mfcalc.cpp

Linux/windows 环境下跨平台开发程序

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

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

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

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

  /* count tokens shifted since error; after three, turn off error status.  */
  if (yyerrstatus) yyerrstatus--;

  yystate = yyn;
  goto yynewstate;

/* Do the default action for the current state.  */
yydefault:

  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;

/* Do a reduction.  yyn is the number of a rule to reduce with.  */
yyreduce:
  yylen = yyr2[yyn];
  if (yylen > 0)
    yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
  if (yydebug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
	       yyn, yyrline[yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    }
#endif


  switch (yyn) {

case 6:
{store_res(&yyvsp[-1]); return 0;;
    break;}
case 7:
{store_res(&yyvsp[-1]); return 0;;
    break;}
case 8:
{store_res(&yyvsp[-1]); return 0;;
    break;}
case 9:
{store_res(&yyvsp[-1]); return 0;;
    break;}
case 10:
{store_res(&yyvsp[-1]); return 0;;
    break;}
case 11:
{yyerrok;;
    break;}
case 12:
{;;
    break;}
case 13:
{yyval.text=add_strings(yyvsp[-2].text, string_value(&yyvsp[0]));;
    break;}
case 14:
{yyval.text=add_strings(string_value(&yyvsp[-2]), yyvsp[0].text);;
    break;}
case 15:
{yyval.text=add_strings(yyvsp[-2].text, yyvsp[0].text);;
    break;}
case 16:
{;;
    break;}
case 17:
{if(yyval.text =(char*)malloc(strlen(yyvsp[-2].tptr->name) +strlen(yyvsp[0].tptr->name) + 2)) sprintf(yyval.text, "%s:%s", yyvsp[-2].tptr->name, yyvsp[0].tptr->name);;
    break;}
case 19:
{if(!yyval.a_data) {yyval.a_data = (double*)malloc(sizeof(double)); yyval.a_count = 1; yyval.a_data[0] = yyval.val;};
    break;}
case 20:
{push(&yyval, &yyvsp[0]);;
    break;}
case 21:
{exec_clause(&yyval);;
    break;}
case 22:
{range_array(&yyval, yyvsp[0].text);;
    break;}
case 23:
{if(yyvsp[-2].val < yyvsp[0].val && (yyval.a_data = (double*)malloc((int)(yyvsp[0].val-yyvsp[-2].val+2)*sizeof(double))))
					for(yyval.a_count=0; yyvsp[-2].val<=yyvsp[0].val; yyval.a_data[yyval.a_count++] = yyvsp[-2].val, yyvsp[-2].val += 1.0 );;
    break;}
case 24:
{yyval.val = yyvsp[0].val; yyval.type = NUM;;
    break;}
case 25:
{yyval.val = 0.0;;
    break;}
case 26:
{yyval.val = syntax_level ? syntax_level->clval : 0.0; ;
    break;}
case 27:
{yyval.val = _PI; yyval.type = NUM;;
    break;}
case 28:
{yyval.val = 2.71828182845905; yyval.type = NUM;;
    break;}
case 29:
{yyvsp[0].tptr->GetValue(&yyval);;
    break;}
case 30:
{eval(&yyvsp[0], &yyval);;
    break;}
case 31:
{yyvsp[-2].tptr->SetValue(&yyval, &yyvsp[0]);;
    break;}
case 32:
{yyvsp[-2].tptr->SetValue(&yyval, &yyvsp[0]);;
    break;}
case 33:
{yyval.val = ((yyvsp[-3].tptr->fnctptr)(yyvsp[-1].val));;
    break;}
case 34:
{yyval.val = ((yyvsp[-3].tptr->fnctptr)(proc_clause(&yyvsp[-1])));;
    break;}
case 35:
{push(&yyvsp[-2], &yyvsp[0]); yyval.val = ((yyvsp[-5].tptr->fnctptr)(&yyvsp[-2]));;
    break;}
case 36:
{push(&yyvsp[-4], &yyvsp[-2]); push(&yyvsp[-4], &yyvsp[0]); yyval.val = ((yyvsp[-7].tptr->fnctptr)(&yyvsp[-4]));;
    break;}
case 37:
{yyval.val = ((yyvsp[-3].tptr->fnctptr)(&yyvsp[-1], &yyval));;
    break;}
case 38:
{yyvsp[-1].text = string_value(&yyvsp[-1]); yyval.val = ((yyvsp[-3].tptr->fnctptr)(&yyvsp[-1], &yyval));;
    break;}
case 39:
{yyval.val = ((*yyvsp[-5].tptr->fnctptr)(proc_clause(&yyvsp[-3]), proc_clause(&yyvsp[-1]), 0L));;
    break;}
case 40:
{yyval.val = ((*yyvsp[-7].tptr->fnctptr)(proc_clause(&yyvsp[-5]), proc_clause(&yyvsp[-3]), yyvsp[-1].text));;
    break;}
case 41:
{yyval.val = yyvsp[-2].val != 0 ? eval(&yyvsp[0], &yyval) : 0.0;;
    break;}
case 42:
{yyval.val = yyvsp[-4].val != 0 ? eval(&yyvsp[-2], &yyval) : eval(&yyvsp[0], &yyval);;
    break;}
case 43:
{yyval.val = ((yyvsp[-2].val != 0) && (yyvsp[0].val != 0))? 1 : 0;;
    break;}
case 44:
{yyval.val = ((yyvsp[-2].val != 0) || (yyvsp[0].val != 0))? 1 : 0;;
    break;}
case 45:
{yyval.val = (yyvsp[-2].val == yyvsp[0].val) ? 1 : 0;;
    break;}
case 46:
{yyval.val = (yyvsp[-2].val != yyvsp[0].val) ? 1 : 0;;
    break;}
case 47:
{yyval.val = (yyvsp[-2].val > yyvsp[0].val) ? 1 : 0;;
    break;}
case 48:
{yyval.val = (yyvsp[-2].val >= yyvsp[0].val) ? 1 : 0;;
    break;}
case 49:
{yyval.val = (yyvsp[-2].val < yyvsp[0].val) ? 1 : 0;;
    break;}
case 50:
{yyval.val = (yyvsp[-2].val <= yyvsp[0].val) ? 1 : 0;;
    break;}
case 51:
{yyval.val = yyvsp[-2].val + yyvsp[0].val;;
    break;}
case 52:
{yyval.val = yyvsp[-2].val - yyvsp[0].val;;
    break;}
case 53:
{yyval.val = yyvsp[-2].val * yyvsp[0].val;;
    break;}
case 54:
{if(yyvsp[0].val != 0.0) yyval.val = yyvsp[-2].val / yyvsp[0].val;
					else yyval.val = (getsym(HashValue((unsigned char*)"zdiv")))->GetValue(); ;
    break;}
case 55:
{yyval.val = -yyvsp[0].val;;
    break;}
case 56:
{yyval.val=yyvsp[-1].tptr->GetValue(); yyvsp[-1].tptr->SetValue(yyval.val+1.0); yyval.val -= 1.0; yyval.type = NUM;;
    break;}
case 57:
{yyval.val=yyvsp[-1].tptr->GetValue(); yyvsp[-1].tptr->SetValue(yyval.val-1.0); yyval.val += 1.0; yyval.type = NUM;;
    break;}
case 58:
{yyval.val=yyvsp[0].tptr->GetValue(); yyvsp[0].tptr->SetValue(yyval.val+1.0); yyval.type = NUM;;
    break;}
case 59:
{yyval.val=yyvsp[0].tptr->GetValue(); yyvsp[0].tptr->SetValue(yyval.val-1.0); yyval.type = NUM;;
    break;}
case 60:
{yyval.val = pow(yyvsp[-2].val, yyvsp[0].val);;
    break;}
case 61:
{memcpy(&yyval, &yyvsp[-1], sizeof(YYSTYPE)); yyvsp[-1].a_data = 0L; yyvsp[-1].a_count = 0;;
    break;}
case 62:
{memcpy(&yyval, yyvsp[-4].val != 0.0 ? &yyvsp[-2] : &yyvsp[0], sizeof(YYSTYPE));
    break;}
case 63:
{memcpy(&yyval, yyvsp[-4].val != 0.0 ? &yyvsp[-2] : &yyvsp[0], sizeof(YYSTYPE));
    break;}
case 64:
{memcpy(&yyval, yyvsp[-4].val != 0.0 ? &yyvsp[-2] : &yyvsp[0], sizeof(YYSTYPE));
    break;}
case 65:
{memcpy(&yyval, yyvsp[-4].val != 0.0 ? &yyvsp[-2] : &yyvsp[0], sizeof(YYSTYPE));
    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;

 yyacceptlab: