parse.c

calc大数库

	    break;
	  case ARRADR: 
	    printf("&array[]");
	    break;
	  case POLY: 
	    printf("poly");
	    break;
	  }
	  if (j!=nArgs) 
	    printf(", ");
	  else
	    printf(")\n");
	}
      } else 
	printf(")\n");

      stackFree(&tmpStack);
      return NULL;
    }
    stackPush(tmpStack, Arg); /* put it back in the stack. in reverse order */

  }

  while (!stackEmpty(tmpStack)) {
    Arg = stackPop(tmpStack);
    switch(Arg->type) {
    case NUM: 
      stackPush(varStack, Arg->u.num);
      break;
    case VARADR:
      if ( Arg->defined == 1) /* if the variable has previously been assigned.
			       */
	FREEMPI(*(Arg->u.varAdr));
      stackPush(varStack, Arg->u.varAdr);
      break;
    case ARR:
      stackPush(varStack, Arg->u.array);
      break;
    case ARRADR:
      if ( Arg->defined == 1) /* if the variable has previously been assigned.
			       */
	FREEMPIA(*(Arg->u.arrayAdr));

      stackPush(varStack, Arg->u.arrayAdr);
      break;
    case POLY:
      stackPush(varStack, Arg->u.poly);
      break;
    }
  }
  stackFree(&tmpStack);
  return varStack;
}

int yylex()
{
	MPI *Temp;
	char c;
	int typ;

	while ((c = *p++) == ' ' || c == '\t')
		;
	if (c == '\0')
		return 0;
	if (isdigit((int)c))
	{
		yylval.val = CHANGE((USL)(c - '0'));
		while (isdigit((int)*p))
		{
		  Temp = yylval.val;
		  yylval.val = MULT_I(yylval.val, 10L);
		  FREEMPI(Temp);
		  Temp = yylval.val;
		  yylval.val = ADD0_I(yylval.val, (USL)(*p++ - '0'));
		  FREEMPI(Temp);
		}
		return NUMBER;
	}
	p--;
	if ( isalpha((int)c))
	{
		Symbol *s;
		char sbuf[100], *tmp = sbuf;

		do {
			*tmp++ = *p;
			p++;
			c=(*p);
		} while (c && isalnum((int)c));
		*tmp = '\0';
		if(c=='[')
		  typ=ARRAY;
		else if ( (c=='^' && *(tmp-1) == POLYID && (tmp-1) == sbuf ) ||
			  (*(p-1)==POLYID && strlen(sbuf) == 1 )) {
		  return POLYTERM; /* don't want to install this */
		} else
		  typ=VAR;
		s = lookup(sbuf,typ);
		if (s == NULL)
		  s = lookup(sbuf, BLTIN);
		if (s == NULL)
		  s = lookup(sbuf, BLTINV);
		if (s == NULL)
		  s = lookup(sbuf, BLTINP);
		if (s == NULL) 
		  s = lookup(sbuf,POLYVAR);
		if (s == NULL) 
		  s = install(sbuf, UNDEF);
		yylval.sym = s;
		if (s->type == UNDEF) 
		  return(typ);
		else 
		  return (s->type);
		
	}
	p++;
	return (int)c; /* returns +, -, ^, *, / etc */
}

void yyerror(s)
char *s;
{
	warning(s,"");
}
#line 619 "y.tab.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack()
{
    int newsize, i;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    i = yyssp - yyss;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss);
    if (newss == NULL)
        return -1;
    yyss = newss;
    yyssp = newss + i;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
    if (newvs == NULL)
        return -1;
    yyvs = newvs;
    yyvsp = newvs + i;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

#ifndef YYPARSE_PARAM
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG void
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif	/* ANSI-C/C++ */
#else	/* YYPARSE_PARAM */
#ifndef YYPARSE_PARAM_TYPE
#define YYPARSE_PARAM_TYPE void *
#endif
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
#endif	/* ANSI-C/C++ */
#endif	/* ! YYPARSE_PARAM */

int
yyparse (YYPARSE_PARAM_ARG)
    YYPARSE_PARAM_DECL
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate])) goto yyreduce;
    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, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(lint) || defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(lint) || defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 3:
#line 64 "parse.y"
{  
	  retval.mpi = yyvsp[-1].val;
	  rettype=RET_MPI;
	}
break;
case 4:
#line 69 "parse.y"
{
	  rettype=RET_MPIA;
	}
break;
case 5:
#line 73 "parse.y"
{ 
	  
	  retval.mpi = yyvsp[-1].val;
	  if (!(rettype == FUNC_FAIL)) {
	    PRINTI(yyvsp[-1].val);
	    printf("\n"); 
	  }
	  rettype = RET_MPI;

	}
break;
case 6:
#line 84 "parse.y"
{ 
	  rettype=0;
	}
break;
case 7:
#line 88 "parse.y"
{ 
	  yyerrok; 	   
	}
break;
case 8:
#line 92 "parse.y"
{ 
	  retval.polyi=yyvsp[-1].pol;
	  if (!(rettype == FUNC_FAIL)) {
	    PRINTPI(yyvsp[-1].pol);
	    printf("\n"); 
	  }
	  rettype=RET_POLY;
	}
break;
case 9:
#line 101 "parse.y"
{ 
	  retval.polyi = yyvsp[-1].pol;
	  rettype=RET_POLY;
	}
break;
case 10:
#line 108 "parse.y"
{
	      DELETEPI(yyvsp[-2].sym->u.sympval);
	      yyvsp[-2].sym->u.sympval=yyvsp[0].pol;
	      yyval.pol = COPYPI(yyvsp[0].pol);
	    }
break;
case 11:
#line 114 "parse.y"
{ 
	      if (yyvsp[-2].sym->type == VAR)
		FREEMPI(yyvsp[-2].sym->u.symval);
	      yyvsp[-2].sym->u.sympval = yyvsp[0].pol;
	      yyvsp[-2].sym->type=POLYVAR;
	      yyval.pol=COPYPI(yyvsp[0].pol);
	    }
break;
case 12:
#line 123 "parse.y"
{
	    if (yyvsp[0].sym->type == UNDEF)
	      execerror("is an undefined variable", yyvsp[0].sym->name);
	    else if( yyvsp[0].sym->u.sympval != (POLYI) NULL)
	      yyval.pol = COPYPI(yyvsp[0].sym->u.sympval);
	    else 
	      yyval.pol = (POLYI) NULL;
	  }
break;
case 13:
#line 132 "parse.y"
{
	  MPI *ONE;
	  ONE = ONEI();
	  yyval.pol = NULL;
	  PINSERTPI(1, ONE, &yyval.pol, 1);
	  FREEMPI(ONE);
	}
break;
case 14:
#line 140 "parse.y"
{
	  yyval.pol = NULL;
	  PINSERTPI(1, yyvsp[-1].val, &yyval.pol, 1);
	  FREEMPI(yyvsp[-1].val);
        }
break;
case 15:
#line 146 "parse.y"
{
	    yyval.pol = NULL;
	    PINSERTPI(CONVERTI(yyvsp[0].val), yyvsp[-3].val, &yyval.pol,1);
	    FREEMPI(yyvsp[-3].val);
	    FREEMPI(yyvsp[0].val); 

	  }
break;
case 16:
#line 154 "parse.y"
{
	    MPI *O;
	    O = ONEI();
	    yyval.pol = NULL;
	    PINSERTPI(CONVERTI(yyvsp[0].val), O, &yyval.pol,1);
	    FREEMPI(O);
	    FREEMPI(yyvsp[0].val); 
	  }
break;
case 17:
#line 163 "parse.y"
{
	  }
break;
case 18:
#line 166 "parse.y"
{
	    yyval.pol = ADDPI(yyvsp[-2].pol,yyvsp[0].pol);
	    DELETEPI(yyvsp[-2].pol);
	    DELETEPI(yyvsp[0].pol);
	  }
break;
case 19:
#line 173 "parse.y"
{
	  yyval.pol = MODPI(yyvsp[-2].pol,yyvsp[0].pol);
	  DELETEPI(yyvsp[-2].pol);
	  DELETEPI(yyvsp[0].pol);
	    
	}
break;
case 20:
#line 180 "parse.y"
{
	  yyval.pol = DIVPI(yyvsp[-2].pol, yyvsp[0].pol);
	  DELETEPI(yyvsp[-2].pol);
	  DELETEPI(yyvsp[0].pol);
	  }
break;
case 21:
#line 186 "parse.y"
{
	  POLYI Z;
	  Z = ZEROPI(); /* returns zero polynomial */
	  yyval.pol = SUBPI(Z, yyvsp[0].pol);
	  DELETEPI(Z);
	  DELETEPI(yyvsp[0].pol);
	}
break;
case 22:
#line 194 "parse.y"
{
	    yyval.pol = SUBPI(yyvsp[-2].pol, yyvsp[0].pol);
	    DELETEPI(yyvsp[-2].pol);
	    DELETEPI(yyvsp[0].pol);
	  }
break;
case 23:
#line 200 "parse.y"