📄 语法分析.tab.c
字号:
# ifndef YYSTACK_RELOCATE
goto yyoverflowlab;
# else
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
goto yyoverflowlab;
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
{
short *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
# if YYLSP_NEEDED
YYSTACK_RELOCATE (yyls);
# endif
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
#if YYLSP_NEEDED
yylsp = yyls + yysize - 1;
#endif
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yychar1 = YYTRANSLATE (yychar);
#if YYDEBUG
/* We have to keep this `#if YYDEBUG', since we use variables
which are defined only if `YYDEBUG' is set. */
if (yydebug)
{
YYFPRINTF (stderr, "Next token is %d (%s",
yychar, yytname[yychar1]);
/* Give the individual parser a way to print the precise
meaning of a token, for further debugging info. */
# ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
# endif
YYFPRINTF (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %d (%s), ",
yychar, yytname[yychar1]));
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
#if YYLSP_NEEDED
*++yylsp = yylloc;
#endif
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
yystate = yyn;
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
`$$ = $1'.
Otherwise, the following line sets YYVAL to the semantic value of
the lookahead token. This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
#if YYLSP_NEEDED
/* Similarly for the default location. Let the user run additional
commands if for instance locations are ranges. */
yyloc = yylsp[1-yylen];
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
#endif
#if YYDEBUG
/* We have to keep this `#if YYDEBUG', since we use variables which
are defined only if `YYDEBUG' is set. */
if (yydebug)
{
int yyi;
YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
switch (yyn) {
case 1:
#line 18 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 程序归约为：分程序.\n");;
break;}
case 2:
#line 22 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：常量说明部分 变量说明部分 过程说明部分 语句\n");;
break;}
case 3:
#line 23 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：常量说明部分 变量说明部分 语句\n");;
break;}
case 4:
#line 24 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：常量说明部分 过程说明部分 语句\n");;
break;}
case 5:
#line 25 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：变量说明部分 过程说明部分 语句\n");;
break;}
case 6:
#line 26 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：常量说明部分 语句\n");;
break;}
case 7:
#line 27 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：变量说明部分 语句\n");;
break;}
case 8:
#line 28 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：过程说明部分 语句\n");;
break;}
case 9:
#line 29 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 分程序归约为：语句\n");;
break;}
case 10:
#line 33 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 常量说明部分归约为：CONST 常量定义 常量定义串；\n");;
break;}
case 11:
#line 34 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 常量说明部分归约为：CONST 常量常义;\n");;
break;}
case 12:
#line 38 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 常量定义串归约为：常量定义串,常量定义\n");;
break;}
case 13:
#line 39 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 常量定义串归约为：,常量定义\n");;
break;}
case 14:
#line 43 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 常量定义归约为：标识符=整数\n");;
break;}
case 15:
#line 47 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 变量说明部分归约为：VAR 标识符 标识符串 ;\n");;
break;}
case 16:
#line 48 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 变量说明部分归约为：VAR 标识符 ;\n");;
break;}
case 17:
#line 52 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 标识符串归约为：,标识符\n");;
break;}
case 18:
#line 53 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 标识符串归约为：标识符串, 标识符\n");;
break;}
case 19:
#line 57 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 过程说明部分归约为：过程首部 分程序 过程说明串 ;\n");;
break;}
case 20:
#line 58 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 过程说明部分归约为：过程首部 分程序 ;\n");;
break;}
case 21:
#line 62 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 过程说明串归约为：; 过程说明部分\n");;
break;}
case 22:
#line 63 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 过程说明串归约为：过程说明串 ; 过程说明部分\n");;
break;}
case 23:
#line 67 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 过程首部归约为：PROCEDURE 标识符 ;\n");;
break;}
case 24:
#line 71 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：赋值语句\n");;
break;}
case 25:
#line 72 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：复合语句\n");;
break;}
case 26:
#line 73 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：条件语句\n");;
break;}
case 27:
#line 74 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：当型循环语句\n");;
break;}
case 28:
#line 75 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：过程调用语句\n");;
break;}
case 29:
#line 76 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：读语句\n");;
break;}
case 30:
#line 77 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：写语句\n");;
break;}
case 31:
#line 78 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句归约为：空语句\n");;
break;}
case 32:
#line 82 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 赋值语句归约为：标识符 := 表达式\n");;
break;}
case 33:
#line 86 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 复合语句归约为：BEGIN 语句 语句串 END\n");;
break;}
case 34:
#line 87 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 复合语句归约为：BEGIN 语句 END\n");;
break;}
case 35:
#line 91 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句串归约为：; 语句\n");;
break;}
case 36:
#line 92 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 语句串归约为：语句串 ; 语句\n");;
break;}
case 37:
#line 96 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 条件语句归约为：IF 条件 THEN 语句\n");;
break;}
case 38:
#line 100 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 条件归约为：表达式 关系运算符 表达式\n");;
break;}
case 39:
#line 101 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 条件归约为：ODD 表达式\n");;
break;}
case 40:
#line 105 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：+ 项 加法和项的串\n");;
break;}
case 41:
#line 106 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：- 项 加法和项的串\n");;
break;}
case 42:
#line 107 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：项 加法和项的串\n");;
break;}
case 43:
#line 108 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：项\n");;
break;}
case 44:
#line 109 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：+ 项\n");;
break;}
case 45:
#line 110 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 表达式归约为：- 项\n");;
break;}
case 46:
#line 114 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 加法和项的串归约为：加法和项的串 加法运算符 项\n");;
break;}
case 47:
#line 115 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 加法和项的串归约为：加法运算符 项\n");;
break;}
case 48:
#line 119 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 项归约为：因子 乘法运算符和因子的串\n");;
break;}
case 49:
#line 120 "D:\\\323\357\267\250\267\326\316\366.y"
{printf(" 项归约为：因子\n");;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -