Return to gram.exec CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / efl

Annotation of 43BSD/usr.bin/efl/gram.exec, revision 1.1

1.1     ! root        1: exec:    beginexec exec1
        !             2:                { TEST fprintf(diagfile, "exec done\n"); }
        !             3:        ;
        !             4: 
        !             5: beginexec:
        !             6:                { $$ = bgnexec();  if(ncases > 0) ncases = 0; }
        !             7:        ;
        !             8: 
        !             9: exec1:   lhs ASGNOP expr
        !            10:                {
        !            11:                if($1->tag==TCALL)
        !            12:                        {
        !            13:                        dclerr("no statement functions in EFL",
        !            14:                                $1->sthead->namep);
        !            15:                        frexpr($1);
        !            16:                        frexpr($3);
        !            17:                        }
        !            18:                else exasgn($1,$2,$3);
        !            19:                }
        !            20:        | DOUBLEADDOP lhs
        !            21:                { exasgn($2, $1, mkint(1) ); }
        !            22:        | lhs1
        !            23:                { excall($1); }
        !            24:        | CALL lhs1
        !            25:                { excall($2); }
        !            26:        | debug exec enddebug
        !            27:        | LBRACK beginblock stats endblock RBRACK
        !            28:                { TEST fprintf(diagfile, "exec: { stats }\n");
        !            29:                  addexec(); }
        !            30:        | labels exec1
        !            31:                { thisexec->labeled = 1; }
        !            32:        | control
        !            33:                { thisexec->uniffable = 1;  popctl(); }
        !            34:        | branch
        !            35:                { thisexec->brnchend = 1; }
        !            36:        | iostat
        !            37:                { exio($1, 0); }
        !            38:        | null
        !            39:                { exnull(); }
        !            40:        | ESCAPE
        !            41:                {
        !            42:                exnull();
        !            43:                putsii(ICCOMMENT, $1);
        !            44:                cfree($1);
        !            45:                exnull();
        !            46:                }
        !            47:        ;
        !            48: 
        !            49: null:
        !            50:                { TEST fprintf(diagfile, "exec:empty\n"); }
        !            51:        |  CONTINUE
        !            52:                { TEST fprintf(diagfile, "exec: continue\n"); }
        !            53:        ;
        !            54: 
        !            55: beginblock:
        !            56:                {
        !            57:                thisexec->copylab = 1;
        !            58:                ++blklevel;
        !            59:                dclsect = 1;
        !            60:                ndecl[blklevel] = 0;
        !            61:                nhid [blklevel] = 0;
        !            62:                }
        !            63:        ;
        !            64: 
        !            65: endblock:
        !            66:                {
        !            67:                if(ndecl[blklevel]) unhide();
        !            68:                --blklevel;
        !            69:                dclsect = 0;
        !            70:                }
        !            71:        ;
        !            72: 
        !            73: labels:          NAME COLON contnu
        !            74:                { mklabel($1,YES); }
        !            75:        | CONST contnu
        !            76:                { mklabel(mkilab($1),YES); }
        !            77:        | CONST contnu COLON contnu
        !            78:                { mklabel(mkilab($1),YES); }
        !            79:        | DEFAULT COLON contnu
        !            80:                { brkcase(); mkcase(PNULL,1); }
        !            81:        | CASE { brkcase(); }  caselist COLON contnu
        !            82:        ;
        !            83: 
        !            84: caselist:     expr
        !            85:                { mkcase($1,1); }
        !            86:        | caselist COMMA expr
        !            87:                { mkcase($3,1); }
        !            88:        ;
        !            89: 
        !            90: control:  ifclause contnu exec EOS ELSE elsecode contnu exec
        !            91:                { TEST fprintf(diagfile, "if-then-else\n");
        !            92:                  i = $3->brnchend & $8->brnchend;
        !            93:                  addexec();
        !            94:                  $$ = addexec();
        !            95:                  thisexec->brnchend = i;
        !            96:                  TEST fprintf(diagfile, "exec: if(expr) exec else exec\n"); }
        !            97:        | ifclause contnu exec EOS
        !            98:                { TEST fprintf(diagfile, "if-then\n");
        !            99:                  pushlex = 1;
        !           100:                  yyclearin;
        !           101:                  $$ = ifthen();
        !           102:                  TEST fprintf(diagfile, "exec: if(expr) exec\n"); }
        !           103:        | repeat contnu exec until
        !           104:                { TEST fprintf(diagfile, "repeat done\n"); }
        !           105:        | leftcont contnu exec
        !           106:                { TEST fprintf(diagfile, "exec: control exec\n"); $$ = addexec(); }
        !           107:        ;
        !           108: 
        !           109: ifclause:        IF LPAR expr RPAR
        !           110:                { pushctl(STIF,$3); }
        !           111:        ;
        !           112: 
        !           113: elsecode:
        !           114:                {
        !           115:                if(thisctl->breaklab == 0)
        !           116:                        thisctl->breaklab = nextlab();
        !           117:                /* if(thisexec->prevexec->brnchend == 0) */
        !           118:                        exgoto(thisctl->breaklab);
        !           119:                exlab( indifs[thisctl->indifn] = nextlab() );
        !           120:                }
        !           121:        ;
        !           122: 
        !           123: repeat:          REPEAT
        !           124:                { pushctl(STREPEAT, PNULL); }
        !           125:        ;
        !           126: 
        !           127: until:   EOS
        !           128:                { pushlex = 1;
        !           129:                  yyclearin;
        !           130:                  $$ = addexec();
        !           131:                  exgoto(thisctl->xlab);
        !           132:                  TEST fprintf(diagfile, " no until\n"); }
        !           133:        | EOS UNTIL LPAR expr RPAR
        !           134:                { $$ = addexec();
        !           135:                  exnull();
        !           136:                  exlab( indifs[thisctl->indifn] = nextlab() );
        !           137:                  exifgo(mknode(TNOTOP,OPNOT,$4,PNULL), thisctl->xlab);
        !           138:                  TEST fprintf(diagfile, "until\n");
        !           139:                }
        !           140:        ;
        !           141: 
        !           142: branch:          RETURN
        !           143:                { exretn(PNULL); }
        !           144:        | RETURN expr
        !           145:                { exretn($2); }
        !           146:        | break
        !           147:        | GOTO label
        !           148:                { exgoto($2); }
        !           149:        | GO NAME label
        !           150:                { if( !equals($2->namep, "to") )
        !           151:                        execerr("go %s ??\n", $2->namep);
        !           152:                  else   exgoto($3);
        !           153:                }
        !           154:        | GOTO parlablist compgotoindex
        !           155:                { excompgoto($2, $3); }
        !           156:        | GO NAME parlablist compgotoindex
        !           157:                { if(!equals($2->namep, "to") )
        !           158:                        execerr("go %s ??\n", $2->namep);
        !           159:                  else excompgoto($3, $4);
        !           160:                }
        !           161:        ;
        !           162: 
        !           163: parlablist:   LPAR lablist RPAR
        !           164:                { $$ = $2; }
        !           165:        ;
        !           166: 
        !           167: 
        !           168: lablist:   label
        !           169:                { $$ = mkchain($1,CHNULL); }
        !           170:        | lablist COMMA label
        !           171:                { $$ = hookup($1, mkchain($3,CHNULL) ); }
        !           172:        ;
        !           173: 
        !           174: compgotoindex:  expr
        !           175:        | COMMA expr
        !           176:                { $$ = $2; }
        !           177:        ;
        !           178: 
        !           179: 
        !           180: label:   NAME
        !           181:                { $$ = mklabel($1,NO); }
        !           182:        | CONST
        !           183:                { $$ = mklabel(mkilab($1),NO); }
        !           184:        | CASE expr
        !           185:                { $$ = mkcase($2,0); }
        !           186:        | DEFAULT
        !           187:                { $$ = mkcase(PNULL,0); }
        !           188:        ;
        !           189: 
        !           190: break:   brk
        !           191:                { exbrk($1, PNULL, 0); }
        !           192:        | brk CONST
        !           193:                { exbrk($1, $2, 0); }
        !           194:        | brk blocktype
        !           195:                { exbrk($1, PNULL, $2); }
        !           196:        | brk CONST blocktype
        !           197:                { exbrk($1,$2,$3); }
        !           198:        | brk blocktype CONST
        !           199:                { exbrk($1,$3,$2); }
        !           200:        ;
        !           201: 
        !           202: brk:     NEXT          { $$ = 1; }
        !           203:        | BREAK         { $$ = 0; }
        !           204:        | EXIT          { $$ = 0; }
        !           205:        ;
        !           206: 
        !           207: blocktype: WHILE       { $$ = STWHILE; }
        !           208:        | FOR           { $$ = STFOR; }
        !           209:        | DO            { $$ = STDO; }
        !           210:        | REPEAT        { $$ = STREPEAT; }
        !           211:        | SWITCH        { $$ = STSWITCH; }
        !           212:        | PROCEDURE     { $$ = STPROC; }
        !           213:        ;
        !           214: 
        !           215: leftcont:   WHILE LPAR exprnull RPAR
        !           216:                { pushctl(STWHILE, $3);
        !           217:                    TEST fprintf(diagfile, "while(expr)\n"); }
        !           218:        | for forinit fortest forincr
        !           219:                { exlab(thisctl->xlab);
        !           220:                  if($3)
        !           221:                        exifgo(mknode(TNOTOP,OPNOT,$3,PNULL),
        !           222:                                thisctl->breaklab = nextlab() );
        !           223:                  else exnull();
        !           224:                  TEST fprintf(diagfile, "for (forlist)\n"); }
        !           225:        | SWITCH LPAR expr RPAR
        !           226:                { pushctl(STSWITCH,  simple(LVAL,$3));
        !           227:                  TEST fprintf(diagfile, "switch (expr)\n"); }
        !           228:        | do
        !           229:                { pushctl(STDO, $1);
        !           230:                  TEST fprintf(diagfile, "do loop\n"); }
        !           231:        ;
        !           232: 
        !           233: do:      DO expr EOS contnu
        !           234:                { $$ = doloop($2, PNULL, PNULL); }
        !           235:        | DO expr contnu
        !           236:                { $$ = doloop($2, PNULL, PNULL); }
        !           237:        | DO expr COMMA expr EOS contnu
        !           238:                { $$ = doloop($2, $4, PNULL); }
        !           239:        | DO expr COMMA expr contnu
        !           240:                { $$ = doloop($2, $4, PNULL); }
        !           241:        | DO expr COMMA expr COMMA expr EOS contnu
        !           242:                { $$ = doloop($2,$4,$6); }
        !           243:        | DO expr COMMA expr COMMA expr contnu
        !           244:                { $$ = doloop($2,$4,$6); }
        !           245:        ;
        !           246: 
        !           247: for:     FOR LPAR
        !           248:                { pushctl(STFOR, PNULL); }
        !           249:        ;
        !           250: 
        !           251: forinit:  exec COMMA
        !           252:                { exgoto(thisctl->xlab);
        !           253:                  exlab(thisctl->nextlab);
        !           254:                  addexec();
        !           255:                  }
        !           256:        | exec EOS contnu COMMA
        !           257:                { exgoto(thisctl->xlab);
        !           258:                  exlab(thisctl->nextlab);
        !           259:                  addexec();
        !           260:                  }
        !           261:        ;
        !           262: 
        !           263: fortest:  exprnull COMMA
        !           264:        ;
        !           265: 
        !           266: forincr:  exec RPAR
        !           267:                { addexec(); }
        !           268:        | exec EOS contnu RPAR
        !           269:                { addexec(); }
        !           270:        ;
        !           271: 
        !           272: exprnull:      { $$ = 0; }
        !           273:        | expr
        !           274:        ;
        !           275: 
        !           276: debug:   DEBUG contnu
        !           277:                { if(dbgopt) ++dbglevel; }
        !           278:        ;
        !           279: 
        !           280: enddebug:
        !           281:                { if(dbgopt) --dbglevel; }
        !           282:        ;
        !           283: 
        !           284: iostat:          iokwd LPAR iounit COMMA iolist RPAR
        !           285:                { $$ = mkiost($1, $3, $5); }
        !           286:        ;
        !           287: 
        !           288: iokwd:   READBIN               { $$ = 0; }
        !           289:        | WRITEBIN              { $$ = 1; }
        !           290:        | READ  { $$ = 2; }
        !           291:        | WRITE { $$ = 3; }
        !           292:        ;
        !           293: 
        !           294: iounit:          expr
        !           295:        |       { $$ = NULL; }
        !           296:        ;
        !           297: 
        !           298: iolist:          ioitem                { $$ = mkchain($1,CHNULL); }
        !           299:        | iolist COMMA ioitem   { hookup($1, mkchain($3,CHNULL)); }
        !           300:        ;
        !           301: 
        !           302: ioitem:          expr  { $$ = mkioitem($1,CNULL); }
        !           303:        | expr COLON format     { $$ = mkioitem($1,$3); }
        !           304:        | COLON format          { $$ = mkioitem(PNULL,$2); }
        !           305:        | iobrace       { $$ = mkiogroup($1, CNULL, PNULL); }
        !           306:        | do iobrace    { $$ = mkiogroup($2, CNULL, $1); }
        !           307:        | do iobrace COLON format       { $$ = mkiogroup($2,$4,$1); }
        !           308:        | iobrace COLON format  { $$ = mkiogroup($1,$3,PNULL); }
        !           309:        ;
        !           310: 
        !           311: iobrace:   LBRACK  { ++iobrlevel; }   iolist RBRACK
        !           312:                { --iobrlevel;  $$ = $3; }
        !           313:        ;
        !           314: 
        !           315: format:          letter
        !           316:                { $$ = mkformat($1, PNULL, PNULL); }
        !           317:        | letter LPAR expr RPAR
        !           318:                { $$ = mkformat($1, $3, PNULL); }
        !           319:        | letter LPAR expr COMMA expr RPAR
        !           320:                { $$ = mkformat($1,$3,$5); }
        !           321:        | letton CONST lettoff
        !           322:                { $$ = $2->leftp; frexpblock($2); }
        !           323:        ;
        !           324: 
        !           325: letter:   letton   LETTER  lettoff  { $$ = $2; }
        !           326:        ;
        !           327: 
        !           328: letton:                        { lettneed = YES;}
        !           329:        ;
        !           330: 
        !           331: lettoff:                       { lettneed = NO; }
        !           332:        ;
        !           333: 
        !           334: %%
        !           335: 
        !           336: setyydeb()
        !           337: {
        !           338: #ifdef YYDEBUG
        !           339:        extern int yydebug;
        !           340:        yydebug = 1;
        !           341: #endif
        !           342: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.