home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / The_SOURCE#7.LHA / Source / DefFunc.lha / DefFunc / y.tab.c < prev   
Encoding:
C/C++ Source or Header  |  1993-12-14  |  13.9 KB  |  564 lines
  1.  
  2. # line 32 "dfcparse.y"
  3. #include <stdio.h>
  4. #include <malloc.h>
  5. #include <math.h>
  6. #include <string.h>
  7. #include "dfctree.h"
  8. #include "dfcsymtable.h"
  9.  
  10. char*         exparserror;
  11. static char   ermsgbuff[128];
  12. static Node*  yyparsetree; 
  13. static int    yytreesize;
  14. static Node   newnode;
  15.  
  16. #if NeedFunctionPrototypes
  17.   int yyparse(void);
  18.   static int yyreverse(void);
  19. #else
  20.   extern int yyparse();
  21.   extern int yyreverse();
  22. #endif
  23.  
  24. #if NeedFunctionPrototypes
  25.   static int addnode(Node *ptr)
  26. #else
  27.   static int addnode(ptr)
  28.   Node *ptr;
  29. #endif
  30. {
  31.     yytreesize++;
  32.  
  33.     if(yytreesize==1)
  34.     {
  35.         yyparsetree = (Node*)malloc(sizeof(Node));
  36.     }
  37.     else
  38.     {
  39.         yyparsetree = (Node*)realloc((Node*)yyparsetree, 
  40.                                  yytreesize*sizeof(Node));
  41.     }
  42.     if(yyparsetree==0)
  43.     {
  44.     perror("malloc/realloc in addnode()");
  45.     exit(1);
  46.     }
  47.  
  48.     if(yyparsetree == 0) 
  49.     {
  50.         fprintf(stderr, "fail to allocate memory in add node\n");
  51.         exit(1);
  52.     }
  53.  
  54.     /* yyparsetree[yytreesize-1] = *ptr; */
  55.     memcpy(yyparsetree+yytreesize-1, ptr, sizeof(Node)); 
  56.  
  57.     return yytreesize-1;
  58. };
  59.  
  60.  
  61. # line 91 "dfcparse.y"
  62. typedef union  {
  63.     int    nodeidx;
  64.     int    argidx;
  65.     double value;
  66.     double (*fnctptr)();
  67.     char   name[32];
  68. } YYSTYPE;
  69. # define CONST 257
  70. # define ARG 258
  71. # define FNCT 259
  72. # define SYM 260
  73. # define SIG 261
  74. #define yyclearin yychar = -1
  75. #define yyerrok yyerrflag = 0
  76. extern int yychar;
  77. extern short yyerrflag;
  78. #ifndef YYMAXDEPTH
  79. #define YYMAXDEPTH 150
  80. #endif
  81. YYSTYPE yylval, yyval;
  82. # define YYERRCODE 256
  83.  
  84. # line 231 "dfcparse.y"
  85.  /* --------------------------------------------------------- */
  86. #include "dfcscan.h"
  87.  
  88. #if NeedFunctionPrototype
  89.   int yyinit(char* expr)
  90. #else
  91.   int yyinit(expr)
  92.   char *expr; 
  93. #endif
  94. {
  95.     initargu();
  96.  
  97.     yyexpr = expr;
  98.     yyexprlen = strlen(yyexpr);
  99.     yypos = 0;
  100.     yytreesize = 0;
  101.  
  102.     return 0;
  103. };
  104.  
  105. #if NeedFunctionPrototypes
  106.   static int yyreverse(void)
  107. #else
  108.   static int yyreverse()  
  109. #endif
  110. /* yyparse() use a LALR(1) bottom-up algorithem to construct the
  111.    parse tree. Thus the result tree is upsetdown, i.e. the root
  112.    is place on the end of the yyparsetree[]. yyreverse make it
  113.    in right order, i.e. yyparsetree[0] be the root */
  114. {
  115.     int   i;
  116.     Node* buff;
  117.  
  118.     if(yytreesize==0) return 0;
  119.  
  120.     buff = (Node*)malloc(sizeof(Node)*yytreesize);
  121.     if(buff==0) 
  122.     {
  123.     perror("malloc in reverse()");
  124.     exit(1);
  125.     }
  126.  
  127.     for(i=0; i<yytreesize; i++) /* reverse */
  128.     {
  129.     
  130.      /* buff[i] = yyparsetree[yytreesize-1-i]; */
  131.     memcpy(buff+i, yyparsetree+yytreesize-1-i, sizeof(Node));
  132.     buff[i].left = yytreesize - 1 - buff[i].left;
  133.     buff[i].right= yytreesize - 1 - buff[i].right;
  134.  
  135.     }
  136.  
  137.     for(i=0; i<yytreesize; i++) /* put it back */ 
  138.     {
  139.     yyparsetree[i] = buff[i];
  140.     }
  141.  
  142.     free(buff);
  143.  
  144.     return yytreesize;
  145. };
  146.  
  147. #if NeedFunctionPrototypes
  148.   int getparsetree(Node* buff)
  149. #else
  150.   int getparsetree(buff)
  151.   Node* buff;
  152. #endif
  153. /* copy the parse into buff */
  154. {
  155.     int i;
  156.  
  157.     for(i=0; i<yytreesize; i++)
  158.     {
  159.     buff[i] = yyparsetree[i];
  160.     }
  161.  
  162.     return yytreesize;
  163. };
  164.  
  165. #if NeedFunctionPrototypes
  166.   static void yyerror(char* s)
  167. #else
  168.   static yyerror(s)
  169.   char *s;
  170. #endif
  171. {
  172.     exparserror=s;
  173. };
  174.  
  175. #if NeedFunctionPrototypes
  176.   static int yywrap(void)
  177. #else
  178.   static int yywrap()
  179. #endif
  180. {
  181.    return 1;
  182. };
  183. short yyexca[] ={
  184. -1, 1,
  185.     0, -1,
  186.     -2, 0,
  187.     };
  188. # define YYNPROD 22
  189. # define YYLAST 251
  190. short yyact[]={
  191.  
  192.    2,  12,  31,  19,  11,  12,  10,  13,  11,  22,
  193.   10,  39,  17,  15,  40,  16,  21,  18,  36,  17,
  194.   15,  37,  16,  17,  18,  42,  17,  15,  18,  16,
  195.   12,  18,  20,  11,   1,  10,   0,   0,   0,  17,
  196.   15,   0,  16,   0,  18,   0,  35,  17,  15,   3,
  197.   16,   0,  18,  34,  17,  15,  14,  16,   0,  18,
  198.    0,   0,   0,   0,  19,   0,   0,   0,   0,   0,
  199.    4,  19,   0,   0,   0,  19,   0,   0,  19,   0,
  200.    0,  23,  24,  25,   0,   0,  26,  27,  28,  29,
  201.   30,  19,  32,  33,   0,   0,   0,   0,   0,  19,
  202.    0,   0,   0,   0,   0,   0,  19,   0,  38,   0,
  203.    0,  41,   0,   0,   0,   0,   0,   0,   0,   0,
  204.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  205.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  206.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  207.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  208.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  209.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  210.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  211.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  212.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  213.    0,   0,   0,   0,   0,   0,   0,   0,   6,   8,
  214.    9,   7,   6,   8,   9,   7,   0,   0,   0,   0,
  215.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  216.    0,   0,   0,   0,   0,   0,   5,   6,   8,   9,
  217.    7 };
  218. short yypact[]={
  219.  
  220.  -10,-1000,-1000,-1000,  -3,  22, -24,-1000,-1000, -31,
  221.  -35, -35, -35,-1000,-1000, -35, -35, -35, -35, -35,
  222. -1000, -39, -35, -91, -91,  12, -19, -19, -91, -91,
  223.  -91,-1000,   5, -23,-1000,-1000,-1000, -35, -30,-1000,
  224.  -35, -16,-1000 };
  225. short yypgo[]={
  226.  
  227.    0,  70,  34 };
  228. short yyr1[]={
  229.  
  230.    0,   2,   2,   2,   2,   2,   1,   1,   1,   1,
  231.    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
  232.    1,   1 };
  233. short yyr2[]={
  234.  
  235.    0,   1,   1,   2,   2,   2,   1,   1,   3,   4,
  236.    1,   4,   6,   8,   3,   3,   3,   3,   2,   2,
  237.    3,   3 };
  238. short yychk[]={
  239.  
  240. -1000,  -2,  10,  59,  -1, 256, 257, 260, 258, 259,
  241.   45,  43,  40,  10,  59,  43,  45,  42,  47,  94,
  242.   10,  40,  40,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
  243.   -1,  41,  -1,  -1,  41,  41,  41,  44,  -1,  41,
  244.   44,  -1,  41 };
  245. short yydef[]={
  246.  
  247.    0,  -2,   1,   2,   0,   0,   6,   7,  10,   0,
  248.    0,   0,   0,   3,   4,   0,   0,   0,   0,   0,
  249.    5,   0,   0,  18,  19,   0,  14,  15,  16,  17,
  250.   20,   8,   0,   0,  21,   9,  11,   0,   0,  12,
  251.    0,   0,  13 };
  252. #ifndef lint
  253. static    char yaccpar_sccsid[] = "@(#)yaccpar 1.6 88/02/08 SMI"; /* from UCB 4.1 83/02/11 */
  254. #endif
  255.  
  256. #
  257. # define YYFLAG -1000
  258. # define YYERROR goto yyerrlab
  259. # define YYACCEPT return(0)
  260. # define YYABORT return(1)
  261.  
  262. /*    parser for yacc output    */
  263.  
  264. #ifdef YYDEBUG
  265. int yydebug = 0; /* 1 for debugging */
  266. #endif
  267. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  268. int yychar = -1; /* current input token number */
  269. int yynerrs = 0;  /* number of errors */
  270. short yyerrflag = 0;  /* error recovery flag */
  271.  
  272. yyparse() {
  273.  
  274.     short yys[YYMAXDEPTH];
  275.     short yyj, yym;
  276.     register YYSTYPE *yypvt;
  277.     register short yystate, *yyps, yyn;
  278.     register YYSTYPE *yypv;
  279.     register short *yyxi;
  280.  
  281.     yystate = 0;
  282.     yychar = -1;
  283.     yynerrs = 0;
  284.     yyerrflag = 0;
  285.     yyps= &yys[-1];
  286.     yypv= &yyv[-1];
  287.  
  288.  yystack:    /* put a state and value onto the stack */
  289.  
  290. #ifdef YYDEBUG
  291.     if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  292. #endif
  293.         if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  294.         *yyps = yystate;
  295.         ++yypv;
  296.         *yypv = yyval;
  297.  
  298.  yynewstate:
  299.  
  300.     yyn = yypact[yystate];
  301.  
  302.     if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  303.  
  304.     if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  305.     if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  306.  
  307.     if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  308.         yychar = -1;
  309.         yyval = yylval;
  310.         yystate = yyn;
  311.         if( yyerrflag > 0 ) --yyerrflag;
  312.         goto yystack;
  313.         }
  314.  
  315.  yydefault:
  316.     /* default state action */
  317.  
  318.     if( (yyn=yydef[yystate]) == -2 ) {
  319.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  320.         /* look through exception table */
  321.  
  322.         for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  323.  
  324.         while( *(yyxi+=2) >= 0 ){
  325.             if( *yyxi == yychar ) break;
  326.             }
  327.         if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  328.         }
  329.  
  330.     if( yyn == 0 ){ /* error */
  331.         /* error ... attempt to resume parsing */
  332.  
  333.         switch( yyerrflag ){
  334.  
  335.         case 0:   /* brand new error */
  336.  
  337.             yyerror( "syntax error" );
  338.         yyerrlab:
  339.             ++yynerrs;
  340.  
  341.         case 1:
  342.         case 2: /* incompletely recovered error ... try again */
  343.  
  344.             yyerrflag = 3;
  345.  
  346.             /* find a state where "error" is a legal shift action */
  347.  
  348.             while ( yyps >= yys ) {
  349.                yyn = yypact[*yyps] + YYERRCODE;
  350.                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  351.                   yystate = yyact[yyn];  /* simulate a shift of "error" */
  352.                   goto yystack;
  353.                   }
  354.                yyn = yypact[*yyps];
  355.  
  356.                /* the current yyps has no shift onn "error", pop stack */
  357.  
  358. #ifdef YYDEBUG
  359.                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  360. #endif
  361.                --yyps;
  362.                --yypv;
  363.                }
  364.  
  365.             /* there is no state on the stack with an error shift ... abort */
  366.  
  367.     yyabort:
  368.             return(1);
  369.  
  370.  
  371.         case 3:  /* no shift yet; clobber input char */
  372.  
  373. #ifdef YYDEBUG
  374.             if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  375. #endif
  376.  
  377.             if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  378.             yychar = -1;
  379.             goto yynewstate;   /* try again in the same state */
  380.  
  381.             }
  382.  
  383.         }
  384.  
  385.     /* reduction by production yyn */
  386.  
  387. #ifdef YYDEBUG
  388.         if( yydebug ) printf("reduce %d\n",yyn);
  389. #endif
  390.         yyps -= yyr2[yyn];
  391.         yypvt = yypv;
  392.         yypv -= yyr2[yyn];
  393.         yyval = yypv[1];
  394.         yym=yyn;
  395.             /* consult goto table to find next state */
  396.         yyn = yyr1[yyn];
  397.         yyj = yypgo[yyn] + *yyps + 1;
  398.         if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  399.         switch(yym){
  400.             
  401. case 1:
  402. # line 111 "dfcparse.y"
  403. {  
  404.                   return 0;
  405.                 } break;
  406. case 2:
  407. # line 114 "dfcparse.y"
  408. {
  409.                   return 0;
  410.                            } break;
  411. case 3:
  412. # line 117 "dfcparse.y"
  413. {  
  414.                               return yyreverse(); 
  415.                            } break;
  416. case 4:
  417. # line 120 "dfcparse.y"
  418. {
  419.                   return yyreverse();
  420.                            } break;
  421. case 5:
  422. # line 123 "dfcparse.y"
  423. {  
  424.                               return -1;
  425.                            } break;
  426. case 6:
  427. # line 128 "dfcparse.y"
  428. {  
  429.                               newnode.type = const_node;
  430.                               newnode.content.value = yypvt[-0].value;
  431.  
  432.                               yyval.nodeidx = addnode(&newnode); 
  433.                            } break;
  434. case 7:
  435. # line 134 "dfcparse.y"
  436. {
  437.                   sprintf(ermsgbuff, 
  438.                   "unknow token \"%s\"", yypvt[-0].name);
  439.                   exparserror = ermsgbuff;
  440.                   return -1;
  441.                            } break;
  442. case 8:
  443. # line 140 "dfcparse.y"
  444. {
  445.                   newnode.type = const_node;
  446.                   newnode.content.value = yypvt[-2].value;
  447.  
  448.                   yyval.nodeidx = addnode(&newnode);
  449.                            } break;
  450. case 9:
  451. # line 146 "dfcparse.y"
  452. {
  453.                   newnode.type = const_node;
  454.                   newnode.content.value = yypvt[-3].value;
  455.  
  456.                   yyval.nodeidx = addnode(&newnode);
  457.                } break;
  458. case 10:
  459. # line 152 "dfcparse.y"
  460. {
  461.                               newnode.type = arg_node;
  462.                   newnode.content.argidx = yypvt[-0].argidx;
  463.                               yyval.nodeidx = addnode(&newnode);
  464.                            } break;
  465. case 11:
  466. # line 157 "dfcparse.y"
  467. { 
  468.                               newnode.type = simplex_fnct_node;
  469.                               newnode.content.fnctptr = yypvt[-3].fnctptr;
  470.                               newnode.right = yypvt[-1].nodeidx;
  471.  
  472.                               yyval.nodeidx = addnode(&newnode);
  473.                            } break;
  474. case 12:
  475. # line 164 "dfcparse.y"
  476. {
  477.                               newnode.type = duplex_fnct_node;
  478.                               newnode.content.fnctptr = yypvt[-5].fnctptr;
  479.                               newnode.left = yypvt[-3].nodeidx;
  480.                               newnode.right= yypvt[-1].nodeidx;
  481.  
  482.                               yyval.nodeidx = addnode(&newnode);
  483.                            } break;
  484. case 13:
  485. # line 172 "dfcparse.y"
  486. {
  487.                   exparserror 
  488.                 = "not support triplex function yet";
  489.                       return -1;    
  490.                        } break;
  491. case 14:
  492. # line 177 "dfcparse.y"
  493. {
  494.                               newnode.type = binary_op_node;
  495.                               newnode.content.op = op_sum;
  496.                               newnode.left = yypvt[-2].nodeidx;
  497.                               newnode.right= yypvt[-0].nodeidx;
  498.  
  499.                               yyval.nodeidx = addnode(&newnode);
  500.                            } break;
  501. case 15:
  502. # line 185 "dfcparse.y"
  503. {
  504.                               newnode.type = binary_op_node;
  505.                               newnode.content.op = op_sub;
  506.                               newnode.left = yypvt[-2].nodeidx;
  507.                               newnode.right= yypvt[-0].nodeidx;
  508.  
  509.                               yyval.nodeidx = addnode(&newnode);
  510.                            } break;
  511. case 16:
  512. # line 193 "dfcparse.y"
  513. {
  514.                               newnode.type = binary_op_node;
  515.                               newnode.content.op = op_mul;
  516.                               newnode.left = yypvt[-2].nodeidx;
  517.                               newnode.right= yypvt[-0].nodeidx;
  518.  
  519.                               yyval.nodeidx = addnode(&newnode);
  520.                            } break;
  521. case 17:
  522. # line 201 "dfcparse.y"
  523. {
  524.                               newnode.type = binary_op_node;
  525.                               newnode.content.op = op_div;
  526.                               newnode.left =yypvt[-2].nodeidx;
  527.                               newnode.right=yypvt[-0].nodeidx;
  528.  
  529.                               yyval.nodeidx = addnode(&newnode); 
  530.                            } break;
  531. case 18:
  532. # line 209 "dfcparse.y"
  533. {
  534.                               newnode.type = unary_op_node; 
  535.                   newnode.content.op = op_neg;
  536.                               newnode.right = yypvt[-0].nodeidx;
  537.  
  538.                               yyval.nodeidx = addnode(&newnode);
  539.                            } break;
  540. case 19:
  541. # line 216 "dfcparse.y"
  542. { 
  543.                               yyval.nodeidx = yypvt[-0].nodeidx;
  544.                            } break;
  545. case 20:
  546. # line 219 "dfcparse.y"
  547. {
  548.                               newnode.type = duplex_fnct_node;
  549.                               newnode.content.fnctptr = pow;
  550.                               newnode.left = yypvt[-2].nodeidx;
  551.                               newnode.right= yypvt[-0].nodeidx;
  552.  
  553.                               yyval.nodeidx = addnode(&newnode);
  554.                            } break;
  555. case 21:
  556. # line 227 "dfcparse.y"
  557. { 
  558.                               yyval.nodeidx = yypvt[-1].nodeidx; 
  559.                            } break;
  560.         }
  561.         goto yystack;  /* stack new state and value */
  562.  
  563.     }
  564.