Return to error.tab.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / yacc / test

Annotation of 43BSDReno/pgrm/yacc/test/error.tab.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: char yysccsid[] = "@(#)yaccpar 1.3 (Berkeley) 01/21/90";
        !             3: #endif
        !             4: #define YYERRCODE 256
        !             5: short yylhs[] = {                                        -1,
        !             6:     0,
        !             7: };
        !             8: short yylen[] = {                                         2,
        !             9:     1,
        !            10: };
        !            11: short yydefred[] = {                                      0,
        !            12:     1,    0,
        !            13: };
        !            14: short yydgoto[] = {                                       2,
        !            15: };
        !            16: short yysindex[] = {                                   -256,
        !            17:     0,    0,
        !            18: };
        !            19: short yyrindex[] = {                                      0,
        !            20:     0,    0,
        !            21: };
        !            22: short yygindex[] = {                                      0,
        !            23: };
        !            24: #define YYTABLESIZE 0
        !            25: short yytable[] = {                                       1,
        !            26: };
        !            27: short yycheck[] = {                                     256,
        !            28: };
        !            29: #define YYFINAL 2
        !            30: #ifndef YYDEBUG
        !            31: #define YYDEBUG 0
        !            32: #endif
        !            33: #define YYMAXTOKEN 0
        !            34: #if YYDEBUG
        !            35: char *yyname[] = {
        !            36: "end-of-file",
        !            37: };
        !            38: char *yyrule[] = {
        !            39: "$accept : S",
        !            40: "S : error",
        !            41: };
        !            42: #endif
        !            43: #ifndef YYSTYPE
        !            44: typedef int YYSTYPE;
        !            45: #endif
        !            46: #define yyclearin (yychar=(-1))
        !            47: #define yyerrok (yyerrflag=0)
        !            48: #ifndef YYSTACKSIZE
        !            49: #ifdef YYMAXDEPTH
        !            50: #define YYSTACKSIZE YYMAXDEPTH
        !            51: #else
        !            52: #define YYSTACKSIZE 300
        !            53: #endif
        !            54: #endif
        !            55: int yydebug;
        !            56: int yynerrs;
        !            57: int yyerrflag;
        !            58: int yychar;
        !            59: short *yyssp;
        !            60: YYSTYPE *yyvsp;
        !            61: YYSTYPE yyval;
        !            62: YYSTYPE yylval;
        !            63: #define yystacksize YYSTACKSIZE
        !            64: short yyss[YYSTACKSIZE];
        !            65: YYSTYPE yyvs[YYSTACKSIZE];
        !            66: #line 4 "error.y"
        !            67: main(){printf("yyparse() = %d\n",yyparse());}
        !            68: yylex(){return-1;}
        !            69: yyerror(s)char*s;{printf("%s\n",s);}
        !            70: #line 70 "error.tab.c"
        !            71: #define YYABORT goto yyabort
        !            72: #define YYACCEPT goto yyaccept
        !            73: #define YYERROR goto yyerrlab
        !            74: int
        !            75: yyparse()
        !            76: {
        !            77:     register int yym, yyn, yystate;
        !            78: #if YYDEBUG
        !            79:     register char *yys;
        !            80:     extern char *getenv();
        !            81: 
        !            82:     if (yys = getenv("YYDEBUG"))
        !            83:     {
        !            84:         yyn = *yys;
        !            85:         if (yyn == '0')
        !            86:             yydebug = 0;
        !            87:         else if (yyn >= '1' && yyn <= '9')
        !            88:             yydebug = yyn - '0';
        !            89:     }
        !            90: #endif
        !            91: 
        !            92:     yynerrs = 0;
        !            93:     yyerrflag = 0;
        !            94:     yychar = (-1);
        !            95: 
        !            96:     yyssp = yyss;
        !            97:     yyvsp = yyvs;
        !            98:     *yyssp = yystate = 0;
        !            99: 
        !           100: yyloop:
        !           101:     if (yyn = yydefred[yystate]) goto yyreduce;
        !           102:     if (yychar < 0)
        !           103:     {
        !           104:         if ((yychar = yylex()) < 0) yychar = 0;
        !           105: #if YYDEBUG
        !           106:         if (yydebug)
        !           107:         {
        !           108:             yys = 0;
        !           109:             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
        !           110:             if (!yys) yys = "illegal-symbol";
        !           111:             printf("yydebug: state %d, reading %d (%s)\n", yystate,
        !           112:                     yychar, yys);
        !           113:         }
        !           114: #endif
        !           115:     }
        !           116:     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
        !           117:             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
        !           118:     {
        !           119: #if YYDEBUG
        !           120:         if (yydebug)
        !           121:             printf("yydebug: state %d, shifting to state %d\n",
        !           122:                     yystate, yytable[yyn]);
        !           123: #endif
        !           124:         if (yyssp >= yyss + yystacksize - 1)
        !           125:         {
        !           126:             goto yyoverflow;
        !           127:         }
        !           128:         *++yyssp = yystate = yytable[yyn];
        !           129:         *++yyvsp = yylval;
        !           130:         yychar = (-1);
        !           131:         if (yyerrflag > 0)  --yyerrflag;
        !           132:         goto yyloop;
        !           133:     }
        !           134:     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
        !           135:             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
        !           136:     {
        !           137:         yyn = yytable[yyn];
        !           138:         goto yyreduce;
        !           139:     }
        !           140:     if (yyerrflag) goto yyinrecovery;
        !           141: #ifdef lint
        !           142:     goto yynewerror;
        !           143: #endif
        !           144: yynewerror:
        !           145:     yyerror("syntax error");
        !           146: #ifdef lint
        !           147:     goto yyerrlab;
        !           148: #endif
        !           149: yyerrlab:
        !           150:     ++yynerrs;
        !           151: yyinrecovery:
        !           152:     if (yyerrflag < 3)
        !           153:     {
        !           154:         yyerrflag = 3;
        !           155:         for (;;)
        !           156:         {
        !           157:             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
        !           158:                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
        !           159:             {
        !           160: #if YYDEBUG
        !           161:                 if (yydebug)
        !           162:                     printf("yydebug: state %d, error recovery shifting\
        !           163:  to state %d\n", *yyssp, yytable[yyn]);
        !           164: #endif
        !           165:                 if (yyssp >= yyss + yystacksize - 1)
        !           166:                 {
        !           167:                     goto yyoverflow;
        !           168:                 }
        !           169:                 *++yyssp = yystate = yytable[yyn];
        !           170:                 *++yyvsp = yylval;
        !           171:                 goto yyloop;
        !           172:             }
        !           173:             else
        !           174:             {
        !           175: #if YYDEBUG
        !           176:                 if (yydebug)
        !           177:                     printf("yydebug: error recovery discarding state %d\n",
        !           178:                             *yyssp);
        !           179: #endif
        !           180:                 if (yyssp <= yyss) goto yyabort;
        !           181:                 --yyssp;
        !           182:                 --yyvsp;
        !           183:             }
        !           184:         }
        !           185:     }
        !           186:     else
        !           187:     {
        !           188:         if (yychar == 0) goto yyabort;
        !           189: #if YYDEBUG
        !           190:         if (yydebug)
        !           191:         {
        !           192:             yys = 0;
        !           193:             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
        !           194:             if (!yys) yys = "illegal-symbol";
        !           195:             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
        !           196:                     yystate, yychar, yys);
        !           197:         }
        !           198: #endif
        !           199:         yychar = (-1);
        !           200:         goto yyloop;
        !           201:     }
        !           202: yyreduce:
        !           203: #if YYDEBUG
        !           204:     if (yydebug)
        !           205:         printf("yydebug: state %d, reducing by rule %d (%s)\n",
        !           206:                 yystate, yyn, yyrule[yyn]);
        !           207: #endif
        !           208:     yym = yylen[yyn];
        !           209:     yyval = yyvsp[1-yym];
        !           210:     switch (yyn)
        !           211:     {
        !           212:     }
        !           213:     yyssp -= yym;
        !           214:     yystate = *yyssp;
        !           215:     yyvsp -= yym;
        !           216:     yym = yylhs[yyn];
        !           217:     if (yystate == 0 && yym == 0)
        !           218:     {
        !           219: #ifdef YYDEBUG
        !           220:         if (yydebug)
        !           221:             printf("yydebug: after reduction, shifting from state 0 to\
        !           222:  state %d\n", YYFINAL);
        !           223: #endif
        !           224:         yystate = YYFINAL;
        !           225:         *++yyssp = YYFINAL;
        !           226:         *++yyvsp = yyval;
        !           227:         if (yychar < 0)
        !           228:         {
        !           229:             if ((yychar = yylex()) < 0) yychar = 0;
        !           230: #if YYDEBUG
        !           231:             if (yydebug)
        !           232:             {
        !           233:                 yys = 0;
        !           234:                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
        !           235:                 if (!yys) yys = "illegal-symbol";
        !           236:                 printf("yydebug: state %d, reading %d (%s)\n",
        !           237:                         YYFINAL, yychar, yys);
        !           238:             }
        !           239: #endif
        !           240:         }
        !           241:         if (yychar == 0) goto yyaccept;
        !           242:         goto yyloop;
        !           243:     }
        !           244:     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
        !           245:             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        !           246:         yystate = yytable[yyn];
        !           247:     else
        !           248:         yystate = yydgoto[yym];
        !           249: #ifdef YYDEBUG
        !           250:     if (yydebug)
        !           251:         printf("yydebug: after reduction, shifting from state %d \
        !           252: to state %d\n", *yyssp, yystate);
        !           253: #endif
        !           254:     if (yyssp >= yyss + yystacksize - 1)
        !           255:     {
        !           256:         goto yyoverflow;
        !           257:     }
        !           258:     *++yyssp = yystate;
        !           259:     *++yyvsp = yyval;
        !           260:     goto yyloop;
        !           261: yyoverflow:
        !           262:     yyerror("yacc stack overflow");
        !           263: yyabort:
        !           264:     return (1);
        !           265: yyaccept:
        !           266:     return (0);
        !           267: }

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