Return to gram.exec CVS log

Up to [Research Unix] / researchv10no / cmd / f2c

Annotation of researchv10no/cmd/f2c/gram.exec, revision 1.1

1.1     ! root        1: exec:    iffable
        !             2:        | SDO end_spec intonlyon label intonlyoff opt_comma dospecw
        !             3:                {
        !             4:                if($4->labdefined)
        !             5:                        execerr("no backward DO loops", CNULL);
        !             6:                $4->blklevel = blklevel+1;
        !             7:                exdo($4->labelno, NPNULL, $7);
        !             8:                }
        !             9:        | SDO end_spec opt_comma dospecw
        !            10:                {
        !            11:                exdo((int)(ctls - ctlstack - 2), NPNULL, $4);
        !            12:                NOEXT("DO without label");
        !            13:                }
        !            14:        | SENDDO
        !            15:                { exenddo(NPNULL); }
        !            16:        | logif iffable
        !            17:                { exendif();  thiswasbranch = NO; }
        !            18:        | logif STHEN
        !            19:        | SELSEIF end_spec SLPAR expr SRPAR STHEN
        !            20:                { exelif($4); lastwasbranch = NO; }
        !            21:        | SELSE end_spec
        !            22:                { exelse(); lastwasbranch = NO; }
        !            23:        | SENDIF end_spec
        !            24:                { exendif(); lastwasbranch = NO; }
        !            25:        ;
        !            26: 
        !            27: logif:   SLOGIF end_spec SLPAR expr SRPAR
        !            28:                { exif($4); }
        !            29:        ;
        !            30: 
        !            31: dospec:          name SEQUALS exprlist
        !            32:                { $$ = mkchain((char *)$1, $3); }
        !            33:        ;
        !            34: 
        !            35: dospecw:  dospec
        !            36:        | SWHILE SLPAR expr SRPAR
        !            37:                { $$ = mkchain(CNULL, (chainp)$3); }
        !            38:        ;
        !            39: 
        !            40: iffable:  let lhs SEQUALS expr
        !            41:                { exequals((struct Primblock *)$2, $4); }
        !            42:        | SASSIGN end_spec assignlabel STO name
        !            43:                { exassign($5, $3); }
        !            44:        | SCONTINUE end_spec
        !            45:        | goto
        !            46:        | io
        !            47:                { inioctl = NO; }
        !            48:        | SARITHIF end_spec SLPAR expr SRPAR label SCOMMA label SCOMMA label
        !            49:                { exarif($4, $6, $8, $10);  thiswasbranch = YES; }
        !            50:        | call
        !            51:                { excall($1, LBNULL, 0, labarray); }
        !            52:        | call SLPAR SRPAR
        !            53:                { excall($1, LBNULL, 0, labarray); }
        !            54:        | call SLPAR callarglist SRPAR
        !            55:                { if(nstars < maxlablist)
        !            56:                        excall($1, mklist(revchain($3)), nstars, labarray);
        !            57:                  else
        !            58:                        many("alternate returns", 'l', maxlablist);
        !            59:                }
        !            60:        | SRETURN end_spec opt_expr
        !            61:                { exreturn($3);  thiswasbranch = YES; }
        !            62:        | stop end_spec opt_expr
        !            63:                { exstop($1, $3);  thiswasbranch = $1; }
        !            64:        ;
        !            65: 
        !            66: assignlabel:   SICON
        !            67:                { $$ = mklabel( convci(toklen, token) ); }
        !            68:        ;
        !            69: 
        !            70: let:     SLET
        !            71:                { if(parstate == OUTSIDE)
        !            72:                        {
        !            73:                        newproc();
        !            74:                        startproc(ESNULL, CLMAIN);
        !            75:                        }
        !            76:                }
        !            77:        ;
        !            78: 
        !            79: goto:    SGOTO end_spec label
        !            80:                { exgoto($3);  thiswasbranch = YES; }
        !            81:        | SASGOTO end_spec name
        !            82:                { exasgoto($3);  thiswasbranch = YES; }
        !            83:        | SASGOTO end_spec name opt_comma SLPAR labellist SRPAR
        !            84:                { exasgoto($3);  thiswasbranch = YES; }
        !            85:        | SCOMPGOTO end_spec SLPAR labellist SRPAR opt_comma expr
        !            86:                { if(nstars < maxlablist)
        !            87:                        putcmgo(putx(fixtype($7)), nstars, labarray);
        !            88:                  else
        !            89:                        many("labels in computed GOTO list", 'l', maxlablist);
        !            90:                }
        !            91:        ;
        !            92: 
        !            93: opt_comma:
        !            94:        | SCOMMA
        !            95:        ;
        !            96: 
        !            97: call:    SCALL end_spec name
        !            98:                { nstars = 0; $$ = $3; }
        !            99:        ;
        !           100: 
        !           101: callarglist:  callarg
        !           102:                { $$ = $1 ? mkchain((char *)$1,CHNULL) : CHNULL; }
        !           103:        | callarglist SCOMMA callarg
        !           104:                { $$ = $3 ? mkchain((char *)$3, $1) : $1; }
        !           105:        ;
        !           106: 
        !           107: callarg:  expr
        !           108:        | SSTAR label
        !           109:                { if(nstars < maxlablist) labarray[nstars++] = $2; $$ = 0; }
        !           110:        ;
        !           111: 
        !           112: stop:    SPAUSE
        !           113:                { $$ = 0; }
        !           114:        | SSTOP
        !           115:                { $$ = 2; }
        !           116:        ;
        !           117: 
        !           118: exprlist:  expr
        !           119:                { $$ = mkchain((char *)$1, CHNULL); }
        !           120:        | exprlist SCOMMA expr
        !           121:                { $$ = hookup($1, mkchain((char *)$3,CHNULL) ); }
        !           122:        ;
        !           123: 
        !           124: end_spec:
        !           125:                { if(parstate == OUTSIDE)
        !           126:                        {
        !           127:                        newproc();
        !           128:                        startproc(ESNULL, CLMAIN);
        !           129:                        }
        !           130: 
        !           131: /* This next statement depends on the ordering of the state table encoding */
        !           132: 
        !           133:                  if(parstate < INDATA) enddcl();
        !           134:                }
        !           135:        ;
        !           136: 
        !           137: intonlyon:
        !           138:                { intonly = YES; }
        !           139:        ;
        !           140: 
        !           141: intonlyoff:
        !           142:                { intonly = NO; }
        !           143:        ;

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