语法分析.tab.c

PL语言语法分析器

    break;}
case 50:
#line 124 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      乘法运算符和因子的串归约为：乘法运算符和因子的串 乘法运算符 因子\n");;
    break;}
case 51:
#line 125 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      乘法运算符和因子的串归约为：乘法运算符 因子\n");;
    break;}
case 52:
#line 129 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      因子归约为：ID\n");;
    break;}
case 53:
#line 130 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      因子归约为：NUM\n");;
    break;}
case 54:
#line 131 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      因子归约为：( 表达式 )\n");;
    break;}
case 55:
#line 135 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      加法运算符归约为：+\n");;
    break;}
case 56:
#line 136 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      加法运算符归约为：-\n");;
    break;}
case 57:
#line 140 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      乘法运算符归约为：*\n");;
    break;}
case 58:
#line 141 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      乘法运算符归约为：/\n");;
    break;}
case 59:
#line 145 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：=\n");;
    break;}
case 60:
#line 146 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：#\n");;
    break;}
case 61:
#line 147 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：<\n");;
    break;}
case 62:
#line 148 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：>\n");;
    break;}
case 63:
#line 149 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：<=\n");;
    break;}
case 64:
#line 150 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      关系运算符归约为：>=\n");;
    break;}
case 65:
#line 153 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      当型循环语句归约为：WHILE 条件 DO 语句\n");;
    break;}
case 66:
#line 157 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      过程调用语句归约为：CALL 标识符\n");;
    break;}
case 67:
#line 161 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      读语句归约为：READ ( 标识符 标识符串 )\n");;
    break;}
case 68:
#line 162 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      读语句归约为：READ ( 标识符 )\n");;
    break;}
case 69:
#line 166 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      写语句归约为：WRITE ( 表达式 表达式串 )\n");;
    break;}
case 70:
#line 167 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      写语句归约为：WRITE ( 表达式 )\n");;
    break;}
case 71:
#line 171 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      表达式串归约为：表达式串 , 表达式\n");;
    break;}
case 72:
#line 172 "D:\\\323\357\267\250\267\326\316\366.y"
{printf("      表达式串归约为：, 表达式\n");;
    break;}
}

#line 705 "bison.simple"


  yyvsp -= yylen;
  yyssp -= yylen;
#if YYLSP_NEEDED
  yylsp -= yylen;
#endif

#if YYDEBUG
  if (yydebug)
    {
      short *yyssp1 = yyss - 1;
      YYFPRINTF (stderr, "state stack now");
      while (yyssp1 != yyssp)
	YYFPRINTF (stderr, " %d", *++yyssp1);
      YYFPRINTF (stderr, "\n");
    }
#endif

  *++yyvsp = yyval;
#if YYLSP_NEEDED
  *++yylsp = yyloc;
#endif

  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTBASE];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
	{
	  YYSIZE_T yysize = 0;
	  char *yymsg;
	  int yyx, yycount;

	  yycount = 0;
	  /* Start YYX at -YYN if negative to avoid negative indexes in
	     YYCHECK.  */
	  for (yyx = yyn < 0 ? -yyn : 0;
	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
	    if (yycheck[yyx + yyn] == yyx)
	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
	  yysize += yystrlen ("parse error, unexpected ") + 1;
	  yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
	  yymsg = (char *) YYSTACK_ALLOC (yysize);
	  if (yymsg != 0)
	    {
	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
	      yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);

	      if (yycount < 5)
		{
		  yycount = 0;
		  for (yyx = yyn < 0 ? -yyn : 0;
		       yyx < (int) (sizeof (yytname) / sizeof (char *));
		       yyx++)
		    if (yycheck[yyx + yyn] == yyx)
		      {
			const char *yyq = ! yycount ? ", expecting " : " or ";
			yyp = yystpcpy (yyp, yyq);
			yyp = yystpcpy (yyp, yytname[yyx]);
			yycount++;
		      }
		}
	      yyerror (yymsg);
	      YYSTACK_FREE (yymsg);
	    }
	  else
	    yyerror ("parse error; also virtual memory exhausted");
	}
      else
#endif /* defined (YYERROR_VERBOSE) */
	yyerror ("parse error");
    }
  goto yyerrlab1;


/*--------------------------------------------------.
| yyerrlab1 -- error raised explicitly by an action |
`--------------------------------------------------*/
yyerrlab1:
  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
	 error, discard it.  */

      /* return failure if at end of input */
      if (yychar == YYEOF)
	YYABORT;
      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
		  yychar, yytname[yychar1]));
      yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */

  yyerrstatus = 3;		/* Each real token shifted decrements this */

  goto yyerrhandle;


/*-------------------------------------------------------------------.
| yyerrdefault -- current state does not do anything special for the |
| error token.                                                       |
`-------------------------------------------------------------------*/
yyerrdefault:
#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */

  /* If its default is to accept any token, ok.  Otherwise pop it.  */
  yyn = yydefact[yystate];
  if (yyn)
    goto yydefault;
#endif


/*---------------------------------------------------------------.
| yyerrpop -- pop the current state because it cannot handle the |
| error token                                                    |
`---------------------------------------------------------------*/
yyerrpop:
  if (yyssp == yyss)
    YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#if YYLSP_NEEDED
  yylsp--;
#endif

#if YYDEBUG
  if (yydebug)
    {
      short *yyssp1 = yyss - 1;
      YYFPRINTF (stderr, "Error: state stack now");
      while (yyssp1 != yyssp)
	YYFPRINTF (stderr, " %d", *++yyssp1);
      YYFPRINTF (stderr, "\n");
    }
#endif

/*--------------.
| yyerrhandle.  |
`--------------*/
yyerrhandle:
  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yyerrdefault;

  yyn += YYTERROR;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    goto yyerrdefault;

  yyn = yytable[yyn];
  if (yyn < 0)
    {
      if (yyn == YYFLAG)
	goto yyerrpop;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrpop;

  if (yyn == YYFINAL)
    YYACCEPT;

  YYDPRINTF ((stderr, "Shifting error token, "));

  *++yyvsp = yylval;
#if YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

/*---------------------------------------------.
| yyoverflowab -- parser overflow comes here.  |
`---------------------------------------------*/
yyoverflowlab:
  yyerror ("parser stack overflow");
  yyresult = 2;
  /* Fall through.  */

yyreturn:
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
  return yyresult;
}
#line 175 "D:\\\323\357\267\250\267\326\316\366.y"


void print()
{
    printf("              **********************************************\n");
    printf("              *               PL0语法分析器                *\n");
    printf("              **********************************************\n\n");
    printf("\n-------------------------PL0语言包含的所有的终结符如下-------------------------\n");
    printf("关键字：IF THEN WHILE DO READ WRITE CALL BEG END CONST VAR PROCEDURE ODD \n");
    printf("运算符有： + - * / \n"); 
    printf("界符有：; ( ) ,\n");
    printf("关系符有：= := # <= >= < >\n");
    printf("标识符为INDENTIFIER 整数为INTEGER\n");
    printf("--------------------------------------------------------------------------\n\n\n\n");
}

int main()
{
    FILE * fp;
    char FILENAME[30];
    char ch;
    print();
    printf("          现在进行语法分析，采用的输入方式是从文件输入。\n");
    printf("          你可以将自己的PL0程序存入文本文件，我们提供了\n");
    printf("          两个PL0程序测试文件:test1.txt和test2.txt\n");
    printf("请输入文件名:\n");
    scanf("%s",FILENAME);
    if((fp=fopen(FILENAME,"r"))==NULL)
    { 
    	printf("对不起，不存在这样的文件!\n");
        return 1;
    }
   printf
("\n********************************************************************************\n");
    printf("你给与的PL0程序如下：\n");
    ch=fgetc(fp);
    while(ch!=EOF)
        {
            putchar(ch);
            ch=fgetc(fp);
         } 
    printf
("\n********************************************************************************\n\n\n");
   /*fclose(fp);
    if((fp=fopen(FILENAME,"r"))==NULL)
    { 
    	printf("对不起，不存在这样的文件!\n");
        return 1;
    }*/
    rewind(fp);
    printf("------------------------------------------------------------------------------\n");
    printf("\n现在开始语法分析:\n\n");
    yyin=fp;
    yyparse();
    fclose(fp);
    printf("                       ------------------------\n");
    printf("                      |       归约成功！        |\n ");
    printf("                      ------------------------\n\n\n");
    printf("------------------------------------------------------------------------------\n");
    return 0;
}

int yyerror(char * msg)
{
	printf("错误:%s 在行号为:%d\n",msg, yylinenumber);
        return 0;
}