Return to yaccpar CVS log

Up to [CSRG BSD Unix] / 42BSD / usr.bin / yacc

Annotation of 42BSD/usr.bin/yacc/yaccpar, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char yaccpar_sccsid[] = "@(#)yaccpar    4.1     (Berkeley)      2/11/83";
                      3: #endif not lint
                      4: 
                      5: #
                      6: # define YYFLAG -1000
                      7: # define YYERROR goto yyerrlab
                      8: # define YYACCEPT return(0)
                      9: # define YYABORT return(1)
                     10: 
                     11: /*     parser for yacc output  */
                     12: 
                     13: #ifdef YYDEBUG
                     14: int yydebug = 0; /* 1 for debugging */
                     15: #endif
                     16: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
                     17: int yychar = -1; /* current input token number */
                     18: int yynerrs = 0;  /* number of errors */
                     19: short yyerrflag = 0;  /* error recovery flag */
                     20: 
                     21: yyparse() {
                     22: 
                     23:        short yys[YYMAXDEPTH];
                     24:        short yyj, yym;
                     25:        register YYSTYPE *yypvt;
                     26:        register short yystate, *yyps, yyn;
                     27:        register YYSTYPE *yypv;
                     28:        register short *yyxi;
                     29: 
                     30:        yystate = 0;
                     31:        yychar = -1;
                     32:        yynerrs = 0;
                     33:        yyerrflag = 0;
                     34:        yyps= &yys[-1];
                     35:        yypv= &yyv[-1];
                     36: 
                     37:  yystack:    /* put a state and value onto the stack */
                     38: 
                     39: #ifdef YYDEBUG
                     40:        if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
                     41: #endif
                     42:                if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
                     43:                *yyps = yystate;
                     44:                ++yypv;
                     45:                *yypv = yyval;
                     46: 
                     47:  yynewstate:
                     48: 
                     49:        yyn = yypact[yystate];
                     50: 
                     51:        if( yyn<= YYFLAG ) goto yydefault; /* simple state */
                     52: 
                     53:        if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
                     54:        if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
                     55: 
                     56:        if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
                     57:                yychar = -1;
                     58:                yyval = yylval;
                     59:                yystate = yyn;
                     60:                if( yyerrflag > 0 ) --yyerrflag;
                     61:                goto yystack;
                     62:                }
                     63: 
                     64:  yydefault:
                     65:        /* default state action */
                     66: 
                     67:        if( (yyn=yydef[yystate]) == -2 ) {
                     68:                if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
                     69:                /* look through exception table */
                     70: 
                     71:                for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
                     72: 
                     73:                while( *(yyxi+=2) >= 0 ){
                     74:                        if( *yyxi == yychar ) break;
                     75:                        }
                     76:                if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
                     77:                }
                     78: 
                     79:        if( yyn == 0 ){ /* error */
                     80:                /* error ... attempt to resume parsing */
                     81: 
                     82:                switch( yyerrflag ){
                     83: 
                     84:                case 0:   /* brand new error */
                     85: 
                     86:                        yyerror( "syntax error" );
                     87:                yyerrlab:
                     88:                        ++yynerrs;
                     89: 
                     90:                case 1:
                     91:                case 2: /* incompletely recovered error ... try again */
                     92: 
                     93:                        yyerrflag = 3;
                     94: 
                     95:                        /* find a state where "error" is a legal shift action */
                     96: 
                     97:                        while ( yyps >= yys ) {
                     98:                           yyn = yypact[*yyps] + YYERRCODE;
                     99:                           if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
                    100:                              yystate = yyact[yyn];  /* simulate a shift of "error" */
                    101:                              goto yystack;
                    102:                              }
                    103:                           yyn = yypact[*yyps];
                    104: 
                    105:                           /* the current yyps has no shift onn "error", pop stack */
                    106: 
                    107: #ifdef YYDEBUG
                    108:                           if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
                    109: #endif
                    110:                           --yyps;
                    111:                           --yypv;
                    112:                           }
                    113: 
                    114:                        /* there is no state on the stack with an error shift ... abort */
                    115: 
                    116:        yyabort:
                    117:                        return(1);
                    118: 
                    119: 
                    120:                case 3:  /* no shift yet; clobber input char */
                    121: 
                    122: #ifdef YYDEBUG
                    123:                        if( yydebug ) printf( "error recovery discards char %d\n", yychar );
                    124: #endif
                    125: 
                    126:                        if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
                    127:                        yychar = -1;
                    128:                        goto yynewstate;   /* try again in the same state */
                    129: 
                    130:                        }
                    131: 
                    132:                }
                    133: 
                    134:        /* reduction by production yyn */
                    135: 
                    136: #ifdef YYDEBUG
                    137:                if( yydebug ) printf("reduce %d\n",yyn);
                    138: #endif
                    139:                yyps -= yyr2[yyn];
                    140:                yypvt = yypv;
                    141:                yypv -= yyr2[yyn];
                    142:                yyval = yypv[1];
                    143:                yym=yyn;
                    144:                        /* consult goto table to find next state */
                    145:                yyn = yyr1[yyn];
                    146:                yyj = yypgo[yyn] + *yyps + 1;
                    147:                if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
                    148:                switch(yym){
                    149:                        $A
                    150:                }
                    151:                goto yystack;  /* stack new state and value */
                    152: 
                    153:        }

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