y_tab.c

现将本人搜集常用的程序设计语言的词法和形式文法提供给大家。其中

#ifndef YYDEBUG_LOOK_AHEAD
YYDEBUG_LOOK_AHEAD(yynew_state, yytoken_num, yytoken_string, yyindent)
int yynew_state;
int yytoken_num;
char * yytoken_string;
int yyindent;
{
    YYDEBUG_INDENT(yyindent);
    printf("          .... look ahead at %s   `%s'\n",
           yytoken_string,
           (0 == yytoken_num)? "\0": YYDEBUG_LEXER_TEXT);
}
#endif /* YYDEBUG_LOOK_AHEAD */
#ifndef YYDEBUG_DISCARD_STATE
YYDEBUG_DISCARD_STATE(yynew_state, yyindent)
int yynew_state;
int yyindent;
{
    if (0 < yyindent)
    {  /* draw the graphics for the reduction */
        YYDEBUG_INDENT(yyindent-1);
        printf("%s", YYDEBUG_REDUCE_STRING);
        putchar('+'); /* left rotated L would look nice */
        printf("  discarding state\n");
        YYDEBUG_INDENT(yyindent-1);
        putchar('|'); /* down arrow would look nice */
        putchar('\n');
    }
    else
    {
        if (0 == yyindent)
            printf("discarding state\n");
        else
            printf("no more states to discard: parser will abort\n");
    }
}
#endif /* YYDEBUG_DISCARD_STATE */
#ifndef YYDEBUG_DISCARD_TOKEN
YYDEBUG_DISCARD_TOKEN(yynew_state, yytoken_num, yytoken_string, yyindent)
int yynew_state;
int yytoken_num;
char * yytoken_string;
int yyindent;
{
    YYDEBUG_INDENT(yyindent);
    printf("discarding token %s\n", yytoken_string);
}
#endif /* YYDEBUG_DISCARD_TOKEN */
#ifndef YYDEBUG_SHIFT_ERROR_LEXEME
YYDEBUG_SHIFT_ERROR_LEXEME(yyold_state, yynew_state, yyindent)
int yyold_state;
int yynew_state;
int yyindent;
{
    YYDEBUG_INDENT(yyindent);
    printf("error\n");
}
#endif /* YYDEBUG_SHIFT_ERROR_LEXEME */
#endif /* YYDEBUG */
int
yyparse()
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;
    extern char *getenv();

    if (yys = getenv("YYDEBUG"))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if (yyn = yydefred[yystate]) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            if (5 > yydebug)
                printf("yydebug: state %d, reading %d (%s)\n", yystate,
                        yychar, yys);
            else
                YYDEBUG_LOOK_AHEAD(yystate, yychar, yys, yyssp-yyss);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            if (5 > yydebug)
                printf("yydebug: state %d, shifting to state %d\n",
                        yystate, yytable[yyn]);
            else
                YYDEBUG_SHIFT_LEXEME(yystate, yytable[yyn], yys, yyssp-yyss);
#endif
        if (yyssp >= yyss + yystacksize - 1)
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#ifdef lint
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#ifdef lint
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    if (5 > yydebug)
                        printf("yydebug: state %d, error recovery shifting\
 to state %d\n", *yyssp, yytable[yyn]);
                    else
                        YYDEBUG_SHIFT_ERROR_LEXEME(*yyssp, yytable[yyn], yyssp-yyss);
#endif
                if (yyssp >= yyss + yystacksize - 1)
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    if (5 > yydebug)
                        printf("yydebug: error recovery discarding state %d\n",
                            *yyssp);
                    else
                        YYDEBUG_DISCARD_STATE(*yyssp, yyssp-yyss-1);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            if (5 > yydebug)
                printf("yydebug: state %d, error recovery discards token %d (%s)\n",
                    yystate, yychar, yys);
            else 
                YYDEBUG_DISCARD_TOKEN(yystate, yychar, yys, yyssp-yyss);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
#if YYDEBUG
    if (yydebug)
        if (5 > yydebug)
            printf("yydebug: state %d, reducing by rule %d (%s)\n",
                    yystate, yyn, yyrule[yyn]);
        else
            YYDEBUG_REDUCE(yystate, yyn, yyrule[yyn], yyssp-yyss-yym, yym);
#endif
    switch (yyn)
    {
case 1:
#line 32 "pascal.y"
{its_a="program";}
break;
case 4:
#line 36 "pascal.y"
{its_a="external-file";}
break;
case 23:
#line 67 "pascal.y"
{its_a="constant";}
break;
case 37:
#line 88 "pascal.y"
{its_a="type";}
break;
case 43:
#line 97 "pascal.y"
{its_a="enumerated-literal";}
break;
case 58:
#line 117 "pascal.y"
{its_a="field";}
break;
case 61:
#line 120 "pascal.y"
{its_a="field";}
break;
case 72:
#line 137 "pascal.y"
{its_a="variable";}
break;
case 74:
#line 139 "pascal.y"
{its_a="don't know";}
break;
case 78:
#line 148 "pascal.y"
{lexical_level--;
			}
break;
case 79:
#line 151 "pascal.y"
{lexical_level--;
			}
break;
case 80:
#line 155 "pascal.y"
{if(param_level==0)its_a="procedure";}
break;
case 81:
#line 156 "pascal.y"
{lexical_level++;}
break;
case 83:
#line 160 "pascal.y"
{if(param_level==0)its_a="function";}
break;
case 84:
#line 161 "pascal.y"
{lexical_level++;}
break;
case 91:
#line 173 "pascal.y"
{param_level++;}
break;
case 92:
#line 173 "pascal.y"
{param_level--;}
break;
case 95:
#line 178 "pascal.y"
{its_a="value-parameter";}
break;
case 97:
#line 179 "pascal.y"
{its_a="var-parameter";}
break;
case 99:
#line 180 "pascal.y"
{its_a="procedure-parameter";}
break;
case 100:
#line 181 "pascal.y"
{lexical_level--;}
break;
case 101:
#line 182 "pascal.y"
{its_a="function-parameter";}
break;
case 102:
#line 182 "pascal.y"
{lexical_level--;}
break;
case 109:
#line 193 "pascal.y"
{its_a="conformant-bound";}
break;
case 195:
#line 332 "pascal.y"
{ 
			if(param_level<2)
			    printf("%s\t%s\n", its_a, lastident);
		    }
break;
#line 1078 "y_tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug && 5 > yydebug)
            printf("yydebug: after reduction, shifting from state 0 to\
 state %d\n", YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                if (5 > yydebug)
                    printf("yydebug: state %d, reading %d (%s)\n",
                        YYFINAL, yychar, yys);
                else
                    YYDEBUG_LOOK_AHEAD(YYFINAL, yychar, yys, yyssp-yyss);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug && 5 > yydebug)
        printf("yydebug: after reduction, shifting from state %d \
to state %d\n", *yyssp, yystate);
#endif
    if (yyssp >= yyss + yystacksize - 1)
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}