%{
#include "cc.h"
%}
%union  {
       Node*   node;
       Sym*    sym;
       Ref*    ref;
       Type*   type;
       struct {
               Type*   t;
               char    c;
       } tycl;
       struct {
               Type*   t1;
               Type*   t2;
       } tyty;
       struct {
               Sym*    sym;
               Ref*    ref;
       } syrf;
       long    lval;
       double  dval;
       char*   sval;
       ushort* rval;
}
%type   <syrf>  ltag
%type   <lval>  tname tnlist
%type   <type>  tlist sbody complex
%type   <tycl>  types
%type   <node>  zarglist arglist zcexpr
%type   <node>  name block stmnt cexpr expr xuexpr pexpr
%type   <node>  zelist elist adecl slist uexpr
%type   <node>  xdecor xdecor2 labels label ulstmnt
%type   <node>  adlist edecor tag qual
%type   <node>  abdecor abdecor1 abdecor2 abdecor3
%type   <node>  zexpr lexpr init ilist lcexpr

%left   ';'
%left   ','
%right  '=' LPE LME LMLE LDVE LMDE LRSHE LLSHE LANDE LXORE LORE
%right  '?' ':'
%left   LOROR
%left   LANDAND
%left   '|'
%left   '^'
%left   '&'
%left   LEQ LNE
%left   '<' '>' LLE LGE
%left   LLSH LRSH
%left   '+' '-'
%left   '*' '/' '%'
%right  LMM LPP LMG '.' '[' '('

%token  <sym>   LNAME LTYPE
%token  <dval>  LFCONST LVLCONST LDCONST
%token  <lval>  LCONST LLCONST LUCONST LULCONST
%token  <sval>  LSTRING
%token  <rval>  LLSTRING
%token          LAUTO LBREAK LCASE LCHAR LCONTINUE LDEFAULT LDO
%token          LDOUBLE LELSE LEXTERN LFLOAT LFOR LGOTO
%token  LIF LINT LLONG LREGISTER LRETURN LSHORT LSIZEOF LUSED
%token  LSTATIC LSTRUCT LSWITCH LTYPEDEF LUNION LUNSIGNED LWHILE
%token  LVOID LENUM LSIGNED LCONSTNT LVOLATILE LSET
%%
prog:
|       prog xdecl

/*
* external declarator
*/
xdecl:
       zctlist ';'
       {
               dodecl(xdecl, lastclass, lasttype, Z);
       }
|       zctlist xdlist ';'
|       zctlist xdecor
       {
               lastdcl = T;
               firstarg = S;
               dodecl(xdecl, lastclass, lasttype, $2);
               if(lastdcl == T || lastdcl->etype != TFUNC) {
                       diag($2, "not a function");
                       lastdcl = types[TFUNC];
               }
               thisfn = lastdcl;
               markdcl();
               firstdcl = dclstack;
               argmark($2, 0);
       }
       pdecl
       {
               argmark($2, 1);
       }
       block
       {
               revertdcl();
               if(!debug['H'])
                       codgen($6, $2);
       }

xdlist:
       xdecor
       {
               dodecl(xdecl, lastclass, lasttype, $1);
       }
|       xdecor
       {
               $1 = dodecl(xdecl, lastclass, lasttype, $1);    /* dirty use of $1 */
       }
       '=' init
       {
               doinit($1->sym, $1->type, 0L, $4);
       }
|       xdlist ',' xdlist

xdecor:
       xdecor2
|       '*' garbage xdecor
       {
               $$ = new(OIND, $3, Z);
       }

xdecor2:
       tag
|       '(' xdecor ')'
       {
               $$ = $2;
       }
|       xdecor2 '(' zarglist ')'
       {
               $$ = new(OFUNC, $1, $3);
       }
|       xdecor2 '[' zexpr ']'
       {
               $$ = new(OARRAY, $1, $3);
       }

/*
* automatic declarator
*/
adecl:
       {
               $$ = Z;
       }
|       adecl ctlist ';'
       {
               $$ = dodecl(adecl, lastclass, lasttype, Z);
               if($1 != Z)
                       if($$ != Z)
                               $$ = new(OLIST, $1, $$);
                       else
                               $$ = $1;
       }
|       adecl ctlist adlist ';'
       {
               $$ = $1;
               if($3 != Z) {
                       $$ = $3;
                       if($1 != Z)
                               $$ = new(OLIST, $1, $3);
               }
       }

adlist:
       xdecor
       {
               dodecl(adecl, lastclass, lasttype, $1);
               $$ = Z;
       }
|       xdecor
       {
               $1 = dodecl(adecl, lastclass, lasttype, $1);
       }
       '=' init
       {
               long w;

               w = $1->sym->type->width;
               $$ = doinit($1->sym, $1->type, 0L, $4);
               $$ = contig($1->sym, $$, w);
       }
|       adlist ',' adlist
       {
               $$ = $1;
               if($3 != Z) {
                       $$ = $3;
                       if($1 != Z)
                               $$ = new(OLIST, $1, $3);
               }
       }

/*
* parameter declarator
*/
pdecl:
|       pdecl ctlist pdlist ';'

pdlist:
       xdecor
       {
               dodecl(pdecl, lastclass, lasttype, $1);
       }
|       pdlist ',' pdlist

/*
* structure element declarator
*/
edecl:
       tlist
       {
               lasttype = $1;
       }
       zedlist ';'
|       edecl tlist
       {
               lasttype = $2;
       }
       zedlist ';'

zedlist:                                        /* extension */
       {
               edecl(CXXX, lasttype, S);
       }
|       edlist

edlist:
       edecor
       {
               dodecl(edecl, CXXX, lasttype, $1);
       }
|       edlist ',' edlist

edecor:
       xdecor
       {
               lastbit = 0;
               firstbit = 1;
       }
|       tag ':' lexpr
       {
               $$ = new(OBIT, $1, $3);
       }
|       ':' lexpr
       {
               $$ = new(OBIT, Z, $2);
       }

/*
* abstract declarator
*/
abdecor:
       {
               $$ = (Z);
       }
|       abdecor1

abdecor1:
       '*' garbage
       {
               $$ = new(OIND, (Z), Z);
       }
|       '*' garbage abdecor1
       {
               $$ = new(OIND, $3, Z);
       }
|       abdecor2

abdecor2:
       abdecor3
|       abdecor2 '(' zarglist ')'
       {
               $$ = new(OFUNC, $1, $3);
       }
|       abdecor2 '[' zexpr ']'
       {
               $$ = new(OARRAY, $1, $3);
       }

abdecor3:
       '(' ')'
       {
               $$ = new(OFUNC, (Z), Z);
       }
|       '[' zexpr ']'
       {
               $$ = new(OARRAY, (Z), $2);
       }
|       '(' abdecor1 ')'
       {
               $$ = $2;
       }

init:
       expr
|       '{' ilist '}'
       {
               $$ = new(OINIT, invert($2), Z);
       }

qual:
       '[' lexpr ']'
       {
               $$ = new(OARRAY, $2, Z);
       }
|       '.' tag
       {
               $$ = new(ODOT, $2, Z);
       }
|       '[' lexpr ']' qual
       {
               $$ = new(OARRAY, $2, Z);
               $$ = new(OLIST, $$, $4);
       }
|       '.' tag qual
       {
               $$ = new(ODOT, $2, Z);
               $$ = new(OLIST, $$, $3);
       }

ilist:
       init
|       qual init
       {
               $$ = new(OLIST, $1, $2);
       }
|       qual '=' init
       {
               $$ = new(OLIST, $1, $3);
       }
|       ilist ',' init
       {
               $$ = new(OLIST, $1, $3);
       }
|       ilist ',' qual init
       {
               $$ = new(OLIST, $1, $3);
               $$ = new(OLIST, $$, $4);
       }
|       ilist ',' qual '=' init
       {
               $$ = new(OLIST, $1, $3);
               $$ = new(OLIST, $$, $5);
       }
|       ilist ','

zarglist:
       {
               $$ = Z;
       }
|       arglist
       {
               $$ = invert($1);
       }


arglist:
       name
|       tlist abdecor
       {
               $$ = new(OPROTO, $2, Z);
               $$->type = $1;
       }
|       tlist xdecor
       {
               $$ = new(OPROTO, $2, Z);
               $$->type = $1;
       }
|       '.' '.' '.'
       {
               $$ = new(ODOTDOT, Z, Z);
       }
|       arglist ',' arglist
       {
               $$ = new(OLIST, $1, $3);
       }

block:
       '{' adecl slist '}'
       {
               $$ = invert($3);
               if($2 != Z)
                       $$ = new(OLIST, $2, $$);
       }

slist:
       {
               $$ = Z;
       }
|       slist stmnt
       {
               $$ = new(OLIST, $1, $2);
       }

labels:
       label
|       labels label
       {
               $$ = new(OLIST, $1, $2);
       }

label:
       LCASE expr ':'
       {
               $$ = new(OCASE, $2, Z);
       }
|       LDEFAULT ':'
       {
               $$ = new(OCASE, Z, Z);
       }
|       LNAME ':'
       {
               $$ = new(OLABEL, dcllabel($1, 1), Z);
               if($1->ref)
                       $1->ref->class = CLABEL+CLAST;
       }

stmnt:
       error ';'
       {
               $$ = Z;
       }
|       ulstmnt
|       labels ulstmnt
       {
               $$ = new(OLIST, $1, $2);
       }

ulstmnt:
       zcexpr ';'
|       {
               markdcl();
       }
       block
       {
               revertdcl();
               $$ = $2;
       }
|       LIF '(' cexpr ')' stmnt
       {
               $$ = new(OIF, $3, new(OLIST, $5, Z));
       }
|       LIF '(' cexpr ')' stmnt LELSE stmnt
       {
               $$ = new(OIF, $3, new(OLIST, $5, $7));
       }
|       LFOR '(' zcexpr ';' zcexpr ';' zcexpr ')' stmnt
       {
               $$ = new(OFOR, new(OLIST, $5, new(OLIST, $3, $7)), $9);
       }
|       LWHILE '(' cexpr ')' stmnt
       {
               $$ = new(OWHILE, $3, $5);
       }
|       LDO stmnt LWHILE '(' cexpr ')' ';'
       {
               $$ = new(ODWHILE, $5, $2);
       }
|       LRETURN zcexpr ';'
       {
               $$ = new(ORETURN, $2, Z);
               $$->type = thisfn->link;
       }
|       LSWITCH '(' lcexpr ')' stmnt
       {
               $$ = new(OSWITCH, $3, $5);
       }
|       LBREAK ';'
       {
               $$ = new(OBREAK, Z, Z);
       }
|       LCONTINUE ';'
       {
               $$ = new(OCONTINUE, Z, Z);
       }
|       LGOTO LNAME ';'
       {
               $$ = new(OGOTO, dcllabel($2, 0), Z);
               if($2->ref)
                       $2->ref->class = CLABEL;
       }
|       LUSED '(' zelist ')' ';'
       {
               $$ = new(OUSED, $3, Z);
       }
|       LSET '(' zelist ')' ';'
       {
               $$ = new(OSET, $3, Z);
       }

zcexpr:
       {
               $$ = Z;
       }
|       cexpr

zexpr:
       {
               $$ = Z;
       }
|       lexpr

lexpr:
       expr
       {
               $$ = new(OCAST, $1, Z);
               $$->type = types[TLONG];
       }

lcexpr:
       cexpr
       {
               $$ = new(OCAST, $1, Z);
               $$->type = types[TLONG];
       }

cexpr:
       expr
|       cexpr ',' cexpr
       {
               $$ = new(OCOMMA, $1, $3);
       }

expr:
       xuexpr
|       expr '*' expr
       {
               $$ = new(OMUL, $1, $3);
       }
|       expr '/' expr
       {
               $$ = new(ODIV, $1, $3);
       }
|       expr '%' expr
       {
               $$ = new(OMOD, $1, $3);
       }
|       expr '+' expr
       {
               $$ = new(OADD, $1, $3);
       }
|       expr '-' expr
       {
               $$ = new(OSUB, $1, $3);
       }
|       expr LRSH expr
       {
               $$ = new(OASHR, $1, $3);
       }
|       expr LLSH expr
       {
               $$ = new(OASHL, $1, $3);
       }
|       expr '<' expr
       {
               $$ = new(OLT, $1, $3);
       }
|       expr '>' expr
       {
               $$ = new(OGT, $1, $3);
       }
|       expr LLE expr
       {
               $$ = new(OLE, $1, $3);
       }
|       expr LGE expr
       {
               $$ = new(OGE, $1, $3);
       }
|       expr LEQ expr
       {
               $$ = new(OEQ, $1, $3);
       }
|       expr LNE expr
       {
               $$ = new(ONE, $1, $3);
       }
|       expr '&' expr
       {
               $$ = new(OAND, $1, $3);
       }
|       expr '^' expr
       {
               $$ = new(OXOR, $1, $3);
       }
|       expr '|' expr
       {
               $$ = new(OOR, $1, $3);
       }
|       expr LANDAND expr
       {
               $$ = new(OANDAND, $1, $3);
       }
|       expr LOROR expr
       {
               $$ = new(OOROR, $1, $3);
       }
|       expr '?' cexpr ':' expr
       {
               $$ = new(OCOND, $1, new(OLIST, $3, $5));
       }
|       expr '=' expr
       {
               $$ = new(OAS, $1, $3);
       }
|       expr LPE expr
       {
               $$ = new(OASADD, $1, $3);
       }
|       expr LME expr
       {
               $$ = new(OASSUB, $1, $3);
       }
|       expr LMLE expr
       {
               $$ = new(OASMUL, $1, $3);
       }
|       expr LDVE expr
       {
               $$ = new(OASDIV, $1, $3);
       }
|       expr LMDE expr
       {
               $$ = new(OASMOD, $1, $3);
       }
|       expr LLSHE expr
       {
               $$ = new(OASASHL, $1, $3);
       }
|       expr LRSHE expr
       {
               $$ = new(OASASHR, $1, $3);
       }
|       expr LANDE expr
       {
               $$ = new(OASAND, $1, $3);
       }
|       expr LXORE expr
       {
               $$ = new(OASXOR, $1, $3);
       }
|       expr LORE expr
       {
               $$ = new(OASOR, $1, $3);
       }

xuexpr:
       uexpr
|       '(' tlist abdecor ')' xuexpr
       {
               $$ = new(OCAST, $5, Z);
               dodecl(NODECL, CXXX, $2, $3);
               $$->type = lastdcl;
       }
|       '(' tlist abdecor ')' '{' ilist '}'     /* extension */
       {
               $$ = new(OSTRUCT, $6, Z);
               dodecl(NODECL, CXXX, $2, $3);
               $$->type = lastdcl;
       }

uexpr:
       pexpr
|       '*' xuexpr
       {
               $$ = new(OIND, $2, Z);
       }
|       '&' xuexpr
       {
               $$ = new(OADDR, $2, Z);
       }
|       '+' xuexpr
       {
               $$ = new(OCONST, Z, Z);
               $$->offset = 0;
               $$->type = tint;
               $2 = new(OSUB, $$, $2);

               $$ = new(OCONST, Z, Z);
               $$->offset = 0;
               $$->type = tint;
               $$ = new(OSUB, $$, $2);
       }
|       '-' xuexpr
       {
               $$ = new(OCONST, Z, Z);
               $$->offset = 0;
               $$->type = tint;
               $$ = new(OSUB, $$, $2);
       }
|       '!' xuexpr
       {
               $$ = new(ONOT, $2, Z);
       }
|       '~' xuexpr
       {
               $$ = new(OCONST, Z, Z);
               $$->offset = -1;
               $$->type = tint;
               $$ = new(OXOR, $$, $2);
       }
|       LPP xuexpr
       {
               $$ = new(OPREINC, $2, Z);
       }
|       LMM xuexpr
       {
               $$ = new(OPREDEC, $2, Z);
       }
|       LSIZEOF uexpr
       {
               $$ = new(OSIZE, $2, Z);
       }

pexpr:
       '(' cexpr ')'
       {
               $$ = $2;
       }
|       LSIZEOF '(' tlist abdecor ')'
       {
               $$ = new(OSIZE, Z, Z);
               dodecl(NODECL, CXXX, $3, $4);
               $$->type = lastdcl;
       }
|       pexpr '(' zelist ')'
       {
               $$ = new(OFUNC, $1, Z);
               if($1->op == ONAME)
               if($1->type == T)
                       dodecl(xdecl, CXXX, tint, $$);
               $$->right = invert($3);
       }
|       pexpr '[' cexpr ']'
       {
               $$ = new(OIND, new(OADD, $1, $3), Z);
       }
|       pexpr LMG ltag
       {
               $$ = new(ODOT, new(OIND, $1, Z), Z);
               $$->sym = $3.sym;
               if($3.ref) {
                       $3.ref->class = CSELEM;
                       $$->ref = $3.ref;
               }
       }
|       pexpr '.' ltag
       {
               $$ = new(ODOT, $1, Z);
               $$->sym = $3.sym;
               if($3.ref) {
                       $3.ref->class = CSELEM;
                       $$->ref = $3.ref;
               }
       }
|       pexpr LPP
       {
               $$ = new(OPOSTINC, $1, Z);
       }
|       pexpr LMM
       {
               $$ = new(OPOSTDEC, $1, Z);
       }
|       name
|       LCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = tint;
               $$->offset = $1;
       }
|       LLCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = types[TLONG];
               $$->offset = $1;
       }
|       LUCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = tuint;
               $$->offset = $1;
       }
|       LULCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = types[TULONG];
               $$->offset = $1;
       }
|       LDCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = types[TDOUBLE];
               $$->ud = $1;
       }
|       LFCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = types[TFLOAT];
               $$->ud = $1;
       }
|       LVLCONST
       {
               $$ = new(OCONST, Z, Z);
               $$->type = types[TVLONG];
               $$->ud = $1;
       }
|       LSTRING
       {
               $$ = new(OSTRING, Z, Z);
               $$->us = $1;
               $$->sym = symstring;
               $$->type = typ(TARRAY, types[TCHAR]);
               $$->etype = TARRAY;
               $$->type->width = lnstring;
               $$->class = CSTATIC;
       }
|       LLSTRING
       {
               $$ = new(OLSTRING, Z, Z);
               $$->rs = $1;
               $$->sym = symstring;
               $$->type = typ(TARRAY, types[TUSHORT]);
               $$->etype = TARRAY;
               $$->type->width = lnstring;
               $$->class = CSTATIC;
       }

zelist:
       {
               $$ = Z;
       }
|       elist

elist:
       expr
|       elist ',' elist
       {
               $$ = new(OLIST, $1, $3);
       }

sbody:
       '{'
       {
               $<tyty>$.t1 = strf;
               $<tyty>$.t2 = strl;
               strf = T;
               strl = T;
               lastbit = 0;
               firstbit = 1;
       }
       edecl '}'
       {
               $$ = strf;
               strf = $<tyty>2.t1;
               strl = $<tyty>2.t2;
       }

zctlist:
       {
               lastclass = CXXX;
               lasttype = tint;
       }
|       ctlist

types:
       complex
       {
               $$.t = $1;
               $$.c = CXXX;
       }
|       complex tnlist
       {
               $$.t = $1;
               $$.c = simplec($2);
               if($2 & ~BCLASS)
                       diag(Z, "illegal combination of types 1: %Q/%T", $2, $1);
       }
|       tnlist
       {
               $$.t = simplet($1);
               $$.c = simplec($1);
       }
|       tnlist complex
       {
               $$.t = $2;
               $$.c = simplec($1);
               if($1 & ~BCLASS)
                       diag(Z, "illegal combination of types 1: %Q/%T", $1, $2);
       }
|       tnlist complex tnlist
       {
               $$.t = $2;
               $$.c = simplec($1|$3);
               if(($1|$3) & ~BCLASS)
                       diag(Z, "illegal combination of types 1: %Q/%T", $1|$3, $2);
       }

tlist:
       types
       {
               $$ = $1.t;
               if($1.c != CXXX)
                       diag(Z, "illegal combination of class 3: %s", cnames[$1.c]);
       }

ctlist:
       types
       {
               lasttype = $1.t;
               lastclass = $1.c;
       }

complex:
       LSTRUCT ltag
       {
               dotag($2.sym, TSTRUCT, 0);
               $$ = $2.sym->suetag;
               if($2.ref)
                       $2.ref->class = CSUETAG;
       }
|       LSTRUCT ltag
       {
               dotag($2.sym, TSTRUCT, autobn);
               if($2.ref)
                       $2.ref->class = CSUETAG+CLAST;
       }
       sbody
       {
               $$ = $2.sym->suetag;
               if($$->link != T)
                       diag(Z, "redeclare tag: %s", $2.sym->name);
               $$->link = $4;
               suallign($$);
               dbgprint($2.sym, $$);
       }
|       LSTRUCT sbody
       {
               $$ = typ(TSTRUCT, $2);
               suallign($$);
       }
|       LUNION ltag
       {
               dotag($2.sym, TUNION, 0);
               $$ = $2.sym->suetag;
               if($2.ref)
                       $2.ref->class = CSUETAG;
       }
|       LUNION ltag
       {
               dotag($2.sym, TUNION, autobn);
               if($2.ref)
                       $2.ref->class = CSUETAG+CLAST;
       }
       sbody
       {
               $$ = $2.sym->suetag;
               if($$->link != T)
                       diag(Z, "redeclare tag: %s", $2.sym->name);
               $$->link = $4;
               suallign($$);
               dbgprint($2.sym, $$);
       }
|       LUNION sbody
       {
               $$ = typ(TUNION, $2);
               suallign($$);
       }
|       LENUM ltag
       {
               dotag($2.sym, TENUM, 0);
               $$ = $2.sym->suetag;
               if($$->link == T)
                       $$->link = tint;
               $$ = $$->link;
               if($2.ref)
                       $2.ref->class = CSUETAG;
       }
|       LENUM ltag
       {
               dotag($2.sym, TENUM, autobn);
               if($2.ref)
                       $2.ref->class = CSUETAG+CLAST;
       }
       '{'
       {
               lastenum = 0;
               maxenum = 0;
       }
       enum '}'
       {
               $$ = $2.sym->suetag;
               if($$->link != T)
                       diag(Z, "redeclare tag: %s", $2.sym->name);
               $$->link = maxtype(maxenum);
               $$ = $$->link;
       }
|       LENUM '{'
       {
               lastenum = 0;
               maxenum = 0;
       }
       enum '}'
       {
               $$ = maxtype(maxenum);
       }
|       LTYPE
       {
               $$ = tcopy($1->type);
               if($1->ref)
                       $1->ref->class = CTYPEDEF;
       }

tnlist:
       tname
|       tnlist tname
       {
               $$ = $1 | $2;
               if($1 & $2)
                       if(($1 & $2) == BLONG)
                               $$ |= BVLONG;           /* long long => vlong */
                       else
                               diag(Z, "once is enough: %Q", $1 & $2);
       }


enum:
       LNAME
       {
               doenum($1, Z);
               if($1->ref) {
                       $1->ref->class = CENUM+CLAST;
                       $1->varlineno = $1->ref->lineno;
               }
       }
|       LNAME
       {
               if($1->ref) {
                       $1->ref->class = CENUM+CLAST;
                       $1->varlineno = $1->ref->lineno;
               }
       }
       '=' expr
       {
               doenum($1, $4);
       }
|       enum ','
|       enum ',' enum

tname:
       LCHAR { $$ = BCHAR; }   /* type words */
|       LSHORT { $$ = BSHORT; }
|       LINT { $$ = BINT; }
|       LLONG { $$ = BLONG; }
|       LSIGNED { $$ = BSIGNED; }
|       LUNSIGNED { $$ = BUNSIGNED; }
|       LFLOAT { $$ = BFLOAT; }
|       LDOUBLE { $$ = BDOUBLE; }
|       LVOID { $$ = BVOID; }

|       LAUTO { $$ = BAUTO; }   /* class words */
|       LSTATIC { $$ = BSTATIC; }
|       LEXTERN { $$ = BEXTERN; }
|       LTYPEDEF { $$ = BTYPEDEF; }
|       LREGISTER { $$ = BREGISTER; }

|       LCONSTNT { $$ = 0; }    /* noise words */
|       LVOLATILE { $$ = 0; }

garbage:
|       garbage LCONSTNT
|       garbage LVOLATILE

name:
       LNAME
       {
               $$ = new(ONAME, Z, Z);
               if($1->class == CLOCAL)
                       $1 = mkstatic($1);
               $$->sym = $1;
               $$->type = $1->type;
               $$->etype = TVOID;
               if($$->type != T)
                       $$->etype = $$->type->etype;
               $$->offset = $1->offset;
               $$->class = $1->class;
               $$->ref = $1->ref;
               $1->aused = 1;
               if($$->ref) {
                       $$->ref->class = $$->class;
                       $$->ref->dlineno = $1->varlineno;
               }
       }
tag:
       ltag
       {
               $$ = new(ONAME, Z, Z);
               $$->sym = $1.sym;
               $$->type = $1.sym->type;
               $$->etype = TVOID;
               if($$->type != T)
                       $$->etype = $$->type->etype;
               $$->offset = $1.sym->offset;
               $$->class = $1.sym->class;
               $$->ref = $1.ref;
       }
ltag:
       LNAME
       {
               $$.sym = $1;
               $$.ref = $1->ref;
       }
|       LTYPE
       {
               $$.sym = $1;
               $$.ref = $1->ref;
       }
%%

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.