bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/parser/Parser.java

   1 /* This file was generated by SableCC (http://www.sablecc.org/). */
   2
   3 package org.simantics.basicexpression.parser;
   4
   5 import org.simantics.basicexpression.lexer.*;
   6 import org.simantics.basicexpression.node.*;
   7 import org.simantics.basicexpression.analysis.*;
   8 import java.util.*;
   9
  10 import java.io.DataInputStream;
  11 import java.io.BufferedInputStream;
  12 import java.io.IOException;
  13
  14 @SuppressWarnings("nls")
  15 public class Parser
  16 {
  17     public final Analysis ignoredTokens = new AnalysisAdapter();
  18
  19     protected ArrayList nodeList;
  20
  21     private final Lexer lexer;
  22     private final ListIterator stack = new LinkedList().listIterator();
  23     private int last_pos;
  24     private int last_line;
  25     private Token last_token;
  26     private final TokenIndex converter = new TokenIndex();
  27     private final int[] action = new int[2];
  28
  29     private final static int SHIFT = 0;
  30     private final static int REDUCE = 1;
  31     private final static int ACCEPT = 2;
  32     private final static int ERROR = 3;
  33
  34     public Parser(@SuppressWarnings("hiding") Lexer lexer)
  35     {
  36         this.lexer = lexer;
  37     }
  38
  39     protected void filter() throws ParserException, LexerException, IOException
  40     {
  41         // Empty body
  42     }
  43
  44     private void push(int numstate, ArrayList listNode, boolean hidden) throws ParserException, LexerException, IOException
  45     {
  46         this.nodeList = listNode;
  47
  48         if(!hidden)
  49         {
  50             filter();
  51         }
  52
  53         if(!this.stack.hasNext())
  54         {
  55             this.stack.add(new State(numstate, this.nodeList));
  56             return;
  57         }
  58
  59         State s = (State) this.stack.next();
  60         s.state = numstate;
  61         s.nodes = this.nodeList;
  62     }
  63
  64     private int goTo(int index)
  65     {
  66         int state = state();
  67         int low = 1;
  68         int high = gotoTable[index].length - 1;
  69         int value = gotoTable[index][0][1];
  70
  71         while(low <= high)
  72         {
  73             int middle = (low + high) / 2;
  74
  75             if(state < gotoTable[index][middle][0])
  76             {
  77                 high = middle - 1;
  78             }
  79             else if(state > gotoTable[index][middle][0])
  80             {
  81                 low = middle + 1;
  82             }
  83             else
  84             {
  85                 value = gotoTable[index][middle][1];
  86                 break;
  87             }
  88         }
  89
  90         return value;
  91     }
  92
  93     private int state()
  94     {
  95         State s = (State) this.stack.previous();
  96         this.stack.next();
  97         return s.state;
  98     }
  99
 100     private ArrayList pop()
 101     {
 102         return ((State) this.stack.previous()).nodes;
 103     }
 104
 105     private int index(Switchable token)
 106     {
 107         this.converter.index = -1;
 108         token.apply(this.converter);
 109         return this.converter.index;
 110     }
 111
 112     @SuppressWarnings("unchecked")
 113     public Start parse() throws ParserException, LexerException, IOException
 114     {
 115         push(0, null, true);
 116         List<Node> ign = null;
 117         while(true)
 118         {
 119             while(index(this.lexer.peek()) == -1)
 120             {
 121                 if(ign == null)
 122                 {
 123                     ign = new LinkedList<Node>();
 124                 }
 125
 126                 ign.add(this.lexer.next());
 127             }
 128
 129             if(ign != null)
 130             {
 131                 this.ignoredTokens.setIn(this.lexer.peek(), ign);
 132                 ign = null;
 133             }
 134
 135             this.last_pos = this.lexer.peek().getPos();
 136             this.last_line = this.lexer.peek().getLine();
 137             this.last_token = this.lexer.peek();
 138
 139             int index = index(this.lexer.peek());
 140             this.action[0] = Parser.actionTable[state()][0][1];
 141             this.action[1] = Parser.actionTable[state()][0][2];
 142
 143             int low = 1;
 144             int high = Parser.actionTable[state()].length - 1;
 145
 146             while(low <= high)
 147             {
 148                 int middle = (low + high) / 2;
 149
 150                 if(index < Parser.actionTable[state()][middle][0])
 151                 {
 152                     high = middle - 1;
 153                 }
 154                 else if(index > Parser.actionTable[state()][middle][0])
 155                 {
 156                     low = middle + 1;
 157                 }
 158                 else
 159                 {
 160                     this.action[0] = Parser.actionTable[state()][middle][1];
 161                     this.action[1] = Parser.actionTable[state()][middle][2];
 162                     break;
 163                 }
 164             }
 165
 166             switch(this.action[0])
 167             {
 168                 case SHIFT:
 169                     {
 170                         ArrayList list = new ArrayList();
 171                         list.add(this.lexer.next());
 172                         push(this.action[1], list, false);
 173                     }
 174                     break;
 175                 case REDUCE:
 176                     switch(this.action[1])
 177                     {
 178                     case 0: /* reduce AMultExpression */
 179                     {
 180                         ArrayList list = new0();
 181                         push(goTo(0), list, false);
 182                     }
 183                     break;
 184                     case 1: /* reduce APlusExpression */
 185                     {
 186                         ArrayList list = new1();
 187                         push(goTo(0), list, false);
 188                     }
 189                     break;
 190                     case 2: /* reduce AMinusExpression */
 191                     {
 192                         ArrayList list = new2();
 193                         push(goTo(0), list, false);
 194                     }
 195                     break;
 196                     case 3: /* reduce AUnaryMultiplicative */
 197                     {
 198                         ArrayList list = new3();
 199                         push(goTo(1), list, false);
 200                     }
 201                     break;
 202                     case 4: /* reduce AMultMultiplicative */
 203                     {
 204                         ArrayList list = new4();
 205                         push(goTo(1), list, false);
 206                     }
 207                     break;
 208                     case 5: /* reduce ADivMultiplicative */
 209                     {
 210                         ArrayList list = new5();
 211                         push(goTo(1), list, false);
 212                     }
 213                     break;
 214                     case 6: /* reduce APrimaryUnary */
 215                     {
 216                         ArrayList list = new6();
 217                         push(goTo(2), list, false);
 218                     }
 219                     break;
 220                     case 7: /* reduce AUnaryplusUnary */
 221                     {
 222                         ArrayList list = new7();
 223                         push(goTo(2), list, false);
 224                     }
 225                     break;
 226                     case 8: /* reduce AUnaryminusUnary */
 227                     {
 228                         ArrayList list = new8();
 229                         push(goTo(2), list, false);
 230                     }
 231                     break;
 232                     case 9: /* reduce ASingleArgList */
 233                     {
 234                         ArrayList list = new9();
 235                         push(goTo(3), list, false);
 236                     }
 237                     break;
 238                     case 10: /* reduce ASequenceArgList */
 239                     {
 240                         ArrayList list = new10();
 241                         push(goTo(3), list, false);
 242                     }
 243                     break;
 244                     case 11: /* reduce AValuePrimary */
 245                     {
 246                         ArrayList list = new11();
 247                         push(goTo(4), list, false);
 248                     }
 249                     break;
 250                     case 12: /* reduce AVariablePrimary */
 251                     {
 252                         ArrayList list = new12();
 253                         push(goTo(4), list, false);
 254                     }
 255                     break;
 256                     case 13: /* reduce AAfunctionprimary1Primary */
 257                     {
 258                         ArrayList list = new13();
 259                         push(goTo(4), list, false);
 260                     }
 261                     break;
 262                     case 14: /* reduce AAfunctionprimary2Primary */
 263                     {
 264                         ArrayList list = new14();
 265                         push(goTo(4), list, false);
 266                     }
 267                     break;
 268                     case 15: /* reduce ASingleRange */
 269                     {
 270                         ArrayList list = new15();
 271                         push(goTo(5), list, false);
 272                     }
 273                     break;
 274                     case 16: /* reduce AMultiRange */
 275                     {
 276                         ArrayList list = new16();
 277                         push(goTo(5), list, false);
 278                     }
 279                     break;
 280                     case 17: /* reduce ARviValue */
 281                     {
 282                         ArrayList list = new17();
 283                         push(goTo(6), list, false);
 284                     }
 285                     break;
 286                     case 18: /* reduce AStringValue */
 287                     {
 288                         ArrayList list = new18();
 289                         push(goTo(6), list, false);
 290                     }
 291                     break;
 292                     case 19: /* reduce AConstantValue */
 293                     {
 294                         ArrayList list = new19();
 295                         push(goTo(6), list, false);
 296                     }
 297                     break;
 298                     case 20: /* reduce ARangeValue */
 299                     {
 300                         ArrayList list = new20();
 301                         push(goTo(6), list, false);
 302                     }
 303                     break;
 304                     case 21: /* reduce AAddressValue */
 305                     {
 306                         ArrayList list = new21();
 307                         push(goTo(6), list, false);
 308                     }
 309                     break;
 310                     case 22: /* reduce AExprValue */
 311                     {
 312                         ArrayList list = new22();
 313                         push(goTo(6), list, false);
 314                     }
 315                     break;
 316                     }
 317                     break;
 318                 case ACCEPT:
 319                     {
 320                         EOF node2 = (EOF) this.lexer.next();
 321                         PExpression node1 = (PExpression) pop().get(0);
 322                         Start node = new Start(node1, node2);
 323                         return node;
 324                     }
 325                 case ERROR:
 326                     throw new ParserException(this.last_token,
 327                         "[" + this.last_line + "," + this.last_pos + "] " +
 328                         Parser.errorMessages[Parser.errors[this.action[1]]]);
 329             }
 330         }
 331     }
 332
 333
 334
 335     @SuppressWarnings("unchecked")
 336     ArrayList new0() /* reduce AMultExpression */
 337     {
 338         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 339
 340         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 341         PExpression pexpressionNode1;
 342         {
 343             // Block
 344         PMultiplicative pmultiplicativeNode2;
 345         pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0);
 346
 347         pexpressionNode1 = new AMultExpression(pmultiplicativeNode2);
 348         }
 349         nodeList.add(pexpressionNode1);
 350         return nodeList;
 351     }
 352
 353
 354
 355     @SuppressWarnings("unchecked")
 356     ArrayList new1() /* reduce APlusExpression */
 357     {
 358         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 359
 360         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 361         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 362         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 363         PExpression pexpressionNode1;
 364         {
 365             // Block
 366         PExpression pexpressionNode2;
 367         TPlus tplusNode3;
 368         PMultiplicative pmultiplicativeNode4;
 369         pexpressionNode2 = (PExpression)nodeArrayList1.get(0);
 370         tplusNode3 = (TPlus)nodeArrayList2.get(0);
 371         pmultiplicativeNode4 = (PMultiplicative)nodeArrayList3.get(0);
 372
 373         pexpressionNode1 = new APlusExpression(pexpressionNode2, tplusNode3, pmultiplicativeNode4);
 374         }
 375         nodeList.add(pexpressionNode1);
 376         return nodeList;
 377     }
 378
 379
 380
 381     @SuppressWarnings("unchecked")
 382     ArrayList new2() /* reduce AMinusExpression */
 383     {
 384         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 385
 386         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 387         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 388         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 389         PExpression pexpressionNode1;
 390         {
 391             // Block
 392         PExpression pexpressionNode2;
 393         TMinus tminusNode3;
 394         PMultiplicative pmultiplicativeNode4;
 395         pexpressionNode2 = (PExpression)nodeArrayList1.get(0);
 396         tminusNode3 = (TMinus)nodeArrayList2.get(0);
 397         pmultiplicativeNode4 = (PMultiplicative)nodeArrayList3.get(0);
 398
 399         pexpressionNode1 = new AMinusExpression(pexpressionNode2, tminusNode3, pmultiplicativeNode4);
 400         }
 401         nodeList.add(pexpressionNode1);
 402         return nodeList;
 403     }
 404
 405
 406
 407     @SuppressWarnings("unchecked")
 408     ArrayList new3() /* reduce AUnaryMultiplicative */
 409     {
 410         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 411
 412         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 413         PMultiplicative pmultiplicativeNode1;
 414         {
 415             // Block
 416         PUnary punaryNode2;
 417         punaryNode2 = (PUnary)nodeArrayList1.get(0);
 418
 419         pmultiplicativeNode1 = new AUnaryMultiplicative(punaryNode2);
 420         }
 421         nodeList.add(pmultiplicativeNode1);
 422         return nodeList;
 423     }
 424
 425
 426
 427     @SuppressWarnings("unchecked")
 428     ArrayList new4() /* reduce AMultMultiplicative */
 429     {
 430         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 431
 432         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 433         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 434         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 435         PMultiplicative pmultiplicativeNode1;
 436         {
 437             // Block
 438         PMultiplicative pmultiplicativeNode2;
 439         TMult tmultNode3;
 440         PUnary punaryNode4;
 441         pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0);
 442         tmultNode3 = (TMult)nodeArrayList2.get(0);
 443         punaryNode4 = (PUnary)nodeArrayList3.get(0);
 444
 445         pmultiplicativeNode1 = new AMultMultiplicative(pmultiplicativeNode2, tmultNode3, punaryNode4);
 446         }
 447         nodeList.add(pmultiplicativeNode1);
 448         return nodeList;
 449     }
 450
 451
 452
 453     @SuppressWarnings("unchecked")
 454     ArrayList new5() /* reduce ADivMultiplicative */
 455     {
 456         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 457
 458         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 459         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 460         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 461         PMultiplicative pmultiplicativeNode1;
 462         {
 463             // Block
 464         PMultiplicative pmultiplicativeNode2;
 465         TDiv tdivNode3;
 466         PUnary punaryNode4;
 467         pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0);
 468         tdivNode3 = (TDiv)nodeArrayList2.get(0);
 469         punaryNode4 = (PUnary)nodeArrayList3.get(0);
 470
 471         pmultiplicativeNode1 = new ADivMultiplicative(pmultiplicativeNode2, tdivNode3, punaryNode4);
 472         }
 473         nodeList.add(pmultiplicativeNode1);
 474         return nodeList;
 475     }
 476
 477
 478
 479     @SuppressWarnings("unchecked")
 480     ArrayList new6() /* reduce APrimaryUnary */
 481     {
 482         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 483
 484         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 485         PUnary punaryNode1;
 486         {
 487             // Block
 488         PPrimary pprimaryNode2;
 489         pprimaryNode2 = (PPrimary)nodeArrayList1.get(0);
 490
 491         punaryNode1 = new APrimaryUnary(pprimaryNode2);
 492         }
 493         nodeList.add(punaryNode1);
 494         return nodeList;
 495     }
 496
 497
 498
 499     @SuppressWarnings("unchecked")
 500     ArrayList new7() /* reduce AUnaryplusUnary */
 501     {
 502         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 503
 504         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 505         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 506         PUnary punaryNode1;
 507         {
 508             // Block
 509         TPlus tplusNode2;
 510         PUnary punaryNode3;
 511         tplusNode2 = (TPlus)nodeArrayList1.get(0);
 512         punaryNode3 = (PUnary)nodeArrayList2.get(0);
 513
 514         punaryNode1 = new AUnaryplusUnary(tplusNode2, punaryNode3);
 515         }
 516         nodeList.add(punaryNode1);
 517         return nodeList;
 518     }
 519
 520
 521
 522     @SuppressWarnings("unchecked")
 523     ArrayList new8() /* reduce AUnaryminusUnary */
 524     {
 525         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 526
 527         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 528         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 529         PUnary punaryNode1;
 530         {
 531             // Block
 532         TMinus tminusNode2;
 533         PUnary punaryNode3;
 534         tminusNode2 = (TMinus)nodeArrayList1.get(0);
 535         punaryNode3 = (PUnary)nodeArrayList2.get(0);
 536
 537         punaryNode1 = new AUnaryminusUnary(tminusNode2, punaryNode3);
 538         }
 539         nodeList.add(punaryNode1);
 540         return nodeList;
 541     }
 542
 543
 544
 545     @SuppressWarnings("unchecked")
 546     ArrayList new9() /* reduce ASingleArgList */
 547     {
 548         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 549
 550         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 551         PArgList parglistNode1;
 552         {
 553             // Block
 554         PExpression pexpressionNode2;
 555         pexpressionNode2 = (PExpression)nodeArrayList1.get(0);
 556
 557         parglistNode1 = new ASingleArgList(pexpressionNode2);
 558         }
 559         nodeList.add(parglistNode1);
 560         return nodeList;
 561     }
 562
 563
 564
 565     @SuppressWarnings("unchecked")
 566     ArrayList new10() /* reduce ASequenceArgList */
 567     {
 568         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 569
 570         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 571         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 572         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 573         PArgList parglistNode1;
 574         {
 575             // Block
 576         PArgList parglistNode2;
 577         TComma tcommaNode3;
 578         PExpression pexpressionNode4;
 579         parglistNode2 = (PArgList)nodeArrayList1.get(0);
 580         tcommaNode3 = (TComma)nodeArrayList2.get(0);
 581         pexpressionNode4 = (PExpression)nodeArrayList3.get(0);
 582
 583         parglistNode1 = new ASequenceArgList(parglistNode2, tcommaNode3, pexpressionNode4);
 584         }
 585         nodeList.add(parglistNode1);
 586         return nodeList;
 587     }
 588
 589
 590
 591     @SuppressWarnings("unchecked")
 592     ArrayList new11() /* reduce AValuePrimary */
 593     {
 594         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 595
 596         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 597         PPrimary pprimaryNode1;
 598         {
 599             // Block
 600         PValue pvalueNode2;
 601         pvalueNode2 = (PValue)nodeArrayList1.get(0);
 602
 603         pprimaryNode1 = new AValuePrimary(pvalueNode2);
 604         }
 605         nodeList.add(pprimaryNode1);
 606         return nodeList;
 607     }
 608
 609
 610
 611     @SuppressWarnings("unchecked")
 612     ArrayList new12() /* reduce AVariablePrimary */
 613     {
 614         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 615
 616         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 617         PPrimary pprimaryNode1;
 618         {
 619             // Block
 620         TVariable tvariableNode2;
 621         tvariableNode2 = (TVariable)nodeArrayList1.get(0);
 622
 623         pprimaryNode1 = new AVariablePrimary(tvariableNode2);
 624         }
 625         nodeList.add(pprimaryNode1);
 626         return nodeList;
 627     }
 628
 629
 630
 631     @SuppressWarnings("unchecked")
 632     ArrayList new13() /* reduce AAfunctionprimary1Primary */
 633     {
 634         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 635
 636         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 637         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 638         PPrimary pprimaryNode1;
 639         {
 640             // Block
 641         TFunc tfuncNode2;
 642         @SuppressWarnings("unused") Object nullNode3 = null;
 643         TRPar trparNode4;
 644         tfuncNode2 = (TFunc)nodeArrayList1.get(0);
 645         trparNode4 = (TRPar)nodeArrayList2.get(0);
 646
 647         pprimaryNode1 = new AFunctionPrimary(tfuncNode2, null, trparNode4);
 648         }
 649         nodeList.add(pprimaryNode1);
 650         return nodeList;
 651     }
 652
 653
 654
 655     @SuppressWarnings("unchecked")
 656     ArrayList new14() /* reduce AAfunctionprimary2Primary */
 657     {
 658         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 659
 660         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 661         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 662         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 663         PPrimary pprimaryNode1;
 664         {
 665             // Block
 666         TFunc tfuncNode2;
 667         PArgList parglistNode3;
 668         TRPar trparNode4;
 669         tfuncNode2 = (TFunc)nodeArrayList1.get(0);
 670         parglistNode3 = (PArgList)nodeArrayList2.get(0);
 671         trparNode4 = (TRPar)nodeArrayList3.get(0);
 672
 673         pprimaryNode1 = new AFunctionPrimary(tfuncNode2, parglistNode3, trparNode4);
 674         }
 675         nodeList.add(pprimaryNode1);
 676         return nodeList;
 677     }
 678
 679
 680
 681     @SuppressWarnings("unchecked")
 682     ArrayList new15() /* reduce ASingleRange */
 683     {
 684         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 685
 686         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 687         PRange prangeNode1;
 688         {
 689             // Block
 690         TCell tcellNode2;
 691         tcellNode2 = (TCell)nodeArrayList1.get(0);
 692
 693         prangeNode1 = new ASingleRange(tcellNode2);
 694         }
 695         nodeList.add(prangeNode1);
 696         return nodeList;
 697     }
 698
 699
 700
 701     @SuppressWarnings("unchecked")
 702     ArrayList new16() /* reduce AMultiRange */
 703     {
 704         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 705
 706         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 707         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 708         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 709         PRange prangeNode1;
 710         {
 711             // Block
 712         TCell tcellNode2;
 713         TColon tcolonNode3;
 714         TCell tcellNode4;
 715         tcellNode2 = (TCell)nodeArrayList1.get(0);
 716         tcolonNode3 = (TColon)nodeArrayList2.get(0);
 717         tcellNode4 = (TCell)nodeArrayList3.get(0);
 718
 719         prangeNode1 = new AMultiRange(tcellNode2, tcolonNode3, tcellNode4);
 720         }
 721         nodeList.add(prangeNode1);
 722         return nodeList;
 723     }
 724
 725
 726
 727     @SuppressWarnings("unchecked")
 728     ArrayList new17() /* reduce ARviValue */
 729     {
 730         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 731
 732         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 733         PValue pvalueNode1;
 734         {
 735             // Block
 736         TRvi trviNode2;
 737         trviNode2 = (TRvi)nodeArrayList1.get(0);
 738
 739         pvalueNode1 = new ARviValue(trviNode2);
 740         }
 741         nodeList.add(pvalueNode1);
 742         return nodeList;
 743     }
 744
 745
 746
 747     @SuppressWarnings("unchecked")
 748     ArrayList new18() /* reduce AStringValue */
 749     {
 750         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 751
 752         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 753         PValue pvalueNode1;
 754         {
 755             // Block
 756         TString tstringNode2;
 757         tstringNode2 = (TString)nodeArrayList1.get(0);
 758
 759         pvalueNode1 = new AStringValue(tstringNode2);
 760         }
 761         nodeList.add(pvalueNode1);
 762         return nodeList;
 763     }
 764
 765
 766
 767     @SuppressWarnings("unchecked")
 768     ArrayList new19() /* reduce AConstantValue */
 769     {
 770         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 771
 772         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 773         PValue pvalueNode1;
 774         {
 775             // Block
 776         TNumber tnumberNode2;
 777         tnumberNode2 = (TNumber)nodeArrayList1.get(0);
 778
 779         pvalueNode1 = new AConstantValue(tnumberNode2);
 780         }
 781         nodeList.add(pvalueNode1);
 782         return nodeList;
 783     }
 784
 785
 786
 787     @SuppressWarnings("unchecked")
 788     ArrayList new20() /* reduce ARangeValue */
 789     {
 790         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 791
 792         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 793         PValue pvalueNode1;
 794         {
 795             // Block
 796         PRange prangeNode2;
 797         prangeNode2 = (PRange)nodeArrayList1.get(0);
 798
 799         pvalueNode1 = new ARangeValue(prangeNode2);
 800         }
 801         nodeList.add(pvalueNode1);
 802         return nodeList;
 803     }
 804
 805
 806
 807     @SuppressWarnings("unchecked")
 808     ArrayList new21() /* reduce AAddressValue */
 809     {
 810         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 811
 812         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 813         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 814         PValue pvalueNode1;
 815         {
 816             // Block
 817         TAmpersand tampersandNode2;
 818         PRange prangeNode3;
 819         tampersandNode2 = (TAmpersand)nodeArrayList1.get(0);
 820         prangeNode3 = (PRange)nodeArrayList2.get(0);
 821
 822         pvalueNode1 = new AAddressValue(tampersandNode2, prangeNode3);
 823         }
 824         nodeList.add(pvalueNode1);
 825         return nodeList;
 826     }
 827
 828
 829
 830     @SuppressWarnings("unchecked")
 831     ArrayList new22() /* reduce AExprValue */
 832     {
 833         @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList();
 834
 835         @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop();
 836         @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop();
 837         @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop();
 838         PValue pvalueNode1;
 839         {
 840             // Block
 841         TLPar tlparNode2;
 842         PExpression pexpressionNode3;
 843         TRPar trparNode4;
 844         tlparNode2 = (TLPar)nodeArrayList1.get(0);
 845         pexpressionNode3 = (PExpression)nodeArrayList2.get(0);
 846         trparNode4 = (TRPar)nodeArrayList3.get(0);
 847
 848         pvalueNode1 = new AExprValue(tlparNode2, pexpressionNode3, trparNode4);
 849         }
 850         nodeList.add(pvalueNode1);
 851         return nodeList;
 852     }
 853
 854
 855
 856     private static int[][][] actionTable;
 857 /*      {
 858                         {{-1, ERROR, 0}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 859                         {{-1, ERROR, 1}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 860                         {{-1, ERROR, 2}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 861                         {{-1, ERROR, 3}, {14, SHIFT, 7}, },
 862                         {{-1, ERROR, 4}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 863                         {{-1, REDUCE, 12}, },
 864                         {{-1, ERROR, 6}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {11, SHIFT, 21}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 865                         {{-1, REDUCE, 15}, {9, SHIFT, 24}, },
 866                         {{-1, REDUCE, 17}, },
 867                         {{-1, REDUCE, 19}, },
 868                         {{-1, REDUCE, 18}, },
 869                         {{-1, ERROR, 11}, {3, SHIFT, 25}, {4, SHIFT, 26}, {19, ACCEPT, -1}, },
 870                         {{-1, REDUCE, 0}, {5, SHIFT, 27}, {6, SHIFT, 28}, },
 871                         {{-1, REDUCE, 3}, },
 872                         {{-1, REDUCE, 6}, },
 873                         {{-1, REDUCE, 20}, },
 874                         {{-1, REDUCE, 11}, },
 875                         {{-1, REDUCE, 7}, },
 876                         {{-1, REDUCE, 8}, },
 877                         {{-1, REDUCE, 21}, },
 878                         {{-1, ERROR, 20}, {3, SHIFT, 25}, {4, SHIFT, 26}, {11, SHIFT, 29}, },
 879                         {{-1, REDUCE, 13}, },
 880                         {{-1, REDUCE, 9}, {3, SHIFT, 25}, {4, SHIFT, 26}, },
 881                         {{-1, ERROR, 23}, {8, SHIFT, 30}, {11, SHIFT, 31}, },
 882                         {{-1, ERROR, 24}, {14, SHIFT, 32}, },
 883                         {{-1, ERROR, 25}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 884                         {{-1, ERROR, 26}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 885                         {{-1, ERROR, 27}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 886                         {{-1, ERROR, 28}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 887                         {{-1, REDUCE, 22}, },
 888                         {{-1, ERROR, 30}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, },
 889                         {{-1, REDUCE, 14}, },
 890                         {{-1, REDUCE, 16}, },
 891                         {{-1, REDUCE, 1}, {5, SHIFT, 27}, {6, SHIFT, 28}, },
 892                         {{-1, REDUCE, 2}, {5, SHIFT, 27}, {6, SHIFT, 28}, },
 893                         {{-1, REDUCE, 4}, },
 894                         {{-1, REDUCE, 5}, },
 895                         {{-1, REDUCE, 10}, {3, SHIFT, 25}, {4, SHIFT, 26}, },
 896         };*/
 897     private static int[][][] gotoTable;
 898 /*      {
 899                         {{-1, 11}, {4, 20}, {6, 22}, {30, 37}, },
 900                         {{-1, 12}, {25, 33}, {26, 34}, },
 901                         {{-1, 13}, {1, 17}, {2, 18}, {27, 35}, {28, 36}, },
 902                         {{-1, 23}, },
 903                         {{-1, 14}, },
 904                         {{-1, 15}, {3, 19}, },
 905                         {{-1, 16}, },
 906         };*/
 907     private static String[] errorMessages;
 908 /*      {
 909                         "expecting: '+', '-', '&', '(', variable, func, cell, rvi, number, string",
 910                         "expecting: cell",
 911                         "expecting: '+', '-', '*', '/', ',', ')', EOF",
 912                         "expecting: '+', '-', '&', '(', ')', variable, func, cell, rvi, number, string",
 913                         "expecting: '+', '-', '*', '/', ',', ':', ')', EOF",
 914                         "expecting: '+', '-', EOF",
 915                         "expecting: '+', '-', ')'",
 916                         "expecting: '+', '-', ',', ')'",
 917                         "expecting: ',', ')'",
 918         };*/
 919     private static int[] errors;
 920 /*      {
 921                         0, 0, 0, 1, 0, 2, 3, 4, 2, 2, 2, 5, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, 7, 8, 1, 0, 0, 0, 0, 2, 0, 2, 2, 2, 2, 2, 2, 7,
 922         };*/
 923
 924     static
 925     {
 926         try
 927         {
 928             DataInputStream s = new DataInputStream(
 929                 new BufferedInputStream(
 930                 Parser.class.getResourceAsStream("parser.dat")));
 931
 932             // read actionTable
 933             int length = s.readInt();
 934             Parser.actionTable = new int[length][][];
 935             for(int i = 0; i < Parser.actionTable.length; i++)
 936             {
 937                 length = s.readInt();
 938                 Parser.actionTable[i] = new int[length][3];
 939                 for(int j = 0; j < Parser.actionTable[i].length; j++)
 940                 {
 941                 for(int k = 0; k < 3; k++)
 942                 {
 943                     Parser.actionTable[i][j][k] = s.readInt();
 944                 }
 945                 }
 946             }
 947
 948             // read gotoTable
 949             length = s.readInt();
 950             gotoTable = new int[length][][];
 951             for(int i = 0; i < gotoTable.length; i++)
 952             {
 953                 length = s.readInt();
 954                 gotoTable[i] = new int[length][2];
 955                 for(int j = 0; j < gotoTable[i].length; j++)
 956                 {
 957                 for(int k = 0; k < 2; k++)
 958                 {
 959                     gotoTable[i][j][k] = s.readInt();
 960                 }
 961                 }
 962             }
 963
 964             // read errorMessages
 965             length = s.readInt();
 966             errorMessages = new String[length];
 967             for(int i = 0; i < errorMessages.length; i++)
 968             {
 969                 length = s.readInt();
 970                 StringBuffer buffer = new StringBuffer();
 971
 972                 for(int j = 0; j < length; j++)
 973                 {
 974                 buffer.append(s.readChar());
 975                 }
 976                 errorMessages[i] = buffer.toString();
 977             }
 978
 979             // read errors
 980             length = s.readInt();
 981             errors = new int[length];
 982             for(int i = 0; i < errors.length; i++)
 983             {
 984                 errors[i] = s.readInt();
 985             }
 986
 987             s.close();
 988         }
 989         catch(Exception e)
 990         {
 991             throw new RuntimeException("The file \"parser.dat\" is either missing or corrupted.");
 992         }
 993     }
 994 }