home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / math / lpsolves / y.tab < prev    next >
Text File  |  1993-07-28  |  16KB  |  698 lines
  1. extern char *malloc(), *realloc();
  2. # define VAR 257
  3. # define CONS 258
  4. # define SIGN 259
  5. # define AR_M_OP 260
  6. # define RE_OP 261
  7. # define END_C 262
  8. # define COMMA 263
  9.  
  10. # line 10 "lp.y"
  11. #include "defines.h" 
  12. #include "globals.h"
  13.  
  14. /* globals */
  15. char Last_var[NAMELEN];
  16. int Rows;
  17. int Lin_term_count;
  18. double f;
  19. int x;
  20. int Sign;
  21. int isign;     /* internal_sign variable to make sure nothing goes wrong */
  22.         /* with lookahead */
  23. int make_neg;    /* is true after the relational operator is seen in order */
  24.         /* to rember if lin_term stands before or after re_op */
  25. #define yyclearin yychar = -1
  26. #define yyerrok yyerrflag = 0
  27. extern int yychar;
  28. extern int yyerrflag;
  29. #ifndef YYMAXDEPTH
  30. #define YYMAXDEPTH 150
  31. #endif
  32. #ifndef YYSTYPE
  33. #define YYSTYPE int
  34. #endif
  35. YYSTYPE yylval, yyval;
  36. # define YYERRCODE 256
  37.  
  38. # line 165 "lp.y"
  39.  
  40. # include "lex.yy.c"
  41. int yyexca[] ={
  42. -1, 1,
  43.     0, -1,
  44.     -2, 0,
  45. -1, 26,
  46.     257, 12,
  47.     -2, 28,
  48.     };
  49. # define YYNPROD 32
  50. # define YYLAST 69
  51. int yyact[]={
  52.  
  53.     42,    28,     7,    15,    47,    41,    43,    16,    46,    28,
  54.     17,    27,     7,    15,    13,    19,     7,     8,    20,    26,
  55.     15,    13,     7,     8,     6,    36,    34,    32,    12,    14,
  56.     11,    24,     5,    10,    30,    18,     4,    38,    29,    35,
  57.     25,    23,    37,    22,    21,     9,     3,     2,    31,     1,
  58.      0,     0,     0,     0,     0,    33,     0,     0,    39,     0,
  59.     40,     0,     0,     0,     0,     0,     0,    45,    44 };
  60. int yypact[]={
  61.  
  62.  -1000, -1000,  -235,  -245,  -252, -1000, -1000, -1000,  -242,  -238,
  63.  -1000,  -250, -1000, -1000, -1000,  -242, -1000, -1000,  -241, -1000,
  64.   -230, -1000, -1000,  -231, -1000,  -232, -1000, -1000, -1000,  -255,
  65.   -241, -1000, -1000, -1000, -1000,  -257, -1000,  -245,  -255, -1000,
  66.  -1000, -1000, -1000,  -249,  -258, -1000, -1000, -1000 };
  67. int yypgo[]={
  68.  
  69.      0,    49,    47,    46,    45,    44,    33,    30,    42,    41,
  70.     31,    40,    39,    28,    38,    37,    29,    36,    35,    34 };
  71. int yyr1[]={
  72.  
  73.      0,     2,     1,     4,     4,     8,     6,     5,     5,     9,
  74.      9,    10,    11,    12,    12,    12,     7,    14,     7,    15,
  75.      7,    13,    13,    17,    18,    17,    19,    17,    16,    16,
  76.     16,     3 };
  77. int yyr2[]={
  78.  
  79.      0,     1,     8,     2,     4,     1,    11,     0,     2,     2,
  80.      4,     6,     3,     3,     5,     7,     2,     1,     6,     1,
  81.      8,     2,     3,     2,     1,     6,     1,     8,     3,     5,
  82.      7,     5 };
  83. int yychk[]={
  84.  
  85.  -1000,    -1,    -2,    -3,   -17,   -16,   259,   257,   258,    -4,
  86.     -6,    -7,   -13,   259,   -16,   258,   259,   262,   -18,   257,
  87.    260,    -5,    -6,    -9,   -10,   -11,   257,   261,   259,   -14,
  88.    -19,   -16,   257,   -10,   257,   -12,   257,    -8,   -15,   -13,
  89.    -16,   262,   257,   263,    -7,   -13,   257,   262 };
  90. int yydef[]={
  91.  
  92.      1,    -2,     0,     0,     0,    23,    24,    28,     0,     7,
  93.      3,     0,    16,    17,    21,    22,    26,    31,     0,    29,
  94.      0,     2,     4,     8,     9,     0,    -2,     5,    19,     0,
  95.      0,    25,    30,    10,    12,     0,    13,     0,     0,    18,
  96.     27,    11,    14,     0,     0,    20,    15,     6 };
  97. typedef struct { char *t_name; int t_val; } yytoktype;
  98. #ifndef YYDEBUG
  99. #    define YYDEBUG    0    /* don't allow debugging */
  100. #endif
  101.  
  102. #if YYDEBUG
  103.  
  104. yytoktype yytoks[] =
  105. {
  106.     "VAR",    257,
  107.     "CONS",    258,
  108.     "SIGN",    259,
  109.     "AR_M_OP",    260,
  110.     "RE_OP",    261,
  111.     "END_C",    262,
  112.     "COMMA",    263,
  113.     "-unknown-",    -1    /* ends search */
  114. };
  115.  
  116. char * yyreds[] =
  117. {
  118.     "-no such reduction-",
  119.     "inputfile : /* empty */",
  120.     "inputfile : objective_function constraints int_declarations",
  121.     "constraints : constraint",
  122.     "constraints : constraints constraint",
  123.     "constraint : x_lineair_sum RE_OP",
  124.     "constraint : x_lineair_sum RE_OP x_lineair_sum END_C",
  125.     "int_declarations : /* empty */",
  126.     "int_declarations : real_int_decls",
  127.     "real_int_decls : int_declaration",
  128.     "real_int_decls : real_int_decls int_declaration",
  129.     "int_declaration : int_declarator vars END_C",
  130.     "int_declarator : VAR",
  131.     "vars : VAR",
  132.     "vars : vars VAR",
  133.     "vars : vars COMMA VAR",
  134.     "x_lineair_sum : x_lineair_term",
  135.     "x_lineair_sum : SIGN",
  136.     "x_lineair_sum : SIGN x_lineair_term",
  137.     "x_lineair_sum : x_lineair_sum SIGN",
  138.     "x_lineair_sum : x_lineair_sum SIGN x_lineair_term",
  139.     "x_lineair_term : lineair_term",
  140.     "x_lineair_term : CONS",
  141.     "lineair_sum : lineair_term",
  142.     "lineair_sum : SIGN",
  143.     "lineair_sum : SIGN lineair_term",
  144.     "lineair_sum : lineair_sum SIGN",
  145.     "lineair_sum : lineair_sum SIGN lineair_term",
  146.     "lineair_term : VAR",
  147.     "lineair_term : CONS VAR",
  148.     "lineair_term : CONS AR_M_OP VAR",
  149.     "objective_function : lineair_sum END_C",
  150. };
  151. #endif /* YYDEBUG */
  152. #line 1 "/usr/lib/yaccpar"
  153. /*    @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10    */
  154.  
  155. /*
  156. ** Skeleton parser driver for yacc output
  157. */
  158.  
  159. /*
  160. ** yacc user known macros and defines
  161. */
  162. #define YYERROR        goto yyerrlab
  163. #define YYACCEPT    { free(yys); free(yyv); return(0); }
  164. #define YYABORT        { free(yys); free(yyv); return(1); }
  165. #define YYBACKUP( newtoken, newvalue )\
  166. {\
  167.     if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
  168.     {\
  169.         yyerror( "syntax error - cannot backup" );\
  170.         goto yyerrlab;\
  171.     }\
  172.     yychar = newtoken;\
  173.     yystate = *yyps;\
  174.     yylval = newvalue;\
  175.     goto yynewstate;\
  176. }
  177. #define YYRECOVERING()    (!!yyerrflag)
  178. #ifndef YYDEBUG
  179. #    define YYDEBUG    1    /* make debugging available */
  180. #endif
  181.  
  182. /*
  183. ** user known globals
  184. */
  185. int yydebug;            /* set to 1 to get debugging */
  186.  
  187. /*
  188. ** driver internal defines
  189. */
  190. #define YYFLAG        (-1000)
  191.  
  192. /*
  193. ** static variables used by the parser
  194. */
  195. static YYSTYPE *yyv;            /* value stack */
  196. static int *yys;            /* state stack */
  197.  
  198. static YYSTYPE *yypv;            /* top of value stack */
  199. static int *yyps;            /* top of state stack */
  200.  
  201. static int yystate;            /* current state */
  202. static int yytmp;            /* extra var (lasts between blocks) */
  203.  
  204. int yynerrs;            /* number of errors */
  205.  
  206. int yyerrflag;            /* error recovery flag */
  207. int yychar;            /* current input token number */
  208.  
  209.  
  210. /*
  211. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  212. */
  213. int
  214. yyparse()
  215. {
  216.     register YYSTYPE *yypvt;    /* top of value stack for $vars */
  217.     unsigned yymaxdepth = YYMAXDEPTH;
  218.  
  219.     /*
  220.     ** Initialize externals - yyparse may be called more than once
  221.     */
  222.     yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
  223.     yys = (int*)malloc(yymaxdepth*sizeof(int));
  224.     if (!yyv || !yys)
  225.     {
  226.         yyerror( "out of memory" );
  227.         return(1);
  228.     }
  229.     yypv = &yyv[-1];
  230.     yyps = &yys[-1];
  231.     yystate = 0;
  232.     yytmp = 0;
  233.     yynerrs = 0;
  234.     yyerrflag = 0;
  235.     yychar = -1;
  236.  
  237.     goto yystack;
  238.     {
  239.         register YYSTYPE *yy_pv;    /* top of value stack */
  240.         register int *yy_ps;        /* top of state stack */
  241.         register int yy_state;        /* current state */
  242.         register int  yy_n;        /* internal state number info */
  243.  
  244.         /*
  245.         ** get globals into registers.
  246.         ** branch to here only if YYBACKUP was called.
  247.         */
  248.     yynewstate:
  249.         yy_pv = yypv;
  250.         yy_ps = yyps;
  251.         yy_state = yystate;
  252.         goto yy_newstate;
  253.  
  254.         /*
  255.         ** get globals into registers.
  256.         ** either we just started, or we just finished a reduction
  257.         */
  258.     yystack:
  259.         yy_pv = yypv;
  260.         yy_ps = yyps;
  261.         yy_state = yystate;
  262.  
  263.         /*
  264.         ** top of for (;;) loop while no reductions done
  265.         */
  266.     yy_stack:
  267.         /*
  268.         ** put a state and value onto the stacks
  269.         */
  270. #if YYDEBUG
  271.         /*
  272.         ** if debugging, look up token value in list of value vs.
  273.         ** name pairs.  0 and negative (-1) are special values.
  274.         ** Note: linear search is used since time is not a real
  275.         ** consideration while debugging.
  276.         */
  277.         if ( yydebug )
  278.         {
  279.             register int yy_i;
  280.  
  281.             (void)printf( "State %d, token ", yy_state );
  282.             if ( yychar == 0 )
  283.                 (void)printf( "end-of-file\n" );
  284.             else if ( yychar < 0 )
  285.                 (void)printf( "-none-\n" );
  286.             else
  287.             {
  288.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  289.                     yy_i++ )
  290.                 {
  291.                     if ( yytoks[yy_i].t_val == yychar )
  292.                         break;
  293.                 }
  294.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  295.             }
  296.         }
  297. #endif /* YYDEBUG */
  298.         if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
  299.         {
  300.             /*
  301.             ** reallocate and recover.  Note that pointers
  302.             ** have to be reset, or bad things will happen
  303.             */
  304.             int yyps_index = (yy_ps - yys);
  305.             int yypv_index = (yy_pv - yyv);
  306.             int yypvt_index = (yypvt - yyv);
  307.             yymaxdepth += YYMAXDEPTH;
  308.             yyv = (YYSTYPE*)realloc((char*)yyv,
  309.                 yymaxdepth * sizeof(YYSTYPE));
  310.             yys = (int*)realloc((char*)yys,
  311.                 yymaxdepth * sizeof(int));
  312.             if (!yyv || !yys)
  313.             {
  314.                 yyerror( "yacc stack overflow" );
  315.                 return(1);
  316.             }
  317.             yy_ps = yys + yyps_index;
  318.             yy_pv = yyv + yypv_index;
  319.             yypvt = yyv + yypvt_index;
  320.         }
  321.         *yy_ps = yy_state;
  322.         *++yy_pv = yyval;
  323.  
  324.         /*
  325.         ** we have a new state - find out what to do
  326.         */
  327.     yy_newstate:
  328.         if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  329.             goto yydefault;        /* simple state */
  330. #if YYDEBUG
  331.         /*
  332.         ** if debugging, need to mark whether new token grabbed
  333.         */
  334.         yytmp = yychar < 0;
  335. #endif
  336.         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  337.             yychar = 0;        /* reached EOF */
  338. #if YYDEBUG
  339.         if ( yydebug && yytmp )
  340.         {
  341.             register int yy_i;
  342.  
  343.             (void)printf( "Received token " );
  344.             if ( yychar == 0 )
  345.                 (void)printf( "end-of-file\n" );
  346.             else if ( yychar < 0 )
  347.                 (void)printf( "-none-\n" );
  348.             else
  349.             {
  350.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  351.                     yy_i++ )
  352.                 {
  353.                     if ( yytoks[yy_i].t_val == yychar )
  354.                         break;
  355.                 }
  356.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  357.             }
  358.         }
  359. #endif /* YYDEBUG */
  360.         if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  361.             goto yydefault;
  362.         if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
  363.         {
  364.             yychar = -1;
  365.             yyval = yylval;
  366.             yy_state = yy_n;
  367.             if ( yyerrflag > 0 )
  368.                 yyerrflag--;
  369.             goto yy_stack;
  370.         }
  371.  
  372.     yydefault:
  373.         if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  374.         {
  375. #if YYDEBUG
  376.             yytmp = yychar < 0;
  377. #endif
  378.             if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  379.                 yychar = 0;        /* reached EOF */
  380. #if YYDEBUG
  381.             if ( yydebug && yytmp )
  382.             {
  383.                 register int yy_i;
  384.  
  385.                 (void)printf( "Received token " );
  386.                 if ( yychar == 0 )
  387.                     (void)printf( "end-of-file\n" );
  388.                 else if ( yychar < 0 )
  389.                     (void)printf( "-none-\n" );
  390.                 else
  391.                 {
  392.                     for ( yy_i = 0;
  393.                         yytoks[yy_i].t_val >= 0;
  394.                         yy_i++ )
  395.                     {
  396.                         if ( yytoks[yy_i].t_val
  397.                             == yychar )
  398.                         {
  399.                             break;
  400.                         }
  401.                     }
  402.                     (void)printf( "%s\n", yytoks[yy_i].t_name );
  403.                 }
  404.             }
  405. #endif /* YYDEBUG */
  406.             /*
  407.             ** look through exception table
  408.             */
  409.             {
  410.                 register int *yyxi = yyexca;
  411.  
  412.                 while ( ( *yyxi != -1 ) ||
  413.                     ( yyxi[1] != yy_state ) )
  414.                 {
  415.                     yyxi += 2;
  416.                 }
  417.                 while ( ( *(yyxi += 2) >= 0 ) &&
  418.                     ( *yyxi != yychar ) )
  419.                     ;
  420.                 if ( ( yy_n = yyxi[1] ) < 0 )
  421.                     YYACCEPT;
  422.             }
  423.         }
  424.  
  425.         /*
  426.         ** check for syntax error
  427.         */
  428.         if ( yy_n == 0 )    /* have an error */
  429.         {
  430.             /* no worry about speed here! */
  431.             switch ( yyerrflag )
  432.             {
  433.             case 0:        /* new error */
  434.                 yyerror( "syntax error" );
  435.                 goto skip_init;
  436.             yyerrlab:
  437.                 /*
  438.                 ** get globals into registers.
  439.                 ** we have a user generated syntax type error
  440.                 */
  441.                 yy_pv = yypv;
  442.                 yy_ps = yyps;
  443.                 yy_state = yystate;
  444.                 yynerrs++;
  445.             skip_init:
  446.             case 1:
  447.             case 2:        /* incompletely recovered error */
  448.                     /* try again... */
  449.                 yyerrflag = 3;
  450.                 /*
  451.                 ** find state where "error" is a legal
  452.                 ** shift action
  453.                 */
  454.                 while ( yy_ps >= yys )
  455.                 {
  456.                     yy_n = yypact[ *yy_ps ] + YYERRCODE;
  457.                     if ( yy_n >= 0 && yy_n < YYLAST &&
  458.                         yychk[yyact[yy_n]] == YYERRCODE)                    {
  459.                         /*
  460.                         ** simulate shift of "error"
  461.                         */
  462.                         yy_state = yyact[ yy_n ];
  463.                         goto yy_stack;
  464.                     }
  465.                     /*
  466.                     ** current state has no shift on
  467.                     ** "error", pop stack
  468.                     */
  469. #if YYDEBUG
  470. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  471.                     if ( yydebug )
  472.                         (void)printf( _POP_, *yy_ps,
  473.                             yy_ps[-1] );
  474. #    undef _POP_
  475. #endif
  476.                     yy_ps--;
  477.                     yy_pv--;
  478.                 }
  479.                 /*
  480.                 ** there is no state on stack with "error" as
  481.                 ** a valid shift.  give up.
  482.                 */
  483.                 YYABORT;
  484.             case 3:        /* no shift yet; eat a token */
  485. #if YYDEBUG
  486.                 /*
  487.                 ** if debugging, look up token in list of
  488.                 ** pairs.  0 and negative shouldn't occur,
  489.                 ** but since timing doesn't matter when
  490.                 ** debugging, it doesn't hurt to leave the
  491.                 ** tests here.
  492.                 */
  493.                 if ( yydebug )
  494.                 {
  495.                     register int yy_i;
  496.  
  497.                     (void)printf( "Error recovery discards " );
  498.                     if ( yychar == 0 )
  499.                         (void)printf( "token end-of-file\n" );
  500.                     else if ( yychar < 0 )
  501.                         (void)printf( "token -none-\n" );
  502.                     else
  503.                     {
  504.                         for ( yy_i = 0;
  505.                             yytoks[yy_i].t_val >= 0;
  506.                             yy_i++ )
  507.                         {
  508.                             if ( yytoks[yy_i].t_val
  509.                                 == yychar )
  510.                             {
  511.                                 break;
  512.                             }
  513.                         }
  514.                         (void)printf( "token %s\n",
  515.                             yytoks[yy_i].t_name );
  516.                     }
  517.                 }
  518. #endif /* YYDEBUG */
  519.                 if ( yychar == 0 )    /* reached EOF. quit */
  520.                     YYABORT;
  521.                 yychar = -1;
  522.                 goto yy_newstate;
  523.             }
  524.         }/* end if ( yy_n == 0 ) */
  525.         /*
  526.         ** reduction by production yy_n
  527.         ** put stack tops, etc. so things right after switch
  528.         */
  529. #if YYDEBUG
  530.         /*
  531.         ** if debugging, print the string that is the user's
  532.         ** specification of the reduction which is just about
  533.         ** to be done.
  534.         */
  535.         if ( yydebug )
  536.             (void)printf( "Reduce by (%d) \"%s\"\n",
  537.                 yy_n, yyreds[ yy_n ] );
  538. #endif
  539.         yytmp = yy_n;            /* value to switch over */
  540.         yypvt = yy_pv;            /* $vars top of value stack */
  541.         /*
  542.         ** Look in goto table for next state
  543.         ** Sorry about using yy_state here as temporary
  544.         ** register variable, but why not, if it works...
  545.         ** If yyr2[ yy_n ] doesn't have the low order bit
  546.         ** set, then there is no action to be done for
  547.         ** this reduction.  So, no saving & unsaving of
  548.         ** registers done.  The only difference between the
  549.         ** code just after the if and the body of the if is
  550.         ** the goto yy_stack in the body.  This way the test
  551.         ** can be made before the choice of what to do is needed.
  552.         */
  553.         {
  554.             /* length of production doubled with extra bit */
  555.             register int yy_len = yyr2[ yy_n ];
  556.  
  557.             if ( !( yy_len & 01 ) )
  558.             {
  559.                 yy_len >>= 1;
  560.                 yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  561.                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  562.                     *( yy_ps -= yy_len ) + 1;
  563.                 if ( yy_state >= YYLAST ||
  564.                     yychk[ yy_state =
  565.                     yyact[ yy_state ] ] != -yy_n )
  566.                 {
  567.                     yy_state = yyact[ yypgo[ yy_n ] ];
  568.                 }
  569.                 goto yy_stack;
  570.             }
  571.             yy_len >>= 1;
  572.             yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  573.             yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  574.                 *( yy_ps -= yy_len ) + 1;
  575.             if ( yy_state >= YYLAST ||
  576.                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  577.             {
  578.                 yy_state = yyact[ yypgo[ yy_n ] ];
  579.             }
  580.         }
  581.                     /* save until reenter driver code */
  582.         yystate = yy_state;
  583.         yyps = yy_ps;
  584.         yypv = yy_pv;
  585.     }
  586.     /*
  587.     ** code supplied by user is placed in this switch
  588.     */
  589.     switch( yytmp )
  590.     {
  591.         
  592. case 1:
  593. # line 32 "lp.y"
  594. {
  595.   init_read();
  596.   isign = 0;
  597.   make_neg = 0;
  598. } break;
  599. case 5:
  600. # line 49 "lp.y"
  601. {
  602.   store_re_op();
  603.   make_neg = 1; 
  604. } break;
  605. case 6:
  606. # line 55 "lp.y"
  607. {
  608.   if(Lin_term_count == 0)
  609.     
  610.     {
  611.       fprintf(stderr, "WARNING line %d: constraint contains no variables\n",
  612.           yylineno);
  613.       null_tmp_store();
  614.     }
  615.   if(Lin_term_count  > 1)
  616.     Rows++;
  617.   if(Lin_term_count == 1)
  618.     store_bounds();
  619.   Lin_term_count = 0;
  620.   isign = 0 ; make_neg = 0;
  621. } break;
  622. case 12:
  623. # line 83 "lp.y"
  624. {/* check_decl(yytext);*/} break;
  625. case 13:
  626. # line 86 "lp.y"
  627. {add_int_var(yytext);} break;
  628. case 14:
  629. # line 87 "lp.y"
  630. {add_int_var(yytext);} break;
  631. case 15:
  632. # line 88 "lp.y"
  633. {add_int_var(yytext);} break;
  634. case 17:
  635. # line 93 "lp.y"
  636. {
  637.   isign = Sign; 
  638. } break;
  639. case 19:
  640. # line 99 "lp.y"
  641. {
  642.   isign = Sign; 
  643. } break;
  644. case 22:
  645. # line 107 "lp.y"
  646. {
  647.   if (isign ^ (!make_neg))
  648.     f = -f;
  649.   rhs_store(f);
  650.   isign = 0;
  651. } break;
  652. case 24:
  653. # line 117 "lp.y"
  654. {
  655.   isign = Sign;
  656. } break;
  657. case 26:
  658. # line 123 "lp.y"
  659. {
  660.   isign = Sign;
  661. } break;
  662. case 28:
  663. # line 130 "lp.y"
  664. {
  665.   if (isign ^ make_neg)
  666.     var_store(Last_var, Rows, (double)-1);
  667.   else
  668.     var_store(Last_var, Rows, (double)1);
  669.   isign = 0;
  670. } break;
  671. case 29:
  672. # line 139 "lp.y"
  673. {
  674.   if (isign ^ make_neg)
  675.     f = -f;
  676.   var_store(Last_var, Rows, f);
  677.   isign = 0;
  678. } break;
  679. case 30:
  680. # line 148 "lp.y"
  681. {
  682.   if (isign ^ make_neg)
  683.     f = -f;
  684.   var_store(Last_var, Rows, f);
  685.   isign = 0;
  686. } break;
  687. case 31:
  688. # line 158 "lp.y"
  689. {
  690.   Rows++;
  691.   Lin_term_count  =  0;
  692.   isign = 0;
  693.   make_neg = 0;
  694. } break;
  695.     }
  696.     goto yystack;        /* reset registers in driver code */
  697. }
  698.