| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| /* |
| * Go language grammar. |
| * |
| * The Go semicolon rules are: |
| * |
| * 1. all statements and declarations are terminated by semicolons. |
| * 2. semicolons can be omitted before a closing ) or }. |
| * 3. semicolons are inserted by the lexer before a newline |
| * following a specific list of tokens. |
| * |
| * Rules #1 and #2 are accomplished by writing the lists as |
| * semicolon-separated lists with an optional trailing semicolon. |
| * Rule #3 is implemented in yylex. |
| */ |
| |
| %{ |
| #include <u.h> |
| #include <stdio.h> /* if we don't, bison will, and go.h re-#defines getc */ |
| #include <libc.h> |
| #include "go.h" |
| |
| static void fixlbrace(int); |
| %} |
| %union { |
| Node* node; |
| NodeList* list; |
| Type* type; |
| Sym* sym; |
| struct Val val; |
| int lint; |
| } |
| |
| // |sed 's/.* //' |9 fmt -l1 |sort |9 fmt -l50 | sed 's/^/%xxx /' |
| |
| %token <val> LLITERAL |
| %token <lint> LASOP |
| %token <sym> LBREAK LCASE LCHAN LCOLAS LCONST LCONTINUE LDDD |
| %token <sym> LDEFAULT LDEFER LELSE LFALL LFOR LFUNC LGO LGOTO |
| %token <sym> LIF LIMPORT LINTERFACE LMAP LNAME |
| %token <sym> LPACKAGE LRANGE LRETURN LSELECT LSTRUCT LSWITCH |
| %token <sym> LTYPE LVAR |
| |
| %token LANDAND LANDNOT LBODY LCOMM LDEC LEQ LGE LGT |
| %token LIGNORE LINC LLE LLSH LLT LNE LOROR LRSH |
| |
| %type <lint> lbrace import_here |
| %type <sym> sym packname |
| %type <val> oliteral |
| |
| %type <node> stmt ntype |
| %type <node> arg_type |
| %type <node> case caseblock |
| %type <node> compound_stmt dotname embed expr complitexpr |
| %type <node> expr_or_type |
| %type <node> fndcl fnliteral |
| %type <node> for_body for_header for_stmt if_header if_stmt else non_dcl_stmt |
| %type <node> interfacedcl keyval labelname name |
| %type <node> name_or_type non_expr_type |
| %type <node> new_name dcl_name oexpr typedclname |
| %type <node> onew_name |
| %type <node> osimple_stmt pexpr pexpr_no_paren |
| %type <node> pseudocall range_stmt select_stmt |
| %type <node> simple_stmt |
| %type <node> switch_stmt uexpr |
| %type <node> xfndcl typedcl |
| |
| %type <list> xdcl fnbody fnres loop_body dcl_name_list |
| %type <list> new_name_list expr_list keyval_list braced_keyval_list expr_or_type_list xdcl_list |
| %type <list> oexpr_list caseblock_list stmt_list oarg_type_list_ocomma arg_type_list |
| %type <list> interfacedcl_list vardcl vardcl_list structdcl structdcl_list |
| %type <list> common_dcl constdcl constdcl1 constdcl_list typedcl_list |
| |
| %type <node> convtype comptype dotdotdot |
| %type <node> indcl interfacetype structtype ptrtype |
| %type <node> recvchantype non_recvchantype othertype fnret_type fntype |
| |
| %type <sym> hidden_importsym hidden_pkg_importsym |
| |
| %type <node> hidden_constant hidden_literal hidden_dcl |
| %type <node> hidden_interfacedcl hidden_structdcl hidden_opt_sym |
| |
| %type <list> hidden_funres |
| %type <list> ohidden_funres |
| %type <list> hidden_funarg_list ohidden_funarg_list |
| %type <list> hidden_interfacedcl_list ohidden_interfacedcl_list |
| %type <list> hidden_structdcl_list ohidden_structdcl_list |
| |
| %type <type> hidden_type hidden_type_misc hidden_pkgtype |
| %type <type> hidden_type_func |
| %type <type> hidden_type_recv_chan hidden_type_non_recv_chan |
| |
| %left LCOMM /* outside the usual hierarchy; here for good error messages */ |
| |
| %left LOROR |
| %left LANDAND |
| %left LEQ LNE LLE LGE LLT LGT |
| %left '+' '-' '|' '^' |
| %left '*' '/' '%' '&' LLSH LRSH LANDNOT |
| |
| /* |
| * manual override of shift/reduce conflicts. |
| * the general form is that we assign a precedence |
| * to the token being shifted and then introduce |
| * NotToken with lower precedence or PreferToToken with higher |
| * and annotate the reducing rule accordingly. |
| */ |
| %left NotPackage |
| %left LPACKAGE |
| |
| %left NotParen |
| %left '(' |
| |
| %left ')' |
| %left PreferToRightParen |
| |
| %error-verbose |
| |
| %% |
| file: |
| loadsys |
| package |
| imports |
| xdcl_list |
| { |
| xtop = concat(xtop, $4); |
| } |
| |
| package: |
| %prec NotPackage |
| { |
| prevlineno = lineno; |
| yyerror("package statement must be first"); |
| flusherrors(); |
| mkpackage("main"); |
| } |
| | LPACKAGE sym ';' |
| { |
| mkpackage($2->name); |
| } |
| |
| /* |
| * this loads the definitions for the low-level runtime functions, |
| * so that the compiler can generate calls to them, |
| * but does not make the name "runtime" visible as a package. |
| */ |
| loadsys: |
| { |
| importpkg = runtimepkg; |
| |
| if(debug['A']) |
| cannedimports("runtime.builtin", "package runtime\n\n$$\n\n"); |
| else |
| cannedimports("runtime.builtin", runtimeimport); |
| curio.importsafe = 1; |
| } |
| import_package |
| import_there |
| { |
| importpkg = nil; |
| } |
| |
| imports: |
| | imports import ';' |
| |
| import: |
| LIMPORT import_stmt |
| | LIMPORT '(' import_stmt_list osemi ')' |
| | LIMPORT '(' ')' |
| |
| import_stmt: |
| import_here import_package import_there |
| { |
| Pkg *ipkg; |
| Sym *my; |
| Node *pack; |
| |
| ipkg = importpkg; |
| my = importmyname; |
| importpkg = nil; |
| importmyname = S; |
| |
| if(my == nil) |
| my = lookup(ipkg->name); |
| |
| pack = nod(OPACK, N, N); |
| pack->sym = my; |
| pack->pkg = ipkg; |
| pack->lineno = $1; |
| |
| if(my->name[0] == '.') { |
| importdot(ipkg, pack); |
| break; |
| } |
| if(my->name[0] == '_' && my->name[1] == '\0') |
| break; |
| if(my->def) { |
| lineno = $1; |
| redeclare(my, "as imported package name"); |
| } |
| my->def = pack; |
| my->lastlineno = $1; |
| my->block = 1; // at top level |
| } |
| |
| |
| import_stmt_list: |
| import_stmt |
| | import_stmt_list ';' import_stmt |
| |
| import_here: |
| LLITERAL |
| { |
| // import with original name |
| $$ = parserline(); |
| importmyname = S; |
| importfile(&$1, $$); |
| } |
| | sym LLITERAL |
| { |
| // import with given name |
| $$ = parserline(); |
| importmyname = $1; |
| importfile(&$2, $$); |
| } |
| | '.' LLITERAL |
| { |
| // import into my name space |
| $$ = parserline(); |
| importmyname = lookup("."); |
| importfile(&$2, $$); |
| } |
| |
| import_package: |
| LPACKAGE sym import_safety ';' |
| { |
| if(importpkg->name == nil) { |
| importpkg->name = $2->name; |
| pkglookup($2->name, nil)->npkg++; |
| } else if(strcmp(importpkg->name, $2->name) != 0) |
| yyerror("conflicting names %s and %s for package \"%Z\"", importpkg->name, $2->name, importpkg->path); |
| importpkg->direct = 1; |
| |
| if(safemode && !curio.importsafe) |
| yyerror("cannot import unsafe package \"%Z\"", importpkg->path); |
| } |
| |
| import_safety: |
| | LNAME |
| { |
| if(strcmp($1->name, "safe") == 0) |
| curio.importsafe = 1; |
| } |
| |
| import_there: |
| { |
| defercheckwidth(); |
| } |
| hidden_import_list '$' '$' |
| { |
| resumecheckwidth(); |
| unimportfile(); |
| } |
| |
| /* |
| * declarations |
| */ |
| xdcl: |
| { |
| yyerror("empty top-level declaration"); |
| $$ = nil; |
| } |
| | common_dcl |
| | xfndcl |
| { |
| $$ = list1($1); |
| } |
| | non_dcl_stmt |
| { |
| yyerror("non-declaration statement outside function body"); |
| $$ = nil; |
| } |
| | error |
| { |
| $$ = nil; |
| } |
| |
| common_dcl: |
| LVAR vardcl |
| { |
| $$ = $2; |
| } |
| | LVAR '(' vardcl_list osemi ')' |
| { |
| $$ = $3; |
| } |
| | LVAR '(' ')' |
| { |
| $$ = nil; |
| } |
| | lconst constdcl |
| { |
| $$ = $2; |
| iota = -100000; |
| lastconst = nil; |
| } |
| | lconst '(' constdcl osemi ')' |
| { |
| $$ = $3; |
| iota = -100000; |
| lastconst = nil; |
| } |
| | lconst '(' constdcl ';' constdcl_list osemi ')' |
| { |
| $$ = concat($3, $5); |
| iota = -100000; |
| lastconst = nil; |
| } |
| | lconst '(' ')' |
| { |
| $$ = nil; |
| iota = -100000; |
| } |
| | LTYPE typedcl |
| { |
| $$ = list1($2); |
| } |
| | LTYPE '(' typedcl_list osemi ')' |
| { |
| $$ = $3; |
| } |
| | LTYPE '(' ')' |
| { |
| $$ = nil; |
| } |
| |
| lconst: |
| LCONST |
| { |
| iota = 0; |
| } |
| |
| vardcl: |
| dcl_name_list ntype |
| { |
| $$ = variter($1, $2, nil); |
| } |
| | dcl_name_list ntype '=' expr_list |
| { |
| $$ = variter($1, $2, $4); |
| } |
| | dcl_name_list '=' expr_list |
| { |
| $$ = variter($1, nil, $3); |
| } |
| |
| constdcl: |
| dcl_name_list ntype '=' expr_list |
| { |
| $$ = constiter($1, $2, $4); |
| } |
| | dcl_name_list '=' expr_list |
| { |
| $$ = constiter($1, N, $3); |
| } |
| |
| constdcl1: |
| constdcl |
| | dcl_name_list ntype |
| { |
| $$ = constiter($1, $2, nil); |
| } |
| | dcl_name_list |
| { |
| $$ = constiter($1, N, nil); |
| } |
| |
| typedclname: |
| sym |
| { |
| // different from dclname because the name |
| // becomes visible right here, not at the end |
| // of the declaration. |
| $$ = typedcl0($1); |
| } |
| |
| typedcl: |
| typedclname ntype |
| { |
| $$ = typedcl1($1, $2, 1); |
| } |
| |
| simple_stmt: |
| expr |
| { |
| $$ = $1; |
| } |
| | expr LASOP expr |
| { |
| $$ = nod(OASOP, $1, $3); |
| $$->etype = $2; // rathole to pass opcode |
| } |
| | expr_list '=' expr_list |
| { |
| if($1->next == nil && $3->next == nil) { |
| // simple |
| $$ = nod(OAS, $1->n, $3->n); |
| break; |
| } |
| // multiple |
| $$ = nod(OAS2, N, N); |
| $$->list = $1; |
| $$->rlist = $3; |
| } |
| | expr_list LCOLAS expr_list |
| { |
| if($3->n->op == OTYPESW) { |
| Node *n; |
| |
| n = N; |
| if($3->next != nil) |
| yyerror("expr.(type) must be alone in list"); |
| if($1->next != nil) |
| yyerror("argument count mismatch: %d = %d", count($1), 1); |
| else if($1->n->op != ONAME && $1->n->op != OTYPE && $1->n->op != ONONAME) |
| yyerror("invalid variable name %N in type switch", $1->n); |
| else |
| n = $1->n; |
| $$ = nod(OTYPESW, n, $3->n->right); |
| break; |
| } |
| $$ = colas($1, $3); |
| } |
| | expr LINC |
| { |
| $$ = nod(OASOP, $1, nodintconst(1)); |
| $$->etype = OADD; |
| } |
| | expr LDEC |
| { |
| $$ = nod(OASOP, $1, nodintconst(1)); |
| $$->etype = OSUB; |
| } |
| |
| case: |
| LCASE expr_or_type_list ':' |
| { |
| Node *n; |
| |
| // will be converted to OCASE |
| // right will point to next case |
| // done in casebody() |
| markdcl(); |
| $$ = nod(OXCASE, N, N); |
| $$->list = $2; |
| if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) { |
| // type switch - declare variable |
| n = newname(n->sym); |
| n->used = 1; // TODO(rsc): better job here |
| declare(n, dclcontext); |
| $$->nname = n; |
| } |
| break; |
| } |
| | LCASE expr_or_type_list '=' expr ':' |
| { |
| Node *n; |
| |
| // will be converted to OCASE |
| // right will point to next case |
| // done in casebody() |
| markdcl(); |
| $$ = nod(OXCASE, N, N); |
| if($2->next == nil) |
| n = nod(OAS, $2->n, $4); |
| else { |
| n = nod(OAS2, N, N); |
| n->list = $2; |
| n->rlist = list1($4); |
| } |
| $$->list = list1(n); |
| } |
| | LCASE expr_or_type_list LCOLAS expr ':' |
| { |
| // will be converted to OCASE |
| // right will point to next case |
| // done in casebody() |
| markdcl(); |
| $$ = nod(OXCASE, N, N); |
| $$->list = list1(colas($2, list1($4))); |
| } |
| | LDEFAULT ':' |
| { |
| Node *n; |
| |
| markdcl(); |
| $$ = nod(OXCASE, N, N); |
| if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) { |
| // type switch - declare variable |
| n = newname(n->sym); |
| n->used = 1; // TODO(rsc): better job here |
| declare(n, dclcontext); |
| $$->nname = n; |
| } |
| } |
| |
| compound_stmt: |
| '{' |
| { |
| markdcl(); |
| } |
| stmt_list '}' |
| { |
| $$ = liststmt($3); |
| popdcl(); |
| } |
| |
| caseblock: |
| case |
| { |
| // If the last token read by the lexer was consumed |
| // as part of the case, clear it (parser has cleared yychar). |
| // If the last token read by the lexer was the lookahead |
| // leave it alone (parser has it cached in yychar). |
| // This is so that the stmt_list action doesn't look at |
| // the case tokens if the stmt_list is empty. |
| yylast = yychar; |
| } |
| stmt_list |
| { |
| int last; |
| |
| // This is the only place in the language where a statement |
| // list is not allowed to drop the final semicolon, because |
| // it's the only place where a statement list is not followed |
| // by a closing brace. Handle the error for pedantry. |
| |
| // Find the final token of the statement list. |
| // yylast is lookahead; yyprev is last of stmt_list |
| last = yyprev; |
| |
| if(last > 0 && last != ';' && yychar != '}') |
| yyerror("missing statement after label"); |
| $$ = $1; |
| $$->nbody = $3; |
| popdcl(); |
| } |
| |
| caseblock_list: |
| { |
| $$ = nil; |
| } |
| | caseblock_list caseblock |
| { |
| $$ = list($1, $2); |
| } |
| |
| loop_body: |
| LBODY |
| { |
| markdcl(); |
| } |
| stmt_list '}' |
| { |
| $$ = $3; |
| popdcl(); |
| } |
| |
| range_stmt: |
| expr_list '=' LRANGE expr |
| { |
| $$ = nod(ORANGE, N, $4); |
| $$->list = $1; |
| $$->etype = 0; // := flag |
| } |
| | expr_list LCOLAS LRANGE expr |
| { |
| $$ = nod(ORANGE, N, $4); |
| $$->list = $1; |
| $$->colas = 1; |
| colasdefn($1, $$); |
| } |
| |
| for_header: |
| osimple_stmt ';' osimple_stmt ';' osimple_stmt |
| { |
| // init ; test ; incr |
| if($5 != N && $5->colas != 0) |
| yyerror("cannot declare in the for-increment"); |
| $$ = nod(OFOR, N, N); |
| if($1 != N) |
| $$->ninit = list1($1); |
| $$->ntest = $3; |
| $$->nincr = $5; |
| } |
| | osimple_stmt |
| { |
| // normal test |
| $$ = nod(OFOR, N, N); |
| $$->ntest = $1; |
| } |
| | range_stmt |
| |
| for_body: |
| for_header loop_body |
| { |
| $$ = $1; |
| $$->nbody = concat($$->nbody, $2); |
| } |
| |
| for_stmt: |
| LFOR |
| { |
| markdcl(); |
| } |
| for_body |
| { |
| $$ = $3; |
| popdcl(); |
| } |
| |
| if_header: |
| osimple_stmt |
| { |
| // test |
| $$ = nod(OIF, N, N); |
| $$->ntest = $1; |
| } |
| | osimple_stmt ';' osimple_stmt |
| { |
| // init ; test |
| $$ = nod(OIF, N, N); |
| if($1 != N) |
| $$->ninit = list1($1); |
| $$->ntest = $3; |
| } |
| |
| /* IF cond body (ELSE IF cond body)* (ELSE block)? */ |
| if_stmt: |
| LIF |
| { |
| markdcl(); |
| } |
| if_header |
| { |
| if($3->ntest == N) |
| yyerror("missing condition in if statement"); |
| } |
| loop_body |
| { |
| $3->nbody = $5; |
| } |
| else |
| { |
| popdcl(); |
| $$ = $3; |
| if($7 != N) |
| $$->nelse = list1($7); |
| } |
| |
| else: |
| { |
| $$ = N; |
| } |
| | LELSE if_stmt |
| { |
| $$ = $2; |
| } |
| | LELSE compound_stmt |
| { |
| $$ = $2; |
| } |
| |
| switch_stmt: |
| LSWITCH |
| { |
| markdcl(); |
| } |
| if_header |
| { |
| Node *n; |
| n = $3->ntest; |
| if(n != N && n->op != OTYPESW) |
| n = N; |
| typesw = nod(OXXX, typesw, n); |
| } |
| LBODY caseblock_list '}' |
| { |
| $$ = $3; |
| $$->op = OSWITCH; |
| $$->list = $6; |
| typesw = typesw->left; |
| popdcl(); |
| } |
| |
| select_stmt: |
| LSELECT |
| { |
| typesw = nod(OXXX, typesw, N); |
| } |
| LBODY caseblock_list '}' |
| { |
| $$ = nod(OSELECT, N, N); |
| $$->lineno = typesw->lineno; |
| $$->list = $4; |
| typesw = typesw->left; |
| } |
| |
| /* |
| * expressions |
| */ |
| expr: |
| uexpr |
| | expr LOROR expr |
| { |
| $$ = nod(OOROR, $1, $3); |
| } |
| | expr LANDAND expr |
| { |
| $$ = nod(OANDAND, $1, $3); |
| } |
| | expr LEQ expr |
| { |
| $$ = nod(OEQ, $1, $3); |
| } |
| | expr LNE expr |
| { |
| $$ = nod(ONE, $1, $3); |
| } |
| | expr LLT expr |
| { |
| $$ = nod(OLT, $1, $3); |
| } |
| | expr LLE expr |
| { |
| $$ = nod(OLE, $1, $3); |
| } |
| | expr LGE expr |
| { |
| $$ = nod(OGE, $1, $3); |
| } |
| | expr LGT expr |
| { |
| $$ = nod(OGT, $1, $3); |
| } |
| | expr '+' expr |
| { |
| $$ = nod(OADD, $1, $3); |
| } |
| | expr '-' expr |
| { |
| $$ = nod(OSUB, $1, $3); |
| } |
| | expr '|' expr |
| { |
| $$ = nod(OOR, $1, $3); |
| } |
| | expr '^' expr |
| { |
| $$ = nod(OXOR, $1, $3); |
| } |
| | expr '*' expr |
| { |
| $$ = nod(OMUL, $1, $3); |
| } |
| | expr '/' expr |
| { |
| $$ = nod(ODIV, $1, $3); |
| } |
| | expr '%' expr |
| { |
| $$ = nod(OMOD, $1, $3); |
| } |
| | expr '&' expr |
| { |
| $$ = nod(OAND, $1, $3); |
| } |
| | expr LANDNOT expr |
| { |
| $$ = nod(OANDNOT, $1, $3); |
| } |
| | expr LLSH expr |
| { |
| $$ = nod(OLSH, $1, $3); |
| } |
| | expr LRSH expr |
| { |
| $$ = nod(ORSH, $1, $3); |
| } |
| /* not an expression anymore, but left in so we can give a good error */ |
| | expr LCOMM expr |
| { |
| $$ = nod(OSEND, $1, $3); |
| } |
| |
| uexpr: |
| pexpr |
| | '*' uexpr |
| { |
| $$ = nod(OIND, $2, N); |
| } |
| | '&' uexpr |
| { |
| $$ = nod(OADDR, $2, N); |
| } |
| | '+' uexpr |
| { |
| $$ = nod(OPLUS, $2, N); |
| } |
| | '-' uexpr |
| { |
| $$ = nod(OMINUS, $2, N); |
| } |
| | '!' uexpr |
| { |
| $$ = nod(ONOT, $2, N); |
| } |
| | '~' uexpr |
| { |
| yyerror("the bitwise complement operator is ^"); |
| $$ = nod(OCOM, $2, N); |
| } |
| | '^' uexpr |
| { |
| $$ = nod(OCOM, $2, N); |
| } |
| | LCOMM uexpr |
| { |
| $$ = nod(ORECV, $2, N); |
| } |
| |
| /* |
| * call-like statements that |
| * can be preceded by 'defer' and 'go' |
| */ |
| pseudocall: |
| pexpr '(' ')' |
| { |
| $$ = nod(OCALL, $1, N); |
| } |
| | pexpr '(' expr_or_type_list ocomma ')' |
| { |
| $$ = nod(OCALL, $1, N); |
| $$->list = $3; |
| } |
| | pexpr '(' expr_or_type_list LDDD ocomma ')' |
| { |
| $$ = nod(OCALL, $1, N); |
| $$->list = $3; |
| $$->isddd = 1; |
| } |
| |
| pexpr_no_paren: |
| LLITERAL |
| { |
| $$ = nodlit($1); |
| } |
| | name |
| | pexpr '.' sym |
| { |
| if($1->op == OPACK) { |
| Sym *s; |
| s = restrictlookup($3->name, $1->pkg); |
| $1->used = 1; |
| $$ = oldname(s); |
| break; |
| } |
| $$ = nod(OXDOT, $1, newname($3)); |
| } |
| | pexpr '.' '(' expr_or_type ')' |
| { |
| $$ = nod(ODOTTYPE, $1, $4); |
| } |
| | pexpr '.' '(' LTYPE ')' |
| { |
| $$ = nod(OTYPESW, N, $1); |
| } |
| | pexpr '[' expr ']' |
| { |
| $$ = nod(OINDEX, $1, $3); |
| } |
| | pexpr '[' oexpr ':' oexpr ']' |
| { |
| $$ = nod(OSLICE, $1, nod(OKEY, $3, $5)); |
| } |
| | pseudocall |
| | convtype '(' expr ')' |
| { |
| // conversion |
| $$ = nod(OCALL, $1, N); |
| $$->list = list1($3); |
| } |
| | comptype lbrace braced_keyval_list '}' |
| { |
| // composite expression |
| $$ = nod(OCOMPLIT, N, $1); |
| $$->list = $3; |
| |
| fixlbrace($2); |
| } |
| | pexpr_no_paren '{' braced_keyval_list '}' |
| { |
| // composite expression |
| $$ = nod(OCOMPLIT, N, $1); |
| $$->list = $3; |
| } |
| | '(' expr_or_type ')' '{' braced_keyval_list '}' |
| { |
| yyerror("cannot parenthesize type in composite literal"); |
| // composite expression |
| $$ = nod(OCOMPLIT, N, $2); |
| $$->list = $5; |
| } |
| | fnliteral |
| |
| keyval: |
| expr ':' complitexpr |
| { |
| $$ = nod(OKEY, $1, $3); |
| } |
| |
| complitexpr: |
| expr |
| | '{' braced_keyval_list '}' |
| { |
| $$ = nod(OCOMPLIT, N, N); |
| $$->list = $2; |
| } |
| |
| pexpr: |
| pexpr_no_paren |
| | '(' expr_or_type ')' |
| { |
| $$ = $2; |
| |
| // Need to know on lhs of := whether there are ( ). |
| // Don't bother with the OPAREN in other cases: |
| // it's just a waste of memory and time. |
| switch($$->op) { |
| case ONAME: |
| case ONONAME: |
| case OPACK: |
| case OTYPE: |
| case OLITERAL: |
| $$ = nod(OPAREN, $$, N); |
| } |
| } |
| |
| expr_or_type: |
| expr |
| | non_expr_type %prec PreferToRightParen |
| |
| name_or_type: |
| ntype |
| |
| lbrace: |
| LBODY |
| { |
| $$ = LBODY; |
| } |
| | '{' |
| { |
| $$ = '{'; |
| } |
| |
| /* |
| * names and types |
| * newname is used before declared |
| * oldname is used after declared |
| */ |
| new_name: |
| sym |
| { |
| $$ = newname($1); |
| } |
| |
| dcl_name: |
| sym |
| { |
| $$ = dclname($1); |
| } |
| |
| onew_name: |
| { |
| $$ = N; |
| } |
| | new_name |
| |
| sym: |
| LNAME |
| | hidden_importsym |
| |
| hidden_importsym: |
| '@' LLITERAL '.' LNAME |
| { |
| if($2.u.sval->len == 0) |
| $$ = pkglookup($4->name, importpkg); |
| else |
| $$ = pkglookup($4->name, mkpkg($2.u.sval)); |
| } |
| |
| name: |
| sym %prec NotParen |
| { |
| $$ = oldname($1); |
| if($$->pack != N) |
| $$->pack->used = 1; |
| } |
| |
| labelname: |
| new_name |
| |
| /* |
| * to avoid parsing conflicts, type is split into |
| * channel types |
| * function types |
| * parenthesized types |
| * any other type |
| * the type system makes additional restrictions, |
| * but those are not implemented in the grammar. |
| */ |
| dotdotdot: |
| LDDD |
| { |
| yyerror("final argument in variadic function missing type"); |
| $$ = nod(ODDD, typenod(typ(TINTER)), N); |
| } |
| | LDDD ntype |
| { |
| $$ = nod(ODDD, $2, N); |
| } |
| |
| ntype: |
| recvchantype |
| | fntype |
| | othertype |
| | ptrtype |
| | dotname |
| | '(' ntype ')' |
| { |
| $$ = nod(OTPAREN, $2, N); |
| } |
| |
| non_expr_type: |
| recvchantype |
| | fntype |
| | othertype |
| | '*' non_expr_type |
| { |
| $$ = nod(OIND, $2, N); |
| } |
| |
| non_recvchantype: |
| fntype |
| | othertype |
| | ptrtype |
| | dotname |
| | '(' ntype ')' |
| { |
| $$ = nod(OTPAREN, $2, N); |
| } |
| |
| convtype: |
| fntype |
| | othertype |
| |
| comptype: |
| othertype |
| |
| fnret_type: |
| recvchantype |
| | fntype |
| | othertype |
| | ptrtype |
| | dotname |
| |
| dotname: |
| name |
| | name '.' sym |
| { |
| if($1->op == OPACK) { |
| Sym *s; |
| s = restrictlookup($3->name, $1->pkg); |
| $1->used = 1; |
| $$ = oldname(s); |
| break; |
| } |
| $$ = nod(OXDOT, $1, newname($3)); |
| } |
| |
| othertype: |
| '[' oexpr ']' ntype |
| { |
| $$ = nod(OTARRAY, $2, $4); |
| } |
| | '[' LDDD ']' ntype |
| { |
| // array literal of nelem |
| $$ = nod(OTARRAY, nod(ODDD, N, N), $4); |
| } |
| | LCHAN non_recvchantype |
| { |
| $$ = nod(OTCHAN, $2, N); |
| $$->etype = Cboth; |
| } |
| | LCHAN LCOMM ntype |
| { |
| $$ = nod(OTCHAN, $3, N); |
| $$->etype = Csend; |
| } |
| | LMAP '[' ntype ']' ntype |
| { |
| $$ = nod(OTMAP, $3, $5); |
| } |
| | structtype |
| | interfacetype |
| |
| ptrtype: |
| '*' ntype |
| { |
| $$ = nod(OIND, $2, N); |
| } |
| |
| recvchantype: |
| LCOMM LCHAN ntype |
| { |
| $$ = nod(OTCHAN, $3, N); |
| $$->etype = Crecv; |
| } |
| |
| structtype: |
| LSTRUCT lbrace structdcl_list osemi '}' |
| { |
| $$ = nod(OTSTRUCT, N, N); |
| $$->list = $3; |
| fixlbrace($2); |
| } |
| | LSTRUCT lbrace '}' |
| { |
| $$ = nod(OTSTRUCT, N, N); |
| fixlbrace($2); |
| } |
| |
| interfacetype: |
| LINTERFACE lbrace interfacedcl_list osemi '}' |
| { |
| $$ = nod(OTINTER, N, N); |
| $$->list = $3; |
| fixlbrace($2); |
| } |
| | LINTERFACE lbrace '}' |
| { |
| $$ = nod(OTINTER, N, N); |
| fixlbrace($2); |
| } |
| |
| /* |
| * function stuff |
| * all in one place to show how crappy it all is |
| */ |
| xfndcl: |
| LFUNC fndcl fnbody |
| { |
| $$ = $2; |
| if($$ == N) |
| break; |
| $$->nbody = $3; |
| $$->endlineno = lineno; |
| funcbody($$); |
| } |
| |
| fndcl: |
| dcl_name '(' oarg_type_list_ocomma ')' fnres |
| { |
| Node *n; |
| |
| $3 = checkarglist($3, 1); |
| $$ = nod(ODCLFUNC, N, N); |
| $$->nname = $1; |
| n = nod(OTFUNC, N, N); |
| n->list = $3; |
| n->rlist = $5; |
| if(strcmp($1->sym->name, "init") == 0) { |
| $$->nname = renameinit($1); |
| if($3 != nil || $5 != nil) |
| yyerror("func init must have no arguments and no return values"); |
| } |
| if(strcmp(localpkg->name, "main") == 0 && strcmp($1->sym->name, "main") == 0) { |
| if($3 != nil || $5 != nil) |
| yyerror("func main must have no arguments and no return values"); |
| } |
| // TODO: check if nname already has an ntype |
| $$->nname->ntype = n; |
| funchdr($$); |
| } |
| | '(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')' fnres |
| { |
| Node *rcvr, *t; |
| Node *name; |
| |
| name = newname($4); |
| $2 = checkarglist($2, 0); |
| $6 = checkarglist($6, 1); |
| $$ = N; |
| if($2 == nil) { |
| yyerror("method has no receiver"); |
| break; |
| } |
| if($2->next != nil) { |
| yyerror("method has multiple receivers"); |
| break; |
| } |
| rcvr = $2->n; |
| if(rcvr->op != ODCLFIELD) { |
| yyerror("bad receiver in method"); |
| break; |
| } |
| if(rcvr->right->op == OTPAREN || (rcvr->right->op == OIND && rcvr->right->left->op == OTPAREN)) |
| yyerror("cannot parenthesize receiver type"); |
| |
| $$ = nod(ODCLFUNC, N, N); |
| $$->nname = methodname1(name, rcvr->right); |
| t = nod(OTFUNC, rcvr, N); |
| t->list = $6; |
| t->rlist = $8; |
| $$->nname->ntype = t; |
| $$->shortname = name; |
| funchdr($$); |
| } |
| |
| fntype: |
| LFUNC '(' oarg_type_list_ocomma ')' fnres |
| { |
| $3 = checkarglist($3, 1); |
| $$ = nod(OTFUNC, N, N); |
| $$->list = $3; |
| $$->rlist = $5; |
| } |
| |
| fnbody: |
| { |
| $$ = nil; |
| } |
| | '{' stmt_list '}' |
| { |
| $$ = $2; |
| if($$ == nil) |
| $$ = list1(nod(OEMPTY, N, N)); |
| } |
| |
| fnres: |
| %prec NotParen |
| { |
| $$ = nil; |
| } |
| | fnret_type |
| { |
| $$ = list1(nod(ODCLFIELD, N, $1)); |
| } |
| | '(' oarg_type_list_ocomma ')' |
| { |
| $2 = checkarglist($2, 0); |
| $$ = $2; |
| } |
| |
| fnlitdcl: |
| fntype |
| { |
| closurehdr($1); |
| } |
| |
| fnliteral: |
| fnlitdcl lbrace stmt_list '}' |
| { |
| $$ = closurebody($3); |
| fixlbrace($2); |
| } |
| | fnlitdcl error |
| { |
| $$ = closurebody(nil); |
| } |
| |
| /* |
| * lists of things |
| * note that they are left recursive |
| * to conserve yacc stack. they need to |
| * be reversed to interpret correctly |
| */ |
| xdcl_list: |
| { |
| $$ = nil; |
| } |
| | xdcl_list xdcl ';' |
| { |
| $$ = concat($1, $2); |
| if(nsyntaxerrors == 0) |
| testdclstack(); |
| } |
| |
| vardcl_list: |
| vardcl |
| | vardcl_list ';' vardcl |
| { |
| $$ = concat($1, $3); |
| } |
| |
| constdcl_list: |
| constdcl1 |
| | constdcl_list ';' constdcl1 |
| { |
| $$ = concat($1, $3); |
| } |
| |
| typedcl_list: |
| typedcl |
| { |
| $$ = list1($1); |
| } |
| | typedcl_list ';' typedcl |
| { |
| $$ = list($1, $3); |
| } |
| |
| structdcl_list: |
| structdcl |
| | structdcl_list ';' structdcl |
| { |
| $$ = concat($1, $3); |
| } |
| |
| interfacedcl_list: |
| interfacedcl |
| { |
| $$ = list1($1); |
| } |
| | interfacedcl_list ';' interfacedcl |
| { |
| $$ = list($1, $3); |
| } |
| |
| structdcl: |
| new_name_list ntype oliteral |
| { |
| NodeList *l; |
| |
| for(l=$1; l; l=l->next) { |
| l->n = nod(ODCLFIELD, l->n, $2); |
| l->n->val = $3; |
| } |
| } |
| | embed oliteral |
| { |
| $1->val = $2; |
| $$ = list1($1); |
| } |
| | '(' embed ')' oliteral |
| { |
| $2->val = $4; |
| $$ = list1($2); |
| yyerror("cannot parenthesize embedded type"); |
| } |
| | '*' embed oliteral |
| { |
| $2->right = nod(OIND, $2->right, N); |
| $2->val = $3; |
| $$ = list1($2); |
| } |
| | '(' '*' embed ')' oliteral |
| { |
| $3->right = nod(OIND, $3->right, N); |
| $3->val = $5; |
| $$ = list1($3); |
| yyerror("cannot parenthesize embedded type"); |
| } |
| | '*' '(' embed ')' oliteral |
| { |
| $3->right = nod(OIND, $3->right, N); |
| $3->val = $5; |
| $$ = list1($3); |
| yyerror("cannot parenthesize embedded type"); |
| } |
| |
| packname: |
| LNAME |
| { |
| Node *n; |
| |
| $$ = $1; |
| n = oldname($1); |
| if(n->pack != N) |
| n->pack->used = 1; |
| } |
| | LNAME '.' sym |
| { |
| Pkg *pkg; |
| |
| if($1->def == N || $1->def->op != OPACK) { |
| yyerror("%S is not a package", $1); |
| pkg = localpkg; |
| } else { |
| $1->def->used = 1; |
| pkg = $1->def->pkg; |
| } |
| $$ = restrictlookup($3->name, pkg); |
| } |
| |
| embed: |
| packname |
| { |
| $$ = embedded($1); |
| } |
| |
| interfacedcl: |
| new_name indcl |
| { |
| $$ = nod(ODCLFIELD, $1, $2); |
| ifacedcl($$); |
| } |
| | packname |
| { |
| $$ = nod(ODCLFIELD, N, oldname($1)); |
| } |
| | '(' packname ')' |
| { |
| $$ = nod(ODCLFIELD, N, oldname($2)); |
| yyerror("cannot parenthesize embedded type"); |
| } |
| |
| indcl: |
| '(' oarg_type_list_ocomma ')' fnres |
| { |
| // without func keyword |
| $2 = checkarglist($2, 1); |
| $$ = nod(OTFUNC, fakethis(), N); |
| $$->list = $2; |
| $$->rlist = $4; |
| } |
| |
| /* |
| * function arguments. |
| */ |
| arg_type: |
| name_or_type |
| | sym name_or_type |
| { |
| $$ = nod(ONONAME, N, N); |
| $$->sym = $1; |
| $$ = nod(OKEY, $$, $2); |
| } |
| | sym dotdotdot |
| { |
| $$ = nod(ONONAME, N, N); |
| $$->sym = $1; |
| $$ = nod(OKEY, $$, $2); |
| } |
| | dotdotdot |
| |
| arg_type_list: |
| arg_type |
| { |
| $$ = list1($1); |
| } |
| | arg_type_list ',' arg_type |
| { |
| $$ = list($1, $3); |
| } |
| |
| oarg_type_list_ocomma: |
| { |
| $$ = nil; |
| } |
| | arg_type_list ocomma |
| { |
| $$ = $1; |
| } |
| |
| /* |
| * statement |
| */ |
| stmt: |
| { |
| $$ = N; |
| } |
| | compound_stmt |
| | common_dcl |
| { |
| $$ = liststmt($1); |
| } |
| | non_dcl_stmt |
| | error |
| { |
| $$ = N; |
| } |
| |
| non_dcl_stmt: |
| simple_stmt |
| | for_stmt |
| | switch_stmt |
| | select_stmt |
| | if_stmt |
| | labelname ':' |
| { |
| $1 = nod(OLABEL, $1, N); |
| $1->sym = dclstack; // context, for goto restrictions |
| } |
| stmt |
| { |
| NodeList *l; |
| |
| $1->defn = $4; |
| l = list1($1); |
| if($4) |
| l = list(l, $4); |
| $$ = liststmt(l); |
| } |
| | LFALL |
| { |
| // will be converted to OFALL |
| $$ = nod(OXFALL, N, N); |
| } |
| | LBREAK onew_name |
| { |
| $$ = nod(OBREAK, $2, N); |
| } |
| | LCONTINUE onew_name |
| { |
| $$ = nod(OCONTINUE, $2, N); |
| } |
| | LGO pseudocall |
| { |
| $$ = nod(OPROC, $2, N); |
| } |
| | LDEFER pseudocall |
| { |
| $$ = nod(ODEFER, $2, N); |
| } |
| | LGOTO new_name |
| { |
| $$ = nod(OGOTO, $2, N); |
| $$->sym = dclstack; // context, for goto restrictions |
| } |
| | LRETURN oexpr_list |
| { |
| $$ = nod(ORETURN, N, N); |
| $$->list = $2; |
| if($$->list == nil) { |
| NodeList *l; |
| |
| for(l=curfn->dcl; l; l=l->next) { |
| if(l->n->class == PPARAM) |
| continue; |
| if(l->n->class != PPARAMOUT) |
| break; |
| if(l->n->sym->def != l->n) |
| yyerror("%s is shadowed during return", l->n->sym->name); |
| } |
| } |
| } |
| |
| stmt_list: |
| stmt |
| { |
| $$ = nil; |
| if($1 != N) |
| $$ = list1($1); |
| } |
| | stmt_list ';' stmt |
| { |
| $$ = $1; |
| if($3 != N) |
| $$ = list($$, $3); |
| } |
| |
| new_name_list: |
| new_name |
| { |
| $$ = list1($1); |
| } |
| | new_name_list ',' new_name |
| { |
| $$ = list($1, $3); |
| } |
| |
| dcl_name_list: |
| dcl_name |
| { |
| $$ = list1($1); |
| } |
| | dcl_name_list ',' dcl_name |
| { |
| $$ = list($1, $3); |
| } |
| |
| expr_list: |
| expr |
| { |
| $$ = list1($1); |
| } |
| | expr_list ',' expr |
| { |
| $$ = list($1, $3); |
| } |
| |
| expr_or_type_list: |
| expr_or_type |
| { |
| $$ = list1($1); |
| } |
| | expr_or_type_list ',' expr_or_type |
| { |
| $$ = list($1, $3); |
| } |
| |
| /* |
| * list of combo of keyval and val |
| */ |
| keyval_list: |
| keyval |
| { |
| $$ = list1($1); |
| } |
| | complitexpr |
| { |
| $$ = list1($1); |
| } |
| | keyval_list ',' keyval |
| { |
| $$ = list($1, $3); |
| } |
| | keyval_list ',' complitexpr |
| { |
| $$ = list($1, $3); |
| } |
| |
| braced_keyval_list: |
| { |
| $$ = nil; |
| } |
| | keyval_list ocomma |
| { |
| $$ = $1; |
| } |
| |
| /* |
| * optional things |
| */ |
| osemi: |
| | ';' |
| |
| ocomma: |
| | ',' |
| |
| oexpr: |
| { |
| $$ = N; |
| } |
| | expr |
| |
| oexpr_list: |
| { |
| $$ = nil; |
| } |
| | expr_list |
| |
| osimple_stmt: |
| { |
| $$ = N; |
| } |
| | simple_stmt |
| |
| ohidden_funarg_list: |
| { |
| $$ = nil; |
| } |
| | hidden_funarg_list |
| |
| ohidden_structdcl_list: |
| { |
| $$ = nil; |
| } |
| | hidden_structdcl_list |
| |
| ohidden_interfacedcl_list: |
| { |
| $$ = nil; |
| } |
| | hidden_interfacedcl_list |
| |
| oliteral: |
| { |
| $$.ctype = CTxxx; |
| } |
| | LLITERAL |
| |
| /* |
| * import syntax from header of |
| * an output package |
| */ |
| hidden_import: |
| LIMPORT sym LLITERAL ';' |
| { |
| // Informational: record package name |
| // associated with import path, for use in |
| // human-readable messages. |
| Pkg *p; |
| |
| p = mkpkg($3.u.sval); |
| if(p->name == nil) { |
| p->name = $2->name; |
| pkglookup($2->name, nil)->npkg++; |
| } else if(strcmp(p->name, $2->name) != 0) |
| yyerror("conflicting names %s and %s for package \"%Z\"", p->name, $2->name, p->path); |
| if(!incannedimport && myimportpath != nil && strcmp($3.u.sval->s, myimportpath) == 0) { |
| yyerror("import \"%Z\": package depends on \"%Z\" (import cycle)", importpkg->path, $3.u.sval); |
| errorexit(); |
| } |
| } |
| | LVAR hidden_pkg_importsym hidden_type ';' |
| { |
| importvar($2, $3, PEXTERN); |
| } |
| | LCONST hidden_pkg_importsym '=' hidden_constant ';' |
| { |
| importconst($2, types[TIDEAL], $4); |
| } |
| | LCONST hidden_pkg_importsym hidden_type '=' hidden_constant ';' |
| { |
| importconst($2, $3, $5); |
| } |
| | LTYPE hidden_pkgtype hidden_type ';' |
| { |
| importtype($2, $3); |
| } |
| | LFUNC hidden_pkg_importsym '(' ohidden_funarg_list ')' ohidden_funres ';' |
| { |
| importvar($2, functype(N, $4, $6), PFUNC); |
| } |
| | LFUNC '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres ';' |
| { |
| if($3->next != nil || $3->n->op != ODCLFIELD) { |
| yyerror("bad receiver in method"); |
| YYERROR; |
| } |
| importmethod($5, functype($3->n, $7, $9)); |
| } |
| |
| hidden_pkgtype: |
| hidden_pkg_importsym |
| { |
| $$ = pkgtype($1); |
| importsym($1, OTYPE); |
| } |
| |
| hidden_type: |
| hidden_type_misc |
| | hidden_type_recv_chan |
| | hidden_type_func |
| |
| hidden_type_non_recv_chan: |
| hidden_type_misc |
| | hidden_type_func |
| |
| hidden_type_misc: |
| hidden_importsym |
| { |
| $$ = pkgtype($1); |
| } |
| | LNAME |
| { |
| // predefined name like uint8 |
| $1 = pkglookup($1->name, builtinpkg); |
| if($1->def == N || $1->def->op != OTYPE) { |
| yyerror("%s is not a type", $1->name); |
| $$ = T; |
| } else |
| $$ = $1->def->type; |
| } |
| | '[' ']' hidden_type |
| { |
| $$ = aindex(N, $3); |
| } |
| | '[' LLITERAL ']' hidden_type |
| { |
| $$ = aindex(nodlit($2), $4); |
| } |
| | LMAP '[' hidden_type ']' hidden_type |
| { |
| $$ = maptype($3, $5); |
| } |
| | LSTRUCT '{' ohidden_structdcl_list '}' |
| { |
| $$ = dostruct($3, TSTRUCT); |
| } |
| | LINTERFACE '{' ohidden_interfacedcl_list '}' |
| { |
| $$ = dostruct($3, TINTER); |
| } |
| | '*' hidden_type |
| { |
| $$ = ptrto($2); |
| } |
| | LCHAN hidden_type_non_recv_chan |
| { |
| $$ = typ(TCHAN); |
| $$->type = $2; |
| $$->chan = Cboth; |
| } |
| | LCHAN '(' hidden_type_recv_chan ')' |
| { |
| $$ = typ(TCHAN); |
| $$->type = $3; |
| $$->chan = Cboth; |
| } |
| | LCHAN LCOMM hidden_type |
| { |
| $$ = typ(TCHAN); |
| $$->type = $3; |
| $$->chan = Csend; |
| } |
| |
| hidden_type_recv_chan: |
| LCOMM LCHAN hidden_type |
| { |
| $$ = typ(TCHAN); |
| $$->type = $3; |
| $$->chan = Crecv; |
| } |
| |
| hidden_type_func: |
| LFUNC '(' ohidden_funarg_list ')' ohidden_funres |
| { |
| $$ = functype(nil, $3, $5); |
| } |
| |
| hidden_opt_sym: |
| sym |
| { |
| $$ = newname($1); |
| } |
| | '?' |
| { |
| $$ = N; |
| } |
| |
| hidden_dcl: |
| hidden_opt_sym hidden_type oliteral |
| { |
| $$ = nod(ODCLFIELD, $1, typenod($2)); |
| $$->val = $3; |
| } |
| | hidden_opt_sym LDDD hidden_type oliteral |
| { |
| Type *t; |
| |
| t = typ(TARRAY); |
| t->bound = -1; |
| t->type = $3; |
| $$ = nod(ODCLFIELD, $1, typenod(t)); |
| $$->isddd = 1; |
| $$->val = $4; |
| } |
| |
| hidden_structdcl: |
| sym hidden_type oliteral |
| { |
| $$ = nod(ODCLFIELD, newname($1), typenod($2)); |
| $$->val = $3; |
| } |
| | '?' hidden_type oliteral |
| { |
| Sym *s; |
| |
| s = $2->sym; |
| if(s == S && isptr[$2->etype]) |
| s = $2->type->sym; |
| if(s && s->pkg == builtinpkg) |
| s = lookup(s->name); |
| $$ = embedded(s); |
| $$->right = typenod($2); |
| $$->val = $3; |
| } |
| |
| hidden_interfacedcl: |
| sym '(' ohidden_funarg_list ')' ohidden_funres |
| { |
| $$ = nod(ODCLFIELD, newname($1), typenod(functype(fakethis(), $3, $5))); |
| } |
| |
| ohidden_funres: |
| { |
| $$ = nil; |
| } |
| | hidden_funres |
| |
| hidden_funres: |
| '(' ohidden_funarg_list ')' |
| { |
| $$ = $2; |
| } |
| | hidden_type |
| { |
| $$ = list1(nod(ODCLFIELD, N, typenod($1))); |
| } |
| |
| hidden_literal: |
| LLITERAL |
| { |
| $$ = nodlit($1); |
| } |
| | '-' LLITERAL |
| { |
| $$ = nodlit($2); |
| switch($$->val.ctype){ |
| case CTINT: |
| mpnegfix($$->val.u.xval); |
| break; |
| case CTFLT: |
| mpnegflt($$->val.u.fval); |
| break; |
| default: |
| yyerror("bad negated constant"); |
| } |
| } |
| | sym |
| { |
| $$ = oldname(pkglookup($1->name, builtinpkg)); |
| if($$->op != OLITERAL) |
| yyerror("bad constant %S", $$->sym); |
| } |
| |
| hidden_constant: |
| hidden_literal |
| | '(' hidden_literal '+' hidden_literal ')' |
| { |
| $$ = nodcplxlit($2->val, $4->val); |
| } |
| |
| hidden_pkg_importsym: |
| hidden_importsym |
| { |
| $$ = $1; |
| structpkg = $$->pkg; |
| } |
| |
| hidden_import_list: |
| | hidden_import_list hidden_import |
| |
| hidden_funarg_list: |
| hidden_dcl |
| { |
| $$ = list1($1); |
| } |
| | hidden_funarg_list ',' hidden_dcl |
| { |
| $$ = list($1, $3); |
| } |
| |
| hidden_structdcl_list: |
| hidden_structdcl |
| { |
| $$ = list1($1); |
| } |
| | hidden_structdcl_list ';' hidden_structdcl |
| { |
| $$ = list($1, $3); |
| } |
| |
| hidden_interfacedcl_list: |
| hidden_interfacedcl |
| { |
| $$ = list1($1); |
| } |
| | hidden_interfacedcl_list ';' hidden_interfacedcl |
| { |
| $$ = list($1, $3); |
| } |
| |
| %% |
| |
| static void |
| fixlbrace(int lbr) |
| { |
| // If the opening brace was an LBODY, |
| // set up for another one now that we're done. |
| // See comment in lex.c about loophack. |
| if(lbr == LBODY) |
| loophack = 1; |
| } |
| |