myyacc.tab.c

编译原理词法分析器实现四

case 11:
#line 114 "myYacc.y"
{
		  char t[10];
		  genrelation("j>",yyvsp[-2].lexeme.name,yyvsp[0].lexeme.name,nextStat+3);
		  strcpy(yyval.lexeme.name,tempVal.name);
		  genjump("ASSIGN",0,0,yyval.lexeme.name);
		  //printf("%10d\t(jmp,\t0,\t0,\t%d)\n",nextStat++,nextStat+1);
		  nextStat++;
		  sprintf(t, "(%d)", nextStat+1);
		  strcpy(JiLu[nCurrentPosition].m_op, "jmp");
			strcpy(JiLu[nCurrentPosition].m_arg1, "0");
			strcpy(JiLu[nCurrentPosition].m_arg2, "0");
			strcpy(JiLu[nCurrentPosition].m_arg3, t);
			nCurrentPosition++;
		  genjump("ASSIGN",1,0,yyval.lexeme.name);		    
		;
    break;}
case 12:
#line 130 "myYacc.y"
{
		  char t[10];
		  genrelation("j<",yyvsp[-2].lexeme.name,yyvsp[0].lexeme.name,nextStat+3);
		  strcpy(yyval.lexeme.name,tempVal.name);
		  genjump("ASSIGN",0,0,yyval.lexeme.name);
		  //printf("%10d\t(jmp,\t0,\t0,\t%d)\n",nextStat++,nextStat+1);
		  nextStat++;
		  sprintf(t, "(%d)", nextStat+1);
		  strcpy(JiLu[nCurrentPosition].m_op, "jmp");
			strcpy(JiLu[nCurrentPosition].m_arg1, "0");
			strcpy(JiLu[nCurrentPosition].m_arg2, "0");
			strcpy(JiLu[nCurrentPosition].m_arg3, t);
			nCurrentPosition++;
		  genjump("ASSIGN",1,0,yyval.lexeme.name);		    
		;
    break;}
case 13:
#line 146 "myYacc.y"
{
		  strcpy(yyval.lexeme.name,yyvsp[-1].lexeme.name);		
		;
    break;}
case 14:
#line 150 "myYacc.y"
{
		  gen("UMINUS",yyvsp[0].lexeme.name,(char *)(-1));
		  strcpy(yyval.lexeme.name,tempVal.name);		
		;
    break;}
case 15:
#line 155 "myYacc.y"
{
		  strcpy(yyval.lexeme.name,lexeme);
		;
    break;}
case 16:
#line 159 "myYacc.y"
{
		  strcpy(yyval.lexeme.name,lexeme);
		;
    break;}
case 17:
#line 163 "myYacc.y"
{
		  strcpy(yyval.lexeme.name,lexeme);
		;
    break;}
case 18:
#line 167 "myYacc.y"
{
		  gen("And",yyvsp[-2].lexeme.name,yyvsp[0].lexeme.name);
		  strcpy(yyval.lexeme.name,tempVal.name);
		;
    break;}
case 19:
#line 172 "myYacc.y"
{
		  gen("Or",yyvsp[-2].lexeme.name,yyvsp[0].lexeme.name);
		  strcpy(yyval.lexeme.name,tempVal.name);
		;
    break;}
case 20:
#line 177 "myYacc.y"
{
		  gen("Not",yyvsp[0].lexeme.name,(char *)(-1));
		  strcpy(yyval.lexeme.name,tempVal.name);
		;
    break;}
case 21:
#line 182 "myYacc.y"
{
			sprintf(tempVal.name,"temp%d",tempVarCount++);
			strcpy(JiLu[nCurrentPosition].m_op, "[]");
	    strcpy(JiLu[nCurrentPosition].m_arg1, yyvsp[-3].lexeme.name);
	    strcpy(JiLu[nCurrentPosition].m_arg2, yyvsp[-1].lexeme.name);
	    strcpy(JiLu[nCurrentPosition].m_arg3, tempVal.name);
	    strcpy(yyval.lexeme.name,tempVal.name);
	    nCurrentPosition++;
	    nextStat++;
		;
    break;}
case 22:
#line 194 "myYacc.y"
{
			nCurrentXunhuan++;
			rem_bool[nCurrentXunhuan]=nCurrentPosition;
		;
    break;}
case 23:
#line 200 "myYacc.y"
{
			rem_exit[nCurrentXunhuan]=nCurrentPosition;
			strcpy(JiLu[nCurrentPosition].m_op, "bool");
	    strcpy(JiLu[nCurrentPosition].m_arg1, yyvsp[-5].lexeme.name);
	    strcpy(JiLu[nCurrentPosition].m_arg2, "0");
	    strcpy(JiLu[nCurrentPosition].m_arg3, "NULL");
	    nCurrentPosition++;
	    nextStat++;
		;
    break;}
case 24:
#line 211 "myYacc.y"
{
		;
    break;}
case 25:
#line 215 "myYacc.y"
{
			char t[10];
			sprintf(t, "(%d)", rem_bool[nCurrentXunhuan]);
			strcpy(JiLu[nCurrentPosition].m_op, "jmp");
	    strcpy(JiLu[nCurrentPosition].m_arg1, "0");
	    strcpy(JiLu[nCurrentPosition].m_arg2, "0");
	    strcpy(JiLu[nCurrentPosition].m_arg3, t);
	    nCurrentPosition++;
	    nextStat++;
	    sprintf(t, "(%d)", nCurrentPosition);
	    strcpy(JiLu[rem_exit[nCurrentXunhuan]].m_arg3, t);
	    nCurrentXunhuan--;
		;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */

  yyvsp -= yylen;
  yyssp -= yylen;
#ifdef YYLSP_NEEDED
  yylsp -= yylen;
#endif

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

  *++yyvsp = yyval;

#ifdef YYLSP_NEEDED
  yylsp++;
  if (yylen == 0)
    {
      yylsp->first_line = yylloc.first_line;
      yylsp->first_column = yylloc.first_column;
      yylsp->last_line = (yylsp-1)->last_line;
      yylsp->last_column = (yylsp-1)->last_column;
      yylsp->text = 0;
    }
  else
    {
      yylsp->last_line = (yylsp+yylen-1)->last_line;
      yylsp->last_column = (yylsp+yylen-1)->last_column;
    }
#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 */

  if (! yyerrstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
	{
	  int size = 0;
	  char *msg;
	  int x, count;

	  count = 0;
	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
	  for (x = (yyn < 0 ? -yyn : 0);
	       x < (sizeof(yytname) / sizeof(char *)); x++)
	    if (yycheck[x + yyn] == x)
	      size += strlen(yytname[x]) + 15, count++;
	  msg = (char *) malloc(size + 15);
	  if (msg != 0)
	    {
	      strcpy(msg, "parse error");

	      if (count < 5)
		{
		  count = 0;
		  for (x = (yyn < 0 ? -yyn : 0);
		       x < (sizeof(yytname) / sizeof(char *)); x++)
		    if (yycheck[x + yyn] == x)
		      {
			strcat(msg, count == 0 ? ", expecting `" : " or `");
			strcat(msg, yytname[x]);
			strcat(msg, "'");
			count++;
		      }
		}
	      yyerror(msg);
	      free(msg);
	    }
	  else
	    yyerror ("parse error; also virtual memory exceeded");
	}
      else
#endif /* YYERROR_VERBOSE */
	yyerror("parse error");
    }

  goto yyerrlab1;
yyerrlab1:   /* here on error raised explicitly by an action */

  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;

#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

      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. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (yyn) goto yydefault;
#endif

yyerrpop:   /* pop the current state because it cannot handle the error token */

  if (yyssp == yyss) YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#ifdef YYLSP_NEEDED
  yylsp--;
#endif

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

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;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

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

  yystate = yyn;
  goto yynewstate;
}
#line 229 "myYacc.y"

int yyerror(char *s)
{
  fprintf(stderr,"syntactic error:%s in %d\n",s,linesCount);
  return 0;
}

void gen(char *opr,char *arg1,char *arg2)
{
  sprintf(tempVal.name,"temp%d",tempVarCount++);
  if((int)arg2 == -1)
	{
	    //fprintf(stdout,"%10d\t(%s,\t%s,\t0,\t%s)\n",nextStat++,opr,arg1,tempVal.name);
	    strcpy(JiLu[nCurrentPosition].m_op, opr);
	    strcpy(JiLu[nCurrentPosition].m_arg1, arg1);
	    strcpy(JiLu[nCurrentPosition].m_arg2, "0");
	    strcpy(JiLu[nCurrentPosition].m_arg3, tempVal.name);
	    nCurrentPosition++;
	    nextStat++;
	}
  else
  {
	    //fprintf(stdout,"%10d\t(%s,\t%s,\t%s,\t%s)\n",nextStat++,opr,arg1,arg2,tempVal.name);
	    strcpy(JiLu[nCurrentPosition].m_op, opr);
	    strcpy(JiLu[nCurrentPosition].m_arg1, arg1);
	    strcpy(JiLu[nCurrentPosition].m_arg2, arg2);
	    strcpy(JiLu[nCurrentPosition].m_arg3, tempVal.name);
	    nCurrentPosition++;
	    nextStat++;
	}
}

void genjump(char *opr,int a,int b,char *arg)
{
  //fprintf(stdout,"%10d\t(%s,\t%d,\t%d,\t%s)\n",nextStat++,opr,a,b,arg);
  char t1[10];
  char t2[10];
  sprintf(t1, "%d", a);
  sprintf(t2, "%d", b);
  strcpy(JiLu[nCurrentPosition].m_op, opr);
	strcpy(JiLu[nCurrentPosition].m_arg1, t1);
	strcpy(JiLu[nCurrentPosition].m_arg2, t2);
	strcpy(JiLu[nCurrentPosition].m_arg3, arg);
	nCurrentPosition++;
	nextStat++;
}

void genrelation(char *opr,char *arg1,char *arg2,int next)
{
  char t[10];
  sprintf(tempVal.name,"temp%d",tempVarCount++);
  //fprintf(stdout,"%10d\t(%s,\t%s,\t%s,\t%d)\n",nextStat++,opr,arg1,arg2,next);
  
  sprintf(t, "(%d)", next);
  strcpy(JiLu[nCurrentPosition].m_op, opr);
	strcpy(JiLu[nCurrentPosition].m_arg1, arg1);
	strcpy(JiLu[nCurrentPosition].m_arg2, arg2);
	strcpy(JiLu[nCurrentPosition].m_arg3, t);
	nCurrentPosition++;
	nextStat++;
}