yacc.tab.cpp

c语言的简化编译器

  case 27:
#line 152 "yacc.y"
    {yyval.stm = makeSTMreturn(NULL);;}
    break;

  case 28:
#line 154 "yacc.y"
    {yyval.stm = makeSTMreturn(yyvsp[-1].exp);;}
    break;

  case 29:
#line 156 "yacc.y"
    {yyval.stm = makeSTMif(yyvsp[-2].exp,makeSTMscope(yyvsp[0].stm));;}
    break;

  case 30:
#line 158 "yacc.y"
    {yyval.stm = makeSTMifelse(yyvsp[-4].exp,makeSTMscope(yyvsp[-2].stm),makeSTMscope(yyvsp[0].stm));;}
    break;

  case 31:
#line 160 "yacc.y"
    {yyval.stm = makeSTMwhile(yyvsp[-2].exp,yyvsp[0].stm);;}
    break;

  case 32:
#line 162 "yacc.y"
    {yyval.stm = makeSTMfor(yyvsp[-6].forinit,yyvsp[-4].exp,yyvsp[-2].exp,makeSTMscope(yyvsp[0].stm));;}
    break;

  case 33:
#line 164 "yacc.y"
    {yyval.stm = makeSTMscope(yyvsp[0].stm);;}
    break;

  case 34:
#line 166 "yacc.y"
    {yyval.stm = makeSTMdecl(yyvsp[0].decl);;}
    break;

  case 35:
#line 168 "yacc.y"
    {yyval.stm = makeSTMexp(yyvsp[-1].exp);;}
    break;

  case 36:
#line 172 "yacc.y"
    {yyval.forinit = NULL;;}
    break;

  case 37:
#line 174 "yacc.y"
    {yyval.forinit = yyvsp[0].forinit;;}
    break;

  case 38:
#line 178 "yacc.y"
    {yyval.forinit = yyvsp[0].forinit;;}
    break;

  case 39:
#line 180 "yacc.y"
    {yyval.forinit = yyvsp[-2].forinit; yyval.forinit->next = yyvsp[0].forinit;;}
    break;

  case 40:
#line 184 "yacc.y"
    {yyval.forinit = makeFORINITdecl(yyvsp[0].decl);;}
    break;

  case 41:
#line 186 "yacc.y"
    {yyval.forinit = makeFORINITexp(yyvsp[0].exp);;}
    break;

  case 42:
#line 192 "yacc.y"
    {yyval.exp = makeEXPassignment(yyvsp[-2].lvalue,yyvsp[0].exp);;}
    break;

  case 43:
#line 194 "yacc.y"
    {yyval.exp = makeEXPequals(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 44:
#line 196 "yacc.y"
    {yyval.exp = makeEXPnequals(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 45:
#line 198 "yacc.y"
    {yyval.exp = makeEXPless(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 46:
#line 200 "yacc.y"
    {yyval.exp = makeEXPgreater(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 47:
#line 202 "yacc.y"
    {yyval.exp = makeEXPlequals(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 48:
#line 204 "yacc.y"
    {yyval.exp = makeEXPgequals(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 49:
#line 206 "yacc.y"
    {yyval.exp = makeEXPplus(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 50:
#line 208 "yacc.y"
    {yyval.exp = makeEXPminus(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 51:
#line 210 "yacc.y"
    {yyval.exp = makeEXPmult(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 52:
#line 212 "yacc.y"
    {yyval.exp = makeEXPdiv(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 53:
#line 214 "yacc.y"
    {yyval.exp = makeEXPmodulo(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 54:
#line 216 "yacc.y"
    {yyval.exp = makeEXPand(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 55:
#line 218 "yacc.y"
    {yyval.exp = makeEXPor(yyvsp[-2].exp,yyvsp[0].exp);;}
    break;

  case 56:
#line 220 "yacc.y"
    {yyval.exp = yyvsp[0].exp;;}
    break;

  case 57:
#line 224 "yacc.y"
    {yyval.exp = makeEXPuminus(yyvsp[0].exp);;}
    break;

  case 58:
#line 226 "yacc.y"
    {yyval.exp = makeEXPnot(yyvsp[0].exp);;}
    break;

  case 59:
#line 228 "yacc.y"
    {yyval.exp = makeEXPcast(yyvsp[-2].type,yyvsp[0].exp);;}
    break;

  case 60:
#line 230 "yacc.y"
    {yyval.exp = yyvsp[0].exp;;}
    break;

  case 61:
#line 234 "yacc.y"
    {yyval.exp = makeEXPintconst(yyvsp[0].intconst);;}
    break;

  case 62:
#line 236 "yacc.y"
    {yyval.exp = makeEXPboolconst(yyvsp[0].boolconst);;}
    break;

  case 63:
#line 238 "yacc.y"
    {yyval.exp = makeEXPstringconst(yyvsp[0].stringconst);;}
    break;

  case 64:
#line 240 "yacc.y"
    {yyval.exp = makeEXPlvalue(yyvsp[0].lvalue);;}
    break;

  case 65:
#line 242 "yacc.y"
    {yyval.exp = yyvsp[-1].exp;;}
    break;

  case 66:
#line 244 "yacc.y"
    {yyval.exp = makeEXPcall(yyvsp[-3].identifier,yyvsp[-1].exp);;}
    break;

  case 67:
#line 248 "yacc.y"
    {yyval.exp = NULL;;}
    break;

  case 68:
#line 250 "yacc.y"
    {yyval.exp = yyvsp[0].exp;;}
    break;

  case 69:
#line 254 "yacc.y"
    {yyval.exp = yyvsp[0].exp;;}
    break;

  case 70:
#line 256 "yacc.y"
    {yyval.exp = yyvsp[-2].exp; yyval.exp->next = yyvsp[0].exp;;}
    break;

  case 71:
#line 260 "yacc.y"
    {yyval.lvalue = makeLVALUEid(yyvsp[0].identifier);;}
    break;


    }

/* Line 991 of yacc.c.  */
#line 1559 "yacc.tab.c"

  yyvsp -= yylen;
  yyssp -= yylen;


  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;


  /* 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 - YYNTOKENS] + *yyssp;
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTOKENS];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (YYPACT_NINF < yyn && yyn < YYLAST)
	{
	  YYSIZE_T yysize = 0;
	  int yytype = YYTRANSLATE (yychar);
	  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 && yyx != YYTERROR)
	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
	  yysize += yystrlen ("syntax error, unexpected ") + 1;
	  yysize += yystrlen (yytname[yytype]);
	  yymsg = (char *) YYSTACK_ALLOC (yysize);
	  if (yymsg != 0)
	    {
	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
	      yyp = yystpcpy (yyp, yytname[yytype]);

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



  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)
        {
	  /* Pop the error token.  */
          YYPOPSTACK;
	  /* Pop the rest of the stack.  */
	  while (yyss < yyssp)
	    {
	      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
	      yydestruct (yystos[*yyssp], yyvsp);
	      YYPOPSTACK;
	    }
	  YYABORT;
        }

      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
      yydestruct (yytoken, &yylval);
      yychar = YYEMPTY;

    }

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


/*----------------------------------------------------.
| yyerrlab1 -- error raised explicitly by an action.  |
`----------------------------------------------------*/
yyerrlab1:

  /* Suppress GCC warning that yyerrlab1 is unused when no action
     invokes YYERROR.  */
#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)
  __attribute__ ((__unused__))
#endif


  goto yyerrlab2;


/*---------------------------------------------------------------.
| yyerrlab2 -- pop states until the error token can be shifted.  |
`---------------------------------------------------------------*/
yyerrlab2:
  yyerrstatus = 3;	/* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (yyn != YYPACT_NINF)
	{
	  yyn += YYTERROR;
	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
	    {
	      yyn = yytable[yyn];
	      if (0 < yyn)
		break;
	    }
	}

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
	YYABORT;

      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
      yydestruct (yystos[yystate], yyvsp);
      yyvsp--;
      yystate = *--yyssp;

      YY_STACK_PRINT (yyss, yyssp);
    }

  if (yyn == YYFINAL)
    YYACCEPT;

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

  *++yyvsp = yylval;


  yystate = yyn;
  goto yynewstate;


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

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

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

yyreturn:
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
  return yyresult;
}