parse.c

calc大数库

{ 
	  POLYI O, P;
	  O = ONEPI();
	  P = SCALARPI(yyvsp[0].val, O);
	  yyval.pol = ADDPI(yyvsp[-2].pol, P);
	  DELETEPI(O);
	  DELETEPI(P);
	  DELETEPI(yyvsp[-2].pol);
	  FREEMPI(yyvsp[0].val);
	}
break;
case 24:
#line 211 "parse.y"
{ 
	  POLYI O, P;
	  O = ONEPI();
	  P = SCALARPI(yyvsp[-2].val, O);
	  yyval.pol = ADDPI(yyvsp[0].pol, P);
	  DELETEPI(O);
	  DELETEPI(P);
	  DELETEPI(yyvsp[0].pol);
	  FREEMPI(yyvsp[-2].val);
	}
break;
case 25:
#line 223 "parse.y"
{ 
	  POLYI O, P;
	  O = ONEPI();
	  P = SCALARPI(yyvsp[0].val, O);
	  yyval.pol = SUBPI(yyvsp[-2].pol, P);
	  DELETEPI(O);
	  DELETEPI(P);
	  DELETEPI(yyvsp[-2].pol);
	  FREEMPI(yyvsp[0].val);
	}
break;
case 26:
#line 234 "parse.y"
{ 
	  POLYI O, P;
	  O = ONEPI();
	  P = SCALARPI(yyvsp[-2].val, O);
	  yyval.pol = SUBPI(P, yyvsp[0].pol);
	  DELETEPI(O);
	  DELETEPI(P);
	  DELETEPI(yyvsp[0].pol);
	  FREEMPI(yyvsp[-2].val);
	}
break;
case 27:
#line 245 "parse.y"
{
	  yyval.pol = SCALARPI(yyvsp[-2].val,yyvsp[0].pol);
	  FREEMPI(yyvsp[-2].val);
	  DELETEPI(yyvsp[0].pol);
	}
break;
case 28:
#line 251 "parse.y"
{
	  yyval.pol = SCALARPI(yyvsp[0].val, yyvsp[-2].pol);
	  FREEMPI(yyvsp[0].val);
	  DELETEPI(yyvsp[-2].pol);
	}
break;
case 29:
#line 257 "parse.y"
{
	  yyval.pol = MULTPI(yyvsp[-2].pol, yyvsp[0].pol);
	  DELETEPI(yyvsp[-2].pol);
	  DELETEPI(yyvsp[0].pol);
	}
break;
case 30:
#line 263 "parse.y"
{
	  yyval.pol = POWERPI(yyvsp[-2].pol, CONVERTI(yyvsp[0].val));
	  DELETEPI(yyvsp[-2].pol);
	  FREEMPI(yyvsp[0].val);
	}
break;
case 31:
#line 269 "parse.y"
{ 
		yyval.pol = yyvsp[-1].pol; 
	}
break;
case 32:
#line 273 "parse.y"
{
	  Stack varStack;
	  if ((varStack = checkArgs(yyvsp[-1].sym))) {
	    yyval.pol = (*(yyvsp[-1].sym->u.ptrp))(varStack);
	    stackFree(&varStack);
	  } else {
	    rettype = FUNC_FAIL; /* return failure of function */
	    yyval.pol = NULL;
	  }
	}
break;
case 33:
#line 290 "parse.y"
{
	     unsigned n = CONVERTI(yyvsp[-3].val);
	     if (yyvsp[-5].sym->type == UNDEF) {
	       yyvsp[-5].sym->u.symarr = BUILDMPIA();
	       yyvsp[-5].sym->type = ARRAY;
	     }
	     ADD_TO_MPIA(yyvsp[-5].sym->u.symarr, yyvsp[0].val, n);
	     FREEMPI(yyvsp[-3].val);
	     FREEMPI(yyvsp[0].val);

	   }
break;
case 34:
#line 302 "parse.y"
{
	     if (yyvsp[-5].sym->type != UNDEF) 
	       FREEMPIA(yyvsp[-5].sym->u.symarr);
	     yyvsp[-5].sym->u.symarr = yyvsp[0].arr;
	     yyvsp[-5].sym->type=ARRAY;

           }
break;
case 35:
#line 310 "parse.y"
{
	     yyval.arr = BUILDMPIA();
	     ADD_TO_MPIA(yyval.arr, yyvsp[-1].val, 0);
	     FREEMPI(yyvsp[-1].val);
	   }
break;
case 36:
#line 316 "parse.y"
{
	     MPIA_INSERT(yyvsp[0].arr, yyvsp[-2].val, 0);
	     FREEMPI(yyvsp[-2].val);
	     yyval.arr = yyvsp[0].arr;
	   }
break;
case 37:
#line 323 "parse.y"
{
		if(yyvsp[-2].sym->type!=UNDEF && yyvsp[-2].sym->u.symval != NULL)
			FREEMPI(yyvsp[-2].sym->u.symval);		  
		yyvsp[-2].sym->u.symval=yyvsp[0].val;
		if ( yyvsp[-2].sym->u.symval != (MPI *) NULL)
			yyval.val = COPYI(yyvsp[-2].sym->u.symval);
		else
  			yyval.val = (MPI *) NULL;
		yyvsp[-2].sym->type = VAR; 
	}
break;
case 38:
#line 334 "parse.y"
{  
	  yyval.val = yyvsp[0].val; 
	}
break;
case 39:
#line 338 "parse.y"
{
	  if (yyvsp[0].sym->type == UNDEF)
			execerror("is an undefined variable", yyvsp[0].sym->name);
		else 
		  yyval.val = COPYI(yyvsp[0].sym->u.symval);
	}
break;
case 40:
#line 350 "parse.y"
{
	  yyval.val = VALPI(yyvsp[-3].pol, yyvsp[-1].val);
	  FREEMPI(yyvsp[-1].val);
	  DELETEPI(yyvsp[-3].pol);
	}
break;
case 41:
#line 356 "parse.y"
{
	  yyval.val = VALPI(yyvsp[-3].sym->u.sympval, yyvsp[-1].val);
	  FREEMPI(yyvsp[-1].val);
	}
break;
case 42:
#line 361 "parse.y"
{
	  int ind;
		if (yyvsp[-3].sym->type == UNDEF)
		{
			FREEMPI(yyvsp[-1].val);
			execerror("[] is an undefined array", yyvsp[-3].sym->name);
		}
		ind = (int)CONVERTI(yyvsp[-1].val);
		if(ind >= yyvsp[-3].sym->u.symarr->size)
		{
			FREEMPI(yyvsp[-1].val);
			execerror("array is too small", yyvsp[-3].sym->name);
		}
		yyval.val = COPYI(yyvsp[-3].sym->u.symarr->A[ind]);
		FREEMPI(yyvsp[-1].val);
	}
break;
case 43:
#line 378 "parse.y"
{
	}
break;
case 44:
#line 381 "parse.y"
{
		 yyval.val = ADDI(yyvsp[-2].val, yyvsp[0].val);
		 FREEMPI(yyvsp[-2].val);
		 FREEMPI(yyvsp[0].val);
	}
break;
case 45:
#line 387 "parse.y"
{ 
		yyval.val = SUBI(yyvsp[-2].val, yyvsp[0].val);
		FREEMPI(yyvsp[-2].val);
		FREEMPI(yyvsp[0].val);
	}
break;
case 46:
#line 393 "parse.y"
{
		yyval.val = MULTI(yyvsp[-2].val, yyvsp[0].val);
		FREEMPI(yyvsp[-2].val);
		FREEMPI(yyvsp[0].val);
	}
break;
case 47:
#line 399 "parse.y"
{
	        if((yyvsp[0].val)->S <= 0)
		{
			FREEMPI(yyvsp[-2].val);
			FREEMPI(yyvsp[0].val);
			execerror(" divisor <= 0", "");
		}
		yyval.val = INTI(yyvsp[-2].val, yyvsp[0].val);
		FREEMPI(yyvsp[-2].val);
		FREEMPI(yyvsp[0].val);
	}
break;
case 48:
#line 411 "parse.y"
{
	        if((yyvsp[0].val)->S <= 0)
		{
			FREEMPI(yyvsp[-2].val);
			FREEMPI(yyvsp[0].val);
			execerror(" divisor <= 0", "");
		}
		yyval.val = MOD(yyvsp[-2].val, yyvsp[0].val);
		FREEMPI(yyvsp[-2].val);
 	        FREEMPI(yyvsp[0].val);
	}
break;
case 49:
#line 423 "parse.y"
{ 
		if ((yyvsp[0].val)->S < 0)
		{
			FREEMPI(yyvsp[-2].val);
			FREEMPI(yyvsp[0].val);
			execerror("negative exponent", "");
		}
		if ((yyvsp[0].val)->D > 0)
		{
			FREEMPI(yyvsp[-2].val);
			FREEMPI(yyvsp[0].val);
			execerror("exponent >= R0", "");
		}
		yyval.val = POWERI(yyvsp[-2].val, (unsigned int)(CONVERTI(yyvsp[0].val))); 
 		FREEMPI(yyvsp[-2].val);
		FREEMPI(yyvsp[0].val);
	}
break;
case 50:
#line 441 "parse.y"
{
		yyval.val = MINUSI(yyvsp[0].val); 
		FREEMPI(yyvsp[0].val);
	}
break;
case 51:
#line 446 "parse.y"
{ 
		yyval.val = yyvsp[-1].val; 
	}
break;
case 52:
#line 450 "parse.y"
{        
	  Stack varStack;
	  if ((varStack = checkArgs(yyvsp[-1].sym))) {
	    yyval.val = (*(yyvsp[-1].sym->u.ptr))(varStack);
	    stackFree(&varStack);
	  } else {
	    yyval.val = NULL;
	    rettype = FUNC_FAIL;
	  }
	}
break;
case 53:
#line 463 "parse.y"
{
	  Stack varStack;
	  if ((varStack = checkArgs(yyvsp[-1].sym))) {
	    (*(yyvsp[-1].sym->u.ptrv))(varStack);
	    stackFree(&varStack);
	  } else {
	    rettype = FUNC_FAIL;
	  }
	}
break;
case 54:
#line 473 "parse.y"
{ 
	  if (yyvsp[-2].sym->type != UNDEF){
	    PRINTIA(yyvsp[-2].sym->u.symarr);
	  } else {
	    execerror("undefined array", yyvsp[-2].sym->name );
	  }
	}
break;
case 55:
#line 482 "parse.y"
{
       }
break;
case 56:
#line 485 "parse.y"
{
       }
break;
case 57:
#line 490 "parse.y"
{
	   stackPush(argStack, createArg(yyvsp[-1].val, NUM, 0));
         }
break;
case 58:
#line 494 "parse.y"
{
	   stackPush(argStack, createArg(yyvsp[-1].pol, POLY, 0));
         }
break;
case 59:
#line 498 "parse.y"
{
	   if (yyvsp[-3].sym->type != UNDEF) {
	     stackPush(argStack, createArg(yyvsp[-3].sym, ARR, 0));
	   } else {
	     execerror("[] is an undefined array", yyvsp[-3].sym->name);
	     rettype = FUNC_FAIL;
	   }
         }
break;
case 60:
#line 507 "parse.y"
{

	   /* S.Seefried.  Normally one would free an old array if it 
	    * existed.  I have deferred this until I am sure all arguments
	    * on the command line are valid for the function in question.
	    * See checkArgs.  It is here that I free. */
	   if (yyvsp[-3].sym->type != UNDEF)
	     stackPush(argStack, createArg(yyvsp[-3].sym, ARRADR, 1));	     
	   else
	     stackPush(argStack, createArg(yyvsp[-3].sym, ARRADR, 0));
	   yyvsp[-3].sym->type=ARRAY;
         }
break;
case 61:
#line 520 "parse.y"
{

	   if (yyvsp[-1].sym->type != UNDEF) 
	     stackPush(argStack, createArg(yyvsp[-1].sym, VARADR, 1));	     
	   else
	     stackPush(argStack, createArg(yyvsp[-1].sym, VARADR, 0));
	   yyvsp[-1].sym->type=VAR;
	 }
break;
case 62:
#line 530 "parse.y"
{
	   if (yyvsp[-2].sym->type != UNDEF) 
	     stackPush(argStack, createArg(yyvsp[-2].sym, VARADR, 1));	     
	   else
	     stackPush(argStack, createArg(yyvsp[-2].sym, VARADR, 0));
	   yyvsp[-2].sym->type=VAR;
	 }
break;
case 63:
#line 538 "parse.y"
{
	   stackPush(argStack, createArg(yyvsp[-2].val, NUM, 0));
         }
break;
case 64:
#line 542 "parse.y"
{
	   stackPush(argStack, createArg(yyvsp[-2].pol, POLY, 0));
         }
break;
case 65:
#line 546 "parse.y"
{
	   if (yyvsp[-4].sym->type != UNDEF) {
	     stackPush(argStack, createArg(yyvsp[-4].sym, ARR, 0));
	   } else {
	     rettype = FUNC_FAIL;
	   }
         }
break;
case 66:
#line 554 "parse.y"
{
	   /* S.Seefried.  Normally one would free an old array if it 
	    * existed.  I have deferred this until I am sure all arguments
	    * on the command line are valid for the function in question.
	    * See checkArgs.  It is here that I free. */

	   if (yyvsp[-4].sym->type != UNDEF) 
	     stackPush(argStack, createArg(yyvsp[-4].sym, ARRADR, 1));	     
	   else
	     stackPush(argStack, createArg(yyvsp[-4].sym, ARRADR, 0));
	   yyvsp[-4].sym->type=ARRAY;
	 }
break;
#line 1422 "y.tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}