yacc.tab.c

C语言表达式语法分析器

case 53:
#line 155 "yacc"
{yyval.tptr=(symrec *)malloc(sizeof(symrec));yyval.tptr->name=(char *)malloc(255);sprintf(yyval.tptr->name,"%s%d","t",ii++);yyval.tptr->val.var=yyvsp[-2].tptr->val.var&&yyvsp[0].tptr->val.var;printf("%.2f\t\t%s=%s%s%s\n",yyval.tptr->val.var,yyval.tptr->name,yyvsp[-2].tptr->name,"&&",yyvsp[0].tptr->name);fprintf(fout,"%s,%s,%s,%s\n","&&",yyvsp[-2].tptr->name,yyvsp[0].tptr->name,yyval.tptr->name);fflush(fout);;
    break;}
case 54:
#line 159 "yacc"
{yyval.tptr=yyvsp[0].tptr;;
    break;}
case 55:
#line 160 "yacc"
{yyval.tptr=(symrec *)malloc(sizeof(symrec));yyval.tptr->name=(char *)malloc(255);sprintf(yyval.tptr->name,"%s%d","t",ii++);yyval.tptr->val.var=yyvsp[-2].tptr->val.var||yyvsp[0].tptr->val.var;printf("%.2f\t\t%s=%s%s%s\n",yyval.tptr->val.var,yyval.tptr->name,yyvsp[-2].tptr->name,"||",yyvsp[0].tptr->name);fprintf(fout,"%s,%s,%s,%s\n","||",yyvsp[-2].tptr->name,yyvsp[0].tptr->name,yyval.tptr->name);fflush(fout);;
    break;}
case 56:
#line 164 "yacc"
{yyval.tptr=yyvsp[0].tptr;;
    break;}
case 57:
#line 165 "yacc"
{yyval.tptr=(symrec *)malloc(sizeof(symrec));yyval.tptr->name=(char *)malloc(255);sprintf(yyval.tptr->name,"%s%d","t",ii++);yyval.tptr->val.var=yyvsp[-4].tptr->val.var?yyvsp[-2].tptr->val.var : yyvsp[0].tptr->val.var;printf("%.2f\t\t%s=%s%s%s%s%s\n",yyval.tptr->val.var,yyval.tptr->name,yyvsp[-4].tptr->name,"?",yyvsp[-2].tptr->name,":",yyvsp[0].tptr->name);/*fprintf(fout,"%s=%s%s%s%s%s\n",$$->name,$1->name,"?",$3->name,":",$5->name);fflush(fout);*/;
    break;}
case 58:
#line 169 "yacc"
{yyval.tptr=yyvsp[0].tptr;;
    break;}
case 59:
#line 170 "yacc"
{yyvsp[-2].tptr->val.var=assignment_in(yyvsp[-2].tptr->val.var,yyvsp[-1].valc,yyvsp[0].tptr->val.var);yyval.tptr=yyvsp[-2].tptr;printf("%.2f\t\t%s%s%s\n",yyval.tptr->val.var,yyval.tptr->name,yyvsp[-1].valc,yyvsp[0].tptr->name);fprintf(fout,"%s,%s,%s,%s\n",yyvsp[-1].valc,yyvsp[0].tptr->name," ",yyval.tptr->name);fflush(fout);;
    break;}
case 60:
#line 174 "yacc"
{yyval.valc=(char * )malloc(255);yyval.valc[0]='=';yyval.valc[1]='\0';;
    break;}
case 61:
#line 175 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 62:
#line 176 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 63:
#line 177 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 64:
#line 178 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 65:
#line 179 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 66:
#line 180 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 67:
#line 181 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 68:
#line 182 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 69:
#line 183 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 70:
#line 184 "yacc"
{yyval.valc=yyvsp[0].valc;;
    break;}
case 71:
#line 188 "yacc"
{yyval.tptr=yyvsp[0].tptr;;
    break;}
case 72:
#line 189 "yacc"
{yyval.tptr=(symrec *)malloc(sizeof(symrec));yyval.tptr->name=(char *)malloc(255);sprintf(yyval.tptr->name,"%s%d","t",ii++);yyval.tptr->val.var=yyvsp[0].tptr->val.var;fflush(fout);;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 442 "bison.simple"

  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;
	  for (x = 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 = 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 191 "yacc"
 



void yyerror(char *s) 
{ 
  printf("%s\n",  s); 
} 
double unary_in(double v1,char *s)
{
	switch (s[0])
{
	case '+' : return  v1;
	case '-' : return (-v1);
	case '~' : return (~(int)v1);
	case '!'  : return (!v1);
 }
}
double assignment_in(double v1, char * s, double v2)
{
	if(strcmp(s,"=")==0) return v2;
	if(strcmp(s,"+=")==0) return (v1+v2);
	if(strcmp(s,"-=")==0) return (v1-v2);
	if(strcmp(s,"*=")==0) return (v1*v2);
	if(strcmp(s,"/=")==0 && v2!=0)return (v1/v2);
	if(strcmp(s,"%=")==0) return ((int)v1%(int)v2);
	if(strcmp(s,"<<=")==0) return ((int)v1<<(int)v2);
	if(strcmp(s,">>=")==0)return ((int)v1>>(int)v2);
	if(strcmp(s,"&=")==0) return ((int)v1&(int)v2);
	if(strcmp(s,"^=")==0) return ((int)v1^(int)v2);
	if(strcmp(s,"|=")==0) return ((int)v1|(int)v2);
	return 0.;
}