`CalculatorParser.java`

    // *******************************************************************
    // This file has been automatically generated from the grammar in file
    // Calculator.grm by ilog.language.syntax.ParserGenerator on
    // Mon Dec 20 18:05:13 PST 2004 --- !!! PLEASE DO NO EDIT !!!
    // *******************************************************************

    import java.io.Reader;
    import java.io.StringReader;
    import java.io.IOException;
    import ilog.language.syntax.*;
    import java.util.HashMap;

    /* ************ */
    /* PARSER CLASS */
    /* ************ */

    public class CalculatorParser extends StaticParser
    {
      /* ************************ */
      /* PARSER CLASS CONSTRUCTOR */
      /* ************************ */

      public CalculatorParser(Tokenizer t)
        {
          input = t;
          admitsOperators = false;
        }

      /* ************************* */
      /* PARSER CLASS DECLARATIONS */
      /* ************************* */

      HashMap defs = new HashMap();

      /* ********************** */
      /* STATIC INITIALIZATIONS */
      /* ********************** */

      static
        {
          initializeTerminals();
          initializeNonTerminals();
          initializeRules();
          initializeParserActions();
          initializeParserStates();
          initializeActionTables();
          initializeGotoTables();
          initializeStateTables();
        }

      /* ********************* */
      /* PARTIAL PARSE METHODS */
      /* ********************* */

      final static ParseNode $SESSION_SWITCH$ = new ParseNode(terminals[3]);

      public final void parseSession (String s) throws IOException
        {
          parseSession(new StringReader(s));
        }

      public final void parseSession (Reader r) throws IOException
        {
          input.setReader(r);
          errorManager().recoverFromErrors(false);
          setSwitchToken($SESSION_SWITCH$);
          parse();
        }

      final static ParseNode $DEFINITION_SWITCH$ = new ParseNode(terminals[5]);

      public final void parseDefinition (String s) throws IOException
        {
          parseDefinition(new StringReader(s));
        }

      public final void parseDefinition (Reader r) throws IOException
        {
          input.setReader(r);
          errorManager().recoverFromErrors(false);
          setSwitchToken($DEFINITION_SWITCH$);
          parse();
        }

      final static ParseNode $EXPRESSION_SWITCH$ = new ParseNode(terminals[4]);

      public final void parseExpression (String s) throws IOException
        {
          parseExpression(new StringReader(s));
        }

      public final void parseExpression (Reader r) throws IOException
        {
          input.setReader(r);
          errorManager().recoverFromErrors(false);
          setSwitchToken($EXPRESSION_SWITCH$);
          parse();
        }

      /* **************** */
      /* SEMANTIC ACTIONS */
      /* **************** */

      protected ParseNode semanticAction(ParserRule $rule$) throws IOException
        {
          ParseNode $head$ = new ParseNode($rule$.head);

          switch($rule$.index())
            {
              case 2:
                {
                $head$ = $head$.copy(node($rule$,2));
                break;
                }
              case 3:
                {
                $head$ = $head$.copy(node($rule$,2));
                break;
                }
              case 4:
                {
                $head$ = $head$.copy(node($rule$,2));
                break;
                }
              case 8:
                {
                currentNode().show(); // show the current parse tree
                if (!Double.isNaN(node($rule$,0).nvalue())) System.out.println(node($rule$,0).nvalue());
                CalculatorTokenizer.prompt();
                break;
                }
              case 10:
                {
                CalculatorDefinition $node1$;
                    if (node($rule$,0) instanceof CalculatorDefinition)
                       $node1$ = (CalculatorDefinition)node($rule$,0);
                     else
                     {
                         $node1$ = new CalculatorDefinition(node($rule$,0));
                         replaceStackNode($rule$,0,$node1$);
                       }

                currentNode().show(); // show the current parse tree
                System.out.println($node1$.getMessage());
                CalculatorTokenizer.prompt();
                break;
                }
              case 12:
                {
                errorManager().reportErrors(true);
                CalculatorTokenizer.prompt();
                break;
                }
              case 14:
                {
                Double value = (Double)defs.get(node($rule$,1).svalue());
                if (value == null)
                  System.out.println("*** Undefined identifier: "+node($rule$,1).svalue());
                else
                  $head$.setNvalue(value.doubleValue());
                break;
                }
              case 16:
                {
                $head$.setNvalue(node($rule$,1).nvalue() + node($rule$,3).nvalue());
                break;
                }
              case 17:
                {
                $head$.setNvalue(node($rule$,1).nvalue() - node($rule$,3).nvalue());
                break;
                }
              case 18:
                {
                $head$.setNvalue(node($rule$,1).nvalue() * node($rule$,3).nvalue());
                break;
                }
              case 19:
                {
                $head$.setNvalue(node($rule$,1).nvalue() / node($rule$,3).nvalue());
                break;
                }
              case 20:
                {
                $head$.setNvalue(- node($rule$,2).nvalue());
                break;
                }
              case 21:
                {
                $head$.setNvalue(node($rule$,2).nvalue());
                break;
                }
              case 22:
                {
                CalculatorDefinition $node0$ = new CalculatorDefinition($head$);
                     $head$ = (CalculatorDefinition)$node0$;

                defs.put(node($rule$,1).svalue(),new Double(node($rule$,3).nvalue()));
                $node0$.setNvalue(node($rule$,3).nvalue());
                $node0$.setSvalue(node($rule$,1).svalue());
                $node0$.setMessage("*** Defined "+$node0$.svalue()+" ("+$node0$.nvalue()+")");
                break;
                }
              case 23:
                {
                System.out.println("*** Bye bye!...");
                System.exit(0);
                break;
                }
              case 0: case 1: case 6:
                break;
              default:
                $head$ = $head$.copy(node($rule$,1));
                break;
            }
          return $head$;
        }

      /* **************** */
      /* TERMINAL SYMBOLS */
      /* **************** */

      static void initializeTerminals ()
        {
          terminals = new ParserTerminal[18];

          newTerminal(0,"$EMPTY$",1,2);
          newTerminal(1,"$E_O_I$",1,2);
          newTerminal(2,"error",1,2);
          newTerminal(3,"$Session_switch$",1,2);
          newTerminal(4,"$Expression_switch$",1,2);
          newTerminal(5,"$Definition_switch$",1,2);
          newTerminal(6,"NUMBER",1,2);
          newTerminal(7,"IDENTIFIER",1,2);
          newTerminal(8,"+",11,0);
          newTerminal(9,"-",11,0);
          newTerminal(10,"*",21,0);
          newTerminal(11,"/",21,0);
          newTerminal(12,"UMINUS",31,1);
          newTerminal(13,";",1,2);
          newTerminal(14,"(",1,2);
          newTerminal(15,")",1,2);
          newTerminal(16,"=",1,2);
          newTerminal(17,"exit",1,2);
        }

      /* ******************** */
      /* NON-TERMINAL SYMBOLS */
      /* ******************** */

      static void initializeNonTerminals ()
        {
          nonterminals = new ParserNonTerminal[12];

          newNonTerminal(0,"$START$");
          newNonTerminal(1,"$ROOTS$");
          newNonTerminal(2,"Session");
          newNonTerminal(3,"Expression");
          newNonTerminal(4,"Definition");
          newNonTerminal(5,"Actions");
          newNonTerminal(6,"Exit");
          newNonTerminal(7,"Action");
          newNonTerminal(8,"$ACTION0$");
          newNonTerminal(9,"$ACTION1$");
          newNonTerminal(10,"$ACTION2$");
          newNonTerminal(11,"$ACTION3$");
        }

      /* **************** */
      /* PRODUCTION RULES */
      /* **************** */

      static void initializeRules ()
        {
          rules = new ParserRule[25];

          rules[0] = new ParserRule(0,1,0,1,2);
          rules[1] = new ParserRule(1,1,1,1,2);
          rules[2] = new ParserRule(1,2,2,1,2);
          rules[3] = new ParserRule(1,2,3,1,2);
          rules[4] = new ParserRule(1,2,4,1,2);
          rules[5] = new ParserRule(2,2,5,1,2);
          rules[6] = new ParserRule(5,0,6,1,2);
          rules[7] = new ParserRule(5,2,7,1,2);
          rules[8] = new ParserRule(8,0,8,1,2);
          rules[9] = new ParserRule(7,3,9,1,2);
          rules[10] = new ParserRule(9,0,10,1,2);
          rules[11] = new ParserRule(7,3,11,1,2);
          rules[12] = new ParserRule(10,0,12,1,2);
          rules[13] = new ParserRule(7,3,13,1,2);
          rules[14] = new ParserRule(3,1,14,1,2);
          rules[15] = new ParserRule(3,1,15,1,2);
          rules[16] = new ParserRule(3,3,16,11,0);
          rules[17] = new ParserRule(3,3,17,11,0);
          rules[18] = new ParserRule(3,3,18,21,0);
          rules[19] = new ParserRule(3,3,19,21,0);
          rules[20] = new ParserRule(3,2,20,31,1);
          rules[21] = new ParserRule(3,3,21,1,2);
          rules[22] = new ParserRule(4,3,22,1,2);
          rules[23] = new ParserRule(11,0,23,1,2);
          rules[24] = new ParserRule(6,3,24,1,2);
        }

      /* ************** */
      /* PARSER ACTIONS */
      /* ************** */

      static void initializeParserActions ()
        {
          actions = new ParserAction[235];

          newAction(0,5,0);
          newAction(1,2,0);
          newAction(2,0,2);
          newAction(3,0,4);
          newAction(4,0,6);
          newAction(5,1,6);
          newAction(6,1,6);
          newAction(7,1,6);
          newAction(8,1,6);
          newAction(9,1,6);
          newAction(10,1,6);
          newAction(11,1,1);
          newAction(12,0,10);
          newAction(13,0,11);
          newAction(14,0,12);
          newAction(15,0,14);
          newAction(16,1,6);
          newAction(17,1,6);
          newAction(18,1,6);
          newAction(19,1,6);
          newAction(20,1,6);
          newAction(21,1,6);
          newAction(22,0,26);
          newAction(23,0,27);
          newAction(24,0,10);
          newAction(25,0,11);
          newAction(26,0,12);
          newAction(27,0,31);
          newAction(28,0,8);
          newAction(29,1,4);
          newAction(30,0,9);
          newAction(31,0,10);
          newAction(32,0,11);
          newAction(33,0,12);
          newAction(34,0,14);
          newAction(35,0,10);
          newAction(36,0,11);
          newAction(37,0,12);
          newAction(38,0,14);
          newAction(39,1,15);
          newAction(40,1,15);
          newAction(41,1,15);
          newAction(42,1,15);
          newAction(43,1,15);
          newAction(44,1,15);
          newAction(45,1,15);
          newAction(46,1,15);
          newAction(47,1,15);
          newAction(48,1,15);
          newAction(49,1,15);
          newAction(50,1,15);
          newAction(51,0,10);
          newAction(52,0,11);
          newAction(53,0,12);
          newAction(54,0,14);
          newAction(55,0,15);
          newAction(56,0,16);
          newAction(57,0,17);
          newAction(58,0,18);
          newAction(59,1,22);
          newAction(60,1,22);
          newAction(61,1,14);
          newAction(62,1,14);
          newAction(63,1,14);
          newAction(64,1,14);
          newAction(65,1,14);
          newAction(66,1,14);
          newAction(67,1,14);
          newAction(68,1,14);
          newAction(69,1,14);
          newAction(70,1,14);
          newAction(71,1,14);
          newAction(72,1,14);
          newAction(73,0,10);
          newAction(74,0,11);
          newAction(75,0,12);
          newAction(76,0,14);
          newAction(77,0,10);
          newAction(78,0,11);
          newAction(79,0,12);
          newAction(80,0,14);
          newAction(81,0,10);
          newAction(82,0,11);
          newAction(83,0,12);
          newAction(84,0,14);
          newAction(85,0,10);
          newAction(86,0,11);
          newAction(87,0,12);
          newAction(88,0,14);
          newAction(89,0,15);
          newAction(90,0,16);
          newAction(91,0,17);
          newAction(92,0,18);
          newAction(93,1,18);
          newAction(94,1,18);
          newAction(95,1,18);
          newAction(96,1,18);
          newAction(97,1,18);
          newAction(98,1,18);
          newAction(99,1,18);
          newAction(100,1,18);
          newAction(101,1,18);
          newAction(102,1,18);
          newAction(103,1,18);
          newAction(104,1,18);
          newAction(105,0,15);
          newAction(106,0,16);
          newAction(107,0,17);
          newAction(108,0,18);
          newAction(109,1,19);
          newAction(110,1,19);
          newAction(111,1,19);
          newAction(112,1,19);
          newAction(113,1,19);
          newAction(114,1,19);
          newAction(115,1,19);
          newAction(116,1,19);
          newAction(117,1,19);
          newAction(118,1,19);
          newAction(119,1,19);
          newAction(120,1,19);
          newAction(121,0,15);
          newAction(122,0,16);
          newAction(123,0,17);
          newAction(124,0,18);
          newAction(125,1,16);
          newAction(126,1,16);
          newAction(127,1,16);
          newAction(128,1,16);
          newAction(129,1,16);
          newAction(130,1,16);
          newAction(131,1,16);
          newAction(132,1,16);
          newAction(133,1,16);
          newAction(134,1,16);
          newAction(135,0,15);
          newAction(136,0,16);
          newAction(137,0,17);
          newAction(138,0,18);
          newAction(139,1,17);
          newAction(140,1,17);
          newAction(141,1,17);
          newAction(142,1,17);
          newAction(143,1,17);
          newAction(144,1,17);
          newAction(145,1,17);
          newAction(146,1,17);
          newAction(147,1,17);
          newAction(148,1,17);
          newAction(149,0,24);
          newAction(150,0,15);
          newAction(151,0,16);
          newAction(152,0,17);
          newAction(153,0,18);
          newAction(154,1,21);
          newAction(155,1,21);
          newAction(156,1,21);
          newAction(157,1,21);
          newAction(158,1,21);
          newAction(159,1,21);
          newAction(160,1,21);
          newAction(161,1,21);
          newAction(162,1,21);
          newAction(163,1,21);
          newAction(164,1,21);
          newAction(165,1,21);
          newAction(166,0,15);
          newAction(167,0,16);
          newAction(168,0,17);
          newAction(169,0,18);
          newAction(170,1,20);
          newAction(171,1,20);
          newAction(172,1,20);
          newAction(173,1,20);
          newAction(174,1,20);
          newAction(175,1,20);
          newAction(176,1,20);
          newAction(177,1,20);
          newAction(178,1,20);
          newAction(179,1,20);
          newAction(180,1,20);
          newAction(181,1,20);
          newAction(182,1,23);
          newAction(183,1,12);
          newAction(184,1,10);
          newAction(185,1,5);
          newAction(186,0,15);
          newAction(187,0,16);
          newAction(188,0,17);
          newAction(189,0,18);
          newAction(190,1,8);
          newAction(191,0,9);
          newAction(192,1,14);
          newAction(193,1,14);
          newAction(194,1,14);
          newAction(195,1,14);
          newAction(196,1,14);
          newAction(197,1,7);
          newAction(198,1,7);
          newAction(199,1,7);
          newAction(200,1,7);
          newAction(201,1,7);
          newAction(202,1,7);
          newAction(203,0,34);
          newAction(204,1,9);
          newAction(205,1,9);
          newAction(206,1,9);
          newAction(207,1,9);
          newAction(208,1,9);
          newAction(209,1,9);
          newAction(210,1,9);
          newAction(211,0,36);
          newAction(212,1,11);
          newAction(213,1,11);
          newAction(214,1,11);
          newAction(215,1,11);
          newAction(216,1,11);
          newAction(217,1,11);
          newAction(218,1,11);
          newAction(219,0,38);
          newAction(220,1,13);
          newAction(221,1,13);
          newAction(222,1,13);
          newAction(223,1,13);
          newAction(224,1,13);
          newAction(225,1,13);
          newAction(226,1,13);
          newAction(227,0,40);
          newAction(228,1,24);
          newAction(229,1,2);
          newAction(230,0,15);
          newAction(231,0,16);
          newAction(232,0,17);
          newAction(233,0,18);
          newAction(234,1,3);
        }

      /* ************* */
      /* PARSER STATES */
      /* ************* */

      static void initializeParserStates ()
        {
          states = new ParserState[43];

          for (int i=0; i<43; i++) newState(i);
        }

      /* ************* */
      /* ACTION TABLES */
      /* ************* */

      static void initializeActionTables ()
        {
          newActionTables(36);

          newActionTable(0,9);
    	setAction(0,17,10);
    	setAction(0,2,5);
    	setAction(0,4,2);
    	setAction(0,9,8);
    	setAction(0,6,6);
    	setAction(0,14,9);
    	setAction(0,3,3);
    	setAction(0,7,7);
    	setAction(0,5,4);

          newActionTable(1,1);
    	setAction(1,1,11);

          newActionTable(2,4);
    	setAction(2,9,12);
    	setAction(2,6,13);
    	setAction(2,14,14);
    	setAction(2,7,15);

          newActionTable(3,1);
    	setAction(3,1,1);

          newActionTable(4,6);
    	setAction(4,17,21);
    	setAction(4,2,16);
    	setAction(4,9,19);
    	setAction(4,6,17);
    	setAction(4,14,20);
    	setAction(4,7,18);

          newActionTable(5,6);
    	setAction(5,17,22);
    	setAction(5,2,23);
    	setAction(5,9,24);
    	setAction(5,6,25);
    	setAction(5,14,26);
    	setAction(5,7,27);

          newActionTable(6,1);
    	setAction(6,7,28);

          newActionTable(7,1);
    	setAction(7,1,29);

          newActionTable(8,1);
    	setAction(8,16,30);

          newActionTable(9,12);
    	setAction(9,17,50);
    	setAction(9,15,49);
    	setAction(9,2,40);
    	setAction(9,13,47);
    	setAction(9,9,44);
    	setAction(9,8,43);
    	setAction(9,11,46);
    	setAction(9,6,41);
    	setAction(9,1,39);
    	setAction(9,14,48);
    	setAction(9,10,45);
    	setAction(9,7,42);

          newActionTable(10,6);
    	setAction(10,13,60);
    	setAction(10,8,56);
    	setAction(10,9,55);
    	setAction(10,11,57);
    	setAction(10,1,59);
    	setAction(10,10,58);

          newActionTable(11,12);
    	setAction(11,17,72);
    	setAction(11,15,71);
    	setAction(11,2,62);
    	setAction(11,13,69);
    	setAction(11,9,66);
    	setAction(11,8,65);
    	setAction(11,11,68);
    	setAction(11,6,63);
    	setAction(11,1,61);
    	setAction(11,14,70);
    	setAction(11,10,67);
    	setAction(11,7,64);

          newActionTable(12,12);
    	setAction(12,17,104);
    	setAction(12,15,103);
    	setAction(12,2,94);
    	setAction(12,13,101);
    	setAction(12,8,97);
    	setAction(12,9,98);
    	setAction(12,6,95);
    	setAction(12,11,100);
    	setAction(12,1,93);
    	setAction(12,14,102);
    	setAction(12,7,96);
    	setAction(12,10,99);

          newActionTable(13,12);
    	setAction(13,17,120);
    	setAction(13,15,119);
    	setAction(13,2,110);
    	setAction(13,13,117);
    	setAction(13,8,113);
    	setAction(13,9,114);
    	setAction(13,6,111);
    	setAction(13,11,116);
    	setAction(13,1,109);
    	setAction(13,14,118);
    	setAction(13,7,112);
    	setAction(13,10,115);

          newActionTable(14,12);
    	setAction(14,17,134);
    	setAction(14,15,133);
    	setAction(14,2,126);
    	setAction(14,13,131);
    	setAction(14,8,129);
    	setAction(14,9,130);
    	setAction(14,6,127);
    	setAction(14,11,123);
    	setAction(14,1,125);
    	setAction(14,14,132);
    	setAction(14,7,128);
    	setAction(14,10,124);

          newActionTable(15,12);
    	setAction(15,17,148);
    	setAction(15,15,147);
    	setAction(15,2,140);
    	setAction(15,13,145);
    	setAction(15,8,143);
    	setAction(15,9,144);
    	setAction(15,6,141);
    	setAction(15,11,137);
    	setAction(15,1,139);
    	setAction(15,14,146);
    	setAction(15,7,142);
    	setAction(15,10,138);

          newActionTable(16,5);
    	setAction(16,15,149);
    	setAction(16,8,151);
    	setAction(16,9,150);
    	setAction(16,11,152);
    	setAction(16,10,153);

          newActionTable(17,12);
    	setAction(17,17,165);
    	setAction(17,15,164);
    	setAction(17,2,155);
    	setAction(17,13,162);
    	setAction(17,9,159);
    	setAction(17,8,158);
    	setAction(17,11,161);
    	setAction(17,6,156);
    	setAction(17,1,154);
    	setAction(17,14,163);
    	setAction(17,10,160);
    	setAction(17,7,157);

          newActionTable(18,12);
    	setAction(18,17,181);
    	setAction(18,15,180);
    	setAction(18,2,171);
    	setAction(18,13,178);
    	setAction(18,8,174);
    	setAction(18,9,175);
    	setAction(18,6,172);
    	setAction(18,11,177);
    	setAction(18,1,170);
    	setAction(18,14,179);
    	setAction(18,7,173);
    	setAction(18,10,176);

          newActionTable(19,1);
    	setAction(19,13,182);

          newActionTable(20,1);
    	setAction(20,13,183);

          newActionTable(21,1);
    	setAction(21,13,184);

          newActionTable(22,1);
    	setAction(22,1,185);

          newActionTable(23,5);
    	setAction(23,13,190);
    	setAction(23,8,187);
    	setAction(23,9,186);
    	setAction(23,11,188);
    	setAction(23,10,189);

          newActionTable(24,6);
    	setAction(24,13,196);
    	setAction(24,9,193);
    	setAction(24,8,192);
    	setAction(24,11,195);
    	setAction(24,16,191);
    	setAction(24,10,194);

          newActionTable(25,6);
    	setAction(25,17,202);
    	setAction(25,2,197);
    	setAction(25,9,200);
    	setAction(25,6,198);
    	setAction(25,14,201);
    	setAction(25,7,199);

          newActionTable(26,1);
    	setAction(26,13,203);

          newActionTable(27,7);
    	setAction(27,17,210);
    	setAction(27,2,205);
    	setAction(27,9,208);
    	setAction(27,6,206);
    	setAction(27,1,204);
    	setAction(27,14,209);
    	setAction(27,7,207);

          newActionTable(28,1);
    	setAction(28,13,211);

          newActionTable(29,7);
    	setAction(29,17,218);
    	setAction(29,2,213);
    	setAction(29,9,216);
    	setAction(29,6,214);
    	setAction(29,1,212);
    	setAction(29,14,217);
    	setAction(29,7,215);

          newActionTable(30,1);
    	setAction(30,13,219);

          newActionTable(31,7);
    	setAction(31,17,226);
    	setAction(31,2,221);
    	setAction(31,9,224);
    	setAction(31,6,222);
    	setAction(31,1,220);
    	setAction(31,14,225);
    	setAction(31,7,223);

          newActionTable(32,1);
    	setAction(32,13,227);

          newActionTable(33,1);
    	setAction(33,1,228);

          newActionTable(34,1);
    	setAction(34,1,229);

          newActionTable(35,5);
    	setAction(35,8,231);
    	setAction(35,9,230);
    	setAction(35,11,232);
    	setAction(35,1,234);
    	setAction(35,10,233);

        }

      /* *********** */
      /* GOTO TABLES */
      /* *********** */

      static void initializeGotoTables ()
        {
          newGotoTables(17);

          newGotoTable(0,3);
    	setGoto(0,2,1);
    	setGoto(0,1,3);
    	setGoto(0,5,5);

          newGotoTable(1,0);

          newGotoTable(2,1);
    	setGoto(2,3,42);

          newGotoTable(3,2);
    	setGoto(3,2,41);
    	setGoto(3,5,5);

          newGotoTable(4,4);
    	setGoto(4,4,28);
    	setGoto(4,6,29);
    	setGoto(4,3,30);
    	setGoto(4,7,32);

          newGotoTable(5,1);
    	setGoto(5,4,7);

          newGotoTable(6,1);
    	setGoto(6,3,13);

          newGotoTable(7,1);
    	setGoto(7,3,25);

          newGotoTable(8,1);
    	setGoto(8,3,23);

          newGotoTable(9,1);
    	setGoto(9,3,22);

          newGotoTable(10,1);
    	setGoto(10,3,21);

          newGotoTable(11,1);
    	setGoto(11,3,20);

          newGotoTable(12,1);
    	setGoto(12,3,19);

          newGotoTable(13,1);
    	setGoto(13,11,39);

          newGotoTable(14,1);
    	setGoto(14,10,37);

          newGotoTable(15,1);
    	setGoto(15,9,35);

          newGotoTable(16,1);
    	setGoto(16,8,33);

        }

      /* ************ */
      /* STATE TABLES */
      /* ************ */

      static void initializeStateTables ()
        {
          setTables(0,0,0);
          setTables(1,1,1);
          setTables(2,2,2);
          setTables(3,3,1);
          setTables(4,4,3);
          setTables(5,5,4);
          setTables(6,6,5);
          setTables(7,7,1);
          setTables(8,8,1);
          setTables(9,2,6);
          setTables(10,2,7);
          setTables(11,9,1);
          setTables(12,2,8);
          setTables(13,10,1);
          setTables(14,11,1);
          setTables(15,2,9);
          setTables(16,2,10);
          setTables(17,2,11);
          setTables(18,2,12);
          setTables(19,12,1);
          setTables(20,13,1);
          setTables(21,14,1);
          setTables(22,15,1);
          setTables(23,16,1);
          setTables(24,17,1);
          setTables(25,18,1);
          setTables(26,19,13);
          setTables(27,20,14);
          setTables(28,21,15);
          setTables(29,22,1);
          setTables(30,23,16);
          setTables(31,24,1);
          setTables(32,25,1);
          setTables(33,26,1);
          setTables(34,27,1);
          setTables(35,28,1);
          setTables(36,29,1);
          setTables(37,30,1);
          setTables(38,31,1);
          setTables(39,32,1);
          setTables(40,33,1);
          setTables(41,34,1);
          setTables(42,35,1);
        }
    }

This file was generated on Mon Dec 20 19:03:12 PST 2004 from file `CalculatorParser.java`
by the `ilog.language.tools.Hilite` Java tool written by Hassan Aït-Kaci