home *** CD-ROM | disk | FTP | other *** search
/ Tutto per Internet / Internet.iso / soft95 / Java / espints / espinst.exe / classes / espresso / Parser.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-02-28  |  18.8 KB  |  1,397 lines
  1. package espresso;
  2.  
  3. class Parser implements Constants {
  4.    private static int[] prec = new int[112];
  5.    private static Name initS = Name.fromString("<init>");
  6.    private static Name starS = Name.fromString("*");
  7.    private static Name nullS = Name.fromString("null");
  8.    private static Name voidS = Name.fromString("void");
  9.    private static Name shortS = Name.fromString("short");
  10.    private static Name longS = Name.fromString("long");
  11.    private static Name intS = Name.fromString("int");
  12.    private static Name floatS = Name.fromString("float");
  13.    private static Name doubleS = Name.fromString("double");
  14.    private static Name charS = Name.fromString("char");
  15.    private static Name booleanS = Name.fromString("boolean");
  16.    private static Name byteS = Name.fromString("byte");
  17.    // $FF: renamed from: S espresso.Scanner
  18.    private Scanner field_0;
  19.    private static final int infixPrecedenceLevels = 10;
  20.    private static final int EXPR = 2;
  21.    private static final int TYPE = 1;
  22.  
  23.    static {
  24.       for(int var0 = 0; var0 <= 111; ++var0) {
  25.          prec[var0] = -1;
  26.       }
  27.  
  28.       prec[55] = 0;
  29.       prec[56] = 1;
  30.       prec[27] = 2;
  31.       prec[24] = 3;
  32.       prec[25] = 4;
  33.       prec[37] = 5;
  34.       prec[40] = 5;
  35.       prec[31] = 6;
  36.       prec[30] = 6;
  37.       prec[38] = 6;
  38.       prec[39] = 6;
  39.       prec[41] = 7;
  40.       prec[42] = 7;
  41.       prec[43] = 7;
  42.       prec[20] = 8;
  43.       prec[21] = 8;
  44.       prec[26] = 9;
  45.       prec[29] = 9;
  46.       prec[23] = 9;
  47.    }
  48.  
  49.    private AST makePostop(int var1, int var2, AST var3) {
  50.       byte var4;
  51.       switch (var2) {
  52.          case 35:
  53.             var4 = 77;
  54.             break;
  55.          case 36:
  56.             var4 = 78;
  57.             break;
  58.          default:
  59.             throw new CompilerError("makePostop");
  60.       }
  61.  
  62.       return new Unop(var1, var4, var3);
  63.    }
  64.  
  65.    private AST makePreop(int var1, int var2, AST var3) {
  66.       byte var4;
  67.       switch (var2) {
  68.          case 20:
  69.             var4 = 71;
  70.             break;
  71.          case 21:
  72.             switch (var3.tag) {
  73.                case 90:
  74.                   ((Literal)var3).val = new Integer(-(Integer)((Literal)var3).val);
  75.                   return var3;
  76.                case 91:
  77.                   ((Literal)var3).val = new Long(-(Long)((Literal)var3).val);
  78.                   return var3;
  79.                case 92:
  80.                   ((Literal)var3).val = new Float(-(Float)((Literal)var3).val);
  81.                   return var3;
  82.                case 93:
  83.                   ((Literal)var3).val = new Double(-(Double)((Literal)var3).val);
  84.                   return var3;
  85.                default:
  86.                   var4 = 72;
  87.                   return new Unop(var1, var4, var3);
  88.             }
  89.          case 22:
  90.             var4 = 73;
  91.             break;
  92.          case 23:
  93.          case 24:
  94.          case 25:
  95.          case 26:
  96.          case 27:
  97.          case 29:
  98.          case 30:
  99.          case 31:
  100.          case 32:
  101.          case 33:
  102.          case 34:
  103.          default:
  104.             throw new CompilerError("makePreop");
  105.          case 28:
  106.             var4 = 74;
  107.             break;
  108.          case 35:
  109.             var4 = 75;
  110.             break;
  111.          case 36:
  112.             var4 = 76;
  113.       }
  114.  
  115.       return new Unop(var1, var4, var3);
  116.    }
  117.  
  118.    private AST makeAssignment(int var1, int var2, AST var3, AST var4) {
  119.       byte var5;
  120.       switch (var2) {
  121.          case 34:
  122.             var5 = 49;
  123.             break;
  124.          case 35:
  125.          case 36:
  126.          case 37:
  127.          case 38:
  128.          case 39:
  129.          case 40:
  130.          case 41:
  131.          case 42:
  132.          case 43:
  133.          default:
  134.             throw new CompilerError("makeAssignment");
  135.          case 44:
  136.             var5 = 56;
  137.             break;
  138.          case 45:
  139.             var5 = 57;
  140.             break;
  141.          case 46:
  142.             var5 = 58;
  143.             break;
  144.          case 47:
  145.             var5 = 59;
  146.             break;
  147.          case 48:
  148.             var5 = 52;
  149.             break;
  150.          case 49:
  151.             var5 = 50;
  152.             break;
  153.          case 50:
  154.             var5 = 51;
  155.             break;
  156.          case 51:
  157.             var5 = 60;
  158.             break;
  159.          case 52:
  160.             var5 = 53;
  161.             break;
  162.          case 53:
  163.             var5 = 54;
  164.             break;
  165.          case 54:
  166.             var5 = 55;
  167.       }
  168.  
  169.       return new Assignop(var1, var5, var3, var4);
  170.    }
  171.  
  172.    private AST makeBinop(int var1, int var2, AST var3, AST var4) {
  173.       byte var5;
  174.       switch (var2) {
  175.          case 20:
  176.             var5 = 44;
  177.             break;
  178.          case 21:
  179.             var5 = 45;
  180.             break;
  181.          case 22:
  182.          case 28:
  183.          case 32:
  184.          case 33:
  185.          case 34:
  186.          case 35:
  187.          case 36:
  188.          case 44:
  189.          case 45:
  190.          case 46:
  191.          case 47:
  192.          case 48:
  193.          case 49:
  194.          case 50:
  195.          case 51:
  196.          case 52:
  197.          case 53:
  198.          case 54:
  199.          default:
  200.             throw new CompilerError("makeBinop");
  201.          case 23:
  202.             var5 = 48;
  203.             break;
  204.          case 24:
  205.             var5 = 39;
  206.             break;
  207.          case 25:
  208.             var5 = 40;
  209.             break;
  210.          case 26:
  211.             var5 = 46;
  212.             break;
  213.          case 27:
  214.             var5 = 38;
  215.             break;
  216.          case 29:
  217.             var5 = 47;
  218.             break;
  219.          case 30:
  220.             var5 = 35;
  221.             break;
  222.          case 31:
  223.             var5 = 34;
  224.             break;
  225.          case 37:
  226.             var5 = 32;
  227.             break;
  228.          case 38:
  229.             var5 = 36;
  230.             break;
  231.          case 39:
  232.             var5 = 37;
  233.             break;
  234.          case 40:
  235.             var5 = 33;
  236.             break;
  237.          case 41:
  238.             var5 = 41;
  239.             break;
  240.          case 42:
  241.             var5 = 42;
  242.             break;
  243.          case 43:
  244.             var5 = 43;
  245.             break;
  246.          case 55:
  247.             var5 = 30;
  248.             break;
  249.          case 56:
  250.             var5 = 31;
  251.       }
  252.  
  253.       return new Binop(var1, var5, var3, var4);
  254.    }
  255.  
  256.    private int narrow(int var1, AST var2) {
  257.       return var1 & ((var2.isType() ? 1 : 0) | (var2.isExpr() ? 2 : 0));
  258.    }
  259.  
  260.    private boolean checkExprStat(AST var1) {
  261.       if (this.checkExpr(var1)) {
  262.          if (49 <= var1.tag && var1.tag <= 60 || 75 <= var1.tag && var1.tag <= 78 || var1.tag == 5 || var1.tag == 7 || var1.tag == 0) {
  263.             return true;
  264.          }
  265.  
  266.          Report.error(var1.pos, "not a statement");
  267.       }
  268.  
  269.       return false;
  270.    }
  271.  
  272.    private boolean checkExpr(AST var1) {
  273.       if (!var1.isExpr() && var1.tag != 0) {
  274.          if (var1.isType()) {
  275.             Report.error(var1.pos, "malformed declaration");
  276.          } else {
  277.             Report.error(var1.pos, "malformed expression");
  278.          }
  279.  
  280.          return false;
  281.       } else {
  282.          return true;
  283.       }
  284.    }
  285.  
  286.    ASTS compilationUnit() {
  287.       int var1 = this.field_0.pos;
  288.       ASTS var2 = new ASTS();
  289.       if (this.field_0.sym == 80) {
  290.          this.field_0.nextsym();
  291.          IdRef var3 = this.qualident();
  292.          this.accept(12);
  293.          var2.append(new Package(var1, var3));
  294.       }
  295.  
  296.       while(this.field_0.sym == 76) {
  297.          var2.append(this.importClause());
  298.       }
  299.  
  300.       while(this.field_0.sym != 111) {
  301.          var2 = this.addTopDef(var2);
  302.       }
  303.  
  304.       return var2;
  305.    }
  306.  
  307.    private AST importClause() {
  308.       int var1 = this.field_0.pos;
  309.       this.field_0.nextsym();
  310.       int var2 = this.field_0.pos;
  311.  
  312.       Object var3;
  313.       for(var3 = new Ident(var2, this.ident()); this.field_0.sym == 10; var3 = new Select(var2, (AST)var3, this.ident())) {
  314.          this.field_0.nextsym();
  315.          if (this.field_0.sym == 26) {
  316.             this.field_0.nextsym();
  317.             var3 = new Select(var2, (AST)var3, starS);
  318.             break;
  319.          }
  320.       }
  321.  
  322.       this.accept(12);
  323.       return new Import(var1, (IdRef)var3);
  324.    }
  325.  
  326.    private ASTS addTopDef(ASTS var1) {
  327.       if (this.field_0.pos == this.field_0.errPos) {
  328.          while(this.field_0.sym != 64 && this.field_0.sym != 77 && this.field_0.sym != 111) {
  329.             this.field_0.nextsym();
  330.          }
  331.       }
  332.  
  333.       if (this.field_0.sym == 12) {
  334.          this.field_0.nextsym();
  335.       } else {
  336.          int var2 = this.modifiers(0);
  337.          if (this.field_0.sym == 64) {
  338.             var1.append(this.classDef(var2));
  339.          } else if (this.field_0.sym == 77) {
  340.             var1.append(this.interfaceDef(var2));
  341.          } else {
  342.             this.syntaxError("'class' or 'interface' expected");
  343.  
  344.             while(this.field_0.sym == 18) {
  345.                this.field_0.nextsym();
  346.             }
  347.          }
  348.       }
  349.  
  350.       return var1;
  351.    }
  352.  
  353.    private AST interfaceDef(int var1) {
  354.       int var2 = this.field_0.pos;
  355.       this.field_0.nextsym();
  356.       Name var3 = this.ident();
  357.       ASTS var4 = new ASTS();
  358.       if (this.field_0.sym == 70) {
  359.          this.field_0.nextsym();
  360.          var4.append(this.qualident());
  361.  
  362.          while(this.field_0.sym == 11) {
  363.             this.field_0.nextsym();
  364.             var4.append(this.qualident());
  365.          }
  366.       }
  367.  
  368.       Block var5 = this.classBlock(var3, true);
  369.       return new ClassDef(var2, var3, var1 | 512, (AST)null, var4, var5);
  370.    }
  371.  
  372.    private AST classDef(int var1) {
  373.       int var2 = this.field_0.pos;
  374.       this.field_0.nextsym();
  375.       Name var3 = this.ident();
  376.       IdRef var4 = null;
  377.       if (this.field_0.sym == 70) {
  378.          this.field_0.nextsym();
  379.          var4 = this.qualident();
  380.       }
  381.  
  382.       ASTS var5 = new ASTS();
  383.       if (this.field_0.sym == 75) {
  384.          this.field_0.nextsym();
  385.          var5.append(this.qualident());
  386.  
  387.          while(this.field_0.sym == 11) {
  388.             this.field_0.nextsym();
  389.             var5.append(this.qualident());
  390.          }
  391.       }
  392.  
  393.       Block var6 = this.classBlock(var3, false);
  394.       return new ClassDef(var2, var3, var1, var4, var5, var6);
  395.    }
  396.  
  397.    private Block classBlock(Name var1, boolean var2) {
  398.       int var3 = this.field_0.pos;
  399.       this.accept(17);
  400.  
  401.       ASTS var4;
  402.       for(var4 = new ASTS(); this.field_0.sym != 18 && this.field_0.sym != 111 && this.field_0.sym != 64 && this.field_0.sym != 77; var4 = this.addDef(var4, var1, var2)) {
  403.       }
  404.  
  405.       this.accept(18);
  406.       return new Block(var3, var4);
  407.    }
  408.  
  409.    private ASTS addDef(ASTS var1, Name var2, boolean var3) {
  410.       if (this.field_0.sym == 12) {
  411.          this.field_0.nextsym();
  412.       } else {
  413.          int var4 = 0;
  414.          if (this.field_0.sym == 85) {
  415.             this.field_0.nextsym();
  416.             if (this.field_0.sym == 17) {
  417.                Block var5 = this.block();
  418.                var5.mods = 8;
  419.                var1.append(var5);
  420.                return var1;
  421.             }
  422.  
  423.             var4 |= 8;
  424.          }
  425.  
  426.          var4 = this.modifiers(var4);
  427.          int var6 = this.field_0.pos;
  428.          AST var7 = this.type();
  429.          if (this.field_0.sym == 13 && var7.tag == 1 && ((Ident)var7).name.equals(var2)) {
  430.             var1.append(this.funDefiner(var6, initS, var4, (AST)null));
  431.          } else {
  432.             var6 = this.field_0.pos;
  433.             Name var8 = this.ident();
  434.             if (this.field_0.sym == 13) {
  435.                var1.append(this.funDefiner(var6, var8, var4, var7));
  436.             } else {
  437.                var1 = this.addVarDefiners(var1, var6, var8, var4, var7, var3);
  438.                this.accept(12);
  439.             }
  440.          }
  441.       }
  442.  
  443.       return var1;
  444.    }
  445.  
  446.    private FunDef funDefiner(int var1, Name var2, int var3, AST var4) {
  447.       ASTS var5 = this.formals();
  448.       var4 = this.brackets(var4);
  449.       ASTS var6 = this.throwsDcl();
  450.       Block var7 = null;
  451.       if (this.field_0.sym == 12) {
  452.          this.field_0.nextsym();
  453.       } else {
  454.          var7 = this.block();
  455.       }
  456.  
  457.       return new FunDef(var1, 65, var2, var3, var4, var5, var6, var7);
  458.    }
  459.  
  460.    private FunDef lambda() {
  461.       int var1 = this.field_0.pos;
  462.       this.field_0.nextsym();
  463.       ASTS var2 = this.formals();
  464.       ASTS var3 = this.throwsDcl();
  465.       Block var4 = this.block();
  466.       return new FunDef(var1, 67, (Name)null, 0, (AST)null, var2, var3, var4);
  467.    }
  468.  
  469.    private ASTS throwsDcl() {
  470.       ASTS var1 = new ASTS();
  471.       if (this.field_0.sym == 92) {
  472.          this.field_0.nextsym();
  473.          var1.append(this.type());
  474.  
  475.          while(this.field_0.sym == 11) {
  476.             this.field_0.nextsym();
  477.             var1.append(this.type());
  478.          }
  479.       }
  480.  
  481.       return var1;
  482.    }
  483.  
  484.    private ASTS typargs() {
  485.       ASTS var1 = new ASTS();
  486.       this.accept(13);
  487.       if (this.field_0.sym != 14) {
  488.          var1.append(this.type());
  489.  
  490.          while(this.field_0.sym == 11) {
  491.             this.field_0.nextsym();
  492.             var1.append(this.type());
  493.          }
  494.       }
  495.  
  496.       this.accept(14);
  497.       return var1;
  498.    }
  499.  
  500.    private ASTS formals() {
  501.       ASTS var1 = new ASTS();
  502.       this.accept(13);
  503.       if (this.field_0.sym != 14) {
  504.          var1.append(this.varDcl(0, this.type()));
  505.  
  506.          while(this.field_0.sym == 11) {
  507.             this.field_0.nextsym();
  508.             var1.append(this.varDcl(0, this.type()));
  509.          }
  510.       }
  511.  
  512.       this.accept(14);
  513.       return var1;
  514.    }
  515.  
  516.    private ASTS varDefs(int var1, AST var2) {
  517.       return this.addVarDefiners(new ASTS(), this.field_0.pos, this.ident(), var1, var2, false);
  518.    }
  519.  
  520.    private ASTS addVarDefiners(ASTS var1, int var2, Name var3, int var4, AST var5, boolean var6) {
  521.       var1.append(this.varDefiner(var2, var3, var4, var5, var6));
  522.  
  523.       while(this.field_0.sym == 11) {
  524.          this.field_0.nextsym();
  525.          int var7 = this.field_0.pos;
  526.          Name var8 = this.ident();
  527.          var1.append(this.varDefiner(var7, var8, var4, var5, var6));
  528.       }
  529.  
  530.       return var1;
  531.    }
  532.  
  533.    private AST varDefiner(int var1, Name var2, int var3, AST var4, boolean var5) {
  534.       var4 = this.brackets(var4);
  535.       AST var6 = null;
  536.       if (this.field_0.sym == 34) {
  537.          this.field_0.nextsym();
  538.          var6 = this.initializer();
  539.       } else if (var5) {
  540.          this.syntaxError("missing initializer");
  541.       }
  542.  
  543.       return new VarDef(var1, var2, var3, var4, var6);
  544.    }
  545.  
  546.    private AST varDcl(int var1, AST var2) {
  547.       int var3 = this.field_0.pos;
  548.       Name var4 = this.ident();
  549.       return new VarDef(var3, var4, var1, this.brackets(var2), (AST)null);
  550.    }
  551.  
  552.    private AST brackets(AST var1) {
  553.       while(this.field_0.sym == 15) {
  554.          int var2 = this.field_0.pos;
  555.          this.field_0.nextsym();
  556.          this.accept(16);
  557.          var1 = new Subscript(var2, (AST)var1, (AST)null);
  558.       }
  559.  
  560.       return (AST)var1;
  561.    }
  562.  
  563.    private Block block() {
  564.       int var1 = this.field_0.pos;
  565.       this.accept(17);
  566.       Block var2 = new Block(var1, this.stats());
  567.       if (this.field_0.sym == 62 || this.field_0.sym == 67) {
  568.          this.syntaxError(String.valueOf("orphaned ").concat(String.valueOf(this.field_0.sym2string(this.field_0.sym))));
  569.       }
  570.  
  571.       this.accept(18);
  572.       return var2;
  573.    }
  574.  
  575.    private ASTS stats() {
  576.       ASTS var1 = new ASTS();
  577.  
  578.       while(true) {
  579.          switch (this.field_0.sym) {
  580.             case 18:
  581.             case 111:
  582.             case 64:
  583.             case 77:
  584.             case 62:
  585.             case 67:
  586.                return var1;
  587.             default:
  588.                var1 = this.addStat(var1);
  589.          }
  590.       }
  591.    }
  592.  
  593.    private AST substat() {
  594.       int var1 = this.field_0.pos;
  595.       ASTS var2 = this.addStat(new ASTS());
  596.       return (AST)(var2.length == 1 && !(var2.elems[0] instanceof Def) ? var2.elems[0] : new Block(var1, var2));
  597.    }
  598.  
  599.    private AST stat() {
  600.       int var1 = this.field_0.pos;
  601.       ASTS var2 = this.addStat(new ASTS());
  602.       return (AST)(var2.length == 1 ? var2.elems[0] : new Block(var1, var2));
  603.    }
  604.  
  605.    private ASTS addStat(ASTS var1) {
  606.       int var2 = this.field_0.pos;
  607.       switch (this.field_0.sym) {
  608.          case 17:
  609.             var1.append(this.block());
  610.             break;
  611.          case 74:
  612.             this.field_0.nextsym();
  613.             AST var3 = this.parExpr();
  614.             AST var4 = this.substat();
  615.             AST var5 = null;
  616.             if (this.field_0.sym == 69) {
  617.                this.field_0.nextsym();
  618.                var5 = this.substat();
  619.             }
  620.  
  621.             var1.append(new Conditional(var2, 28, var3, var4, var5));
  622.             break;
  623.          case 73:
  624.             this.field_0.nextsym();
  625.             this.accept(13);
  626.             ASTS var6 = this.forInit();
  627.             this.accept(12);
  628.             AST var7 = null;
  629.             if (this.field_0.sym != 12) {
  630.                var7 = this.expr();
  631.             }
  632.  
  633.             this.accept(12);
  634.             ASTS var8 = this.forIncr();
  635.             this.accept(14);
  636.             var1.append(new ForLoop(var2, var6, var7, var8, this.substat()));
  637.             break;
  638.          case 95:
  639.             this.field_0.nextsym();
  640.             AST var9 = this.parExpr();
  641.             var1.append(new WhileLoop(var2, var9, this.substat()));
  642.             break;
  643.          case 68:
  644.             this.field_0.nextsym();
  645.             AST var10 = this.substat();
  646.             this.accept(95);
  647.             var1.append(new DoLoop(var2, var10, this.parExpr()));
  648.             this.accept(12);
  649.             break;
  650.          case 94:
  651.             this.field_0.nextsym();
  652.             Block var11 = this.block();
  653.             ASTS var12 = new ASTS();
  654.  
  655.             while(this.field_0.sym == 63) {
  656.                int var13 = this.field_0.pos;
  657.                this.field_0.nextsym();
  658.                this.accept(13);
  659.                ASTS var14 = new ASTS();
  660.                var14.append(this.varDcl(0, this.type()));
  661.                this.accept(14);
  662.                Block var15 = this.block();
  663.                var12.append(new FunDef(var13, 66, (Name)null, 0, (AST)null, var14, new ASTS(), var15));
  664.             }
  665.  
  666.             Block var16 = null;
  667.             if (this.field_0.sym == 72) {
  668.                this.field_0.nextsym();
  669.                var16 = this.block();
  670.             }
  671.  
  672.             var1.append(new Try(var2, var11, var12, var16));
  673.             if (var12.length == 0 && var16 == null) {
  674.                Report.error(var2, "'try' without 'catch' or 'finally'");
  675.             }
  676.             break;
  677.          case 87:
  678.             this.field_0.nextsym();
  679.             AST var17 = this.parExpr();
  680.             this.accept(17);
  681.             var1.append(new Switch(var2, var17, this.cases()));
  682.             this.accept(18);
  683.             break;
  684.          case 88:
  685.             this.field_0.nextsym();
  686.             AST var18 = this.parExpr();
  687.             AST var19 = this.substat();
  688.             var1.append(new Synchronized(var2, var18, var19));
  689.             break;
  690.          case 84:
  691.             this.field_0.nextsym();
  692.             AST var20 = null;
  693.             if (this.field_0.sym != 12) {
  694.                var20 = this.expr();
  695.             }
  696.  
  697.             var1.append(new Return(var2, var20));
  698.             this.accept(12);
  699.             break;
  700.          case 91:
  701.             this.field_0.nextsym();
  702.             AST var21 = this.expr();
  703.             var1.append(new Throw(var2, var21));
  704.             this.accept(12);
  705.             break;
  706.          case 61:
  707.             this.field_0.nextsym();
  708.             if (this.field_0.sym == 1) {
  709.                var1.append(new Break(var2, this.field_0.name));
  710.                this.field_0.nextsym();
  711.             } else {
  712.                var1.append(new Break(var2, (Name)null));
  713.             }
  714.  
  715.             this.accept(12);
  716.             break;
  717.          case 66:
  718.             this.field_0.nextsym();
  719.             if (this.field_0.sym == 1) {
  720.                var1.append(new Continue(var2, this.field_0.name));
  721.                this.field_0.nextsym();
  722.             } else {
  723.                var1.append(new Continue(var2, (Name)null));
  724.             }
  725.  
  726.             this.accept(12);
  727.             break;
  728.          case 12:
  729.             this.field_0.nextsym();
  730.             break;
  731.          case 69:
  732.             this.syntaxError("'else' without 'if'");
  733.             break;
  734.          case 72:
  735.             this.syntaxError("'finally' without 'try'");
  736.             break;
  737.          case 63:
  738.             this.syntaxError("'catch' without 'try'");
  739.             break;
  740.          default:
  741.             byte var22 = 0;
  742.             AST var23 = this.term(3);
  743.             if (var23.tag == 1 && this.field_0.sym == 33) {
  744.                this.field_0.nextsym();
  745.                var1.append(new Labelled(var2, ((Ident)var23).name, this.stat()));
  746.             } else if (this.field_0.sym == 1 && var23.isType()) {
  747.                var2 = this.field_0.pos;
  748.                Name var24 = this.ident();
  749.                var1 = this.addVarDefiners(var1, var2, var24, var22, var23, false);
  750.                this.accept(12);
  751.             } else {
  752.                this.checkExprStat(var23);
  753.                var1.append(new Exec(var2, var23));
  754.                this.accept(12);
  755.             }
  756.       }
  757.  
  758.       return var1;
  759.    }
  760.  
  761.    private ASTS forIncr() {
  762.       ASTS var1 = new ASTS();
  763.       if (this.field_0.sym != 14) {
  764.          var1.append(this.expr());
  765.  
  766.          while(this.field_0.sym == 11) {
  767.             this.field_0.nextsym();
  768.             var1.append(this.expr());
  769.          }
  770.       }
  771.  
  772.       return var1;
  773.    }
  774.  
  775.    private ASTS forInit() {
  776.       ASTS var1 = new ASTS();
  777.       if (this.field_0.sym != 12) {
  778.          AST var2 = this.term(3);
  779.          if (this.field_0.sym == 1 && var2.isType()) {
  780.             return this.varDefs(0, var2);
  781.          }
  782.  
  783.          if (this.checkExpr(var2)) {
  784.             var1.append(var2);
  785.          }
  786.  
  787.          while(this.field_0.sym == 11) {
  788.             this.field_0.nextsym();
  789.             var1.append(this.expr());
  790.          }
  791.       }
  792.  
  793.       return var1;
  794.    }
  795.  
  796.    private ASTS cases() {
  797.       ASTS var1 = new ASTS();
  798.  
  799.       while(this.field_0.sym == 62 || this.field_0.sym == 67) {
  800.          int var2 = this.field_0.pos;
  801.          int var3 = this.field_0.sym;
  802.          this.field_0.nextsym();
  803.          AST var4 = null;
  804.          if (var3 == 62) {
  805.             var4 = this.expr();
  806.          }
  807.  
  808.          this.accept(33);
  809.          ASTS var5 = this.stats();
  810.          var1.append(new Case(var2, var4, var5));
  811.       }
  812.  
  813.       return var1;
  814.    }
  815.  
  816.    private AST initializer() {
  817.       return this.field_0.sym == 17 ? this.aggregate() : this.expr();
  818.    }
  819.  
  820.    private AST aggregate() {
  821.       int var1 = this.field_0.pos;
  822.       this.field_0.nextsym();
  823.       ASTS var2 = new ASTS();
  824.       if (this.field_0.sym != 18) {
  825.          var2.append(this.initializer());
  826.  
  827.          while(this.field_0.sym == 11) {
  828.             this.field_0.nextsym();
  829.             if (this.field_0.sym == 18) {
  830.                break;
  831.             }
  832.  
  833.             var2.append(this.initializer());
  834.          }
  835.       }
  836.  
  837.       this.accept(18);
  838.       return new Aggregate(var1, var2);
  839.    }
  840.  
  841.    private AST arrowtype(ASTS var1) {
  842.       int var2 = this.field_0.pos;
  843.       this.accept(109);
  844.       return new FunctionType(var2, this.type(), var1, this.throwsDcl());
  845.    }
  846.  
  847.    private AST parTerm(int var1) {
  848.       int var2 = this.field_0.pos;
  849.       this.accept(13);
  850.       Object var3;
  851.       if (Switches.extended && this.field_0.sym == 109 && (var1 & 1) != 0) {
  852.          var3 = this.arrowtype(new ASTS());
  853.          this.accept(14);
  854.       } else {
  855.          var3 = this.term(var1 | 1);
  856.          if (Switches.extended && (this.field_0.sym == 11 || this.field_0.sym == 109) && (var1 & 1) != 0 && ((AST)var3).isType()) {
  857.             ASTS var4 = new ASTS((AST)var3);
  858.  
  859.             while(this.field_0.sym == 11) {
  860.                this.field_0.nextsym();
  861.                var4.append(this.type());
  862.             }
  863.  
  864.             var3 = this.arrowtype(var4);
  865.             this.accept(14);
  866.          } else {
  867.             this.accept(14);
  868.             if (((AST)var3).isType() && (var1 & 2) != 0) {
  869.                switch (this.field_0.sym) {
  870.                   case 13:
  871.                   case 1:
  872.                   case 2:
  873.                   case 3:
  874.                   case 4:
  875.                   case 5:
  876.                   case 6:
  877.                   case 7:
  878.                   case 79:
  879.                   case 89:
  880.                   case 86:
  881.                   case 106:
  882.                   case 28:
  883.                   case 22:
  884.                   case 107:
  885.                      var3 = new Typeop(var2, 62, this.term4(2), (AST)var3);
  886.                      break;
  887.                   case 20:
  888.                   case 21:
  889.                   case 35:
  890.                   case 36:
  891.                      if (!((AST)var3).isExpr()) {
  892.                         var3 = new Typeop(var2, 62, this.term4(2), (AST)var3);
  893.                      }
  894.                }
  895.             }
  896.          }
  897.       }
  898.  
  899.       return (AST)var3;
  900.    }
  901.  
  902.    private AST constructor() {
  903.       IdRef var1 = this.typeident();
  904.       Object var3;
  905.       if (this.field_0.sym == 15) {
  906.          int var2 = this.field_0.pos;
  907.          this.field_0.nextsym();
  908.          var3 = new Subscript(var2, var1, this.expr());
  909.          this.accept(16);
  910.  
  911.          while(this.field_0.sym == 15) {
  912.             var2 = this.field_0.pos;
  913.             this.field_0.nextsym();
  914.             if (this.field_0.sym == 16) {
  915.                var3 = new Subscript(var2, (AST)var3, (AST)null);
  916.                this.field_0.nextsym();
  917.  
  918.                while(this.field_0.sym == 15) {
  919.                   var3 = new Subscript(var2, (AST)var3, (AST)null);
  920.                   this.field_0.nextsym();
  921.                   this.accept(16);
  922.                }
  923.             } else {
  924.                var3 = new Subscript(var2, (AST)var3, this.expr());
  925.                this.accept(16);
  926.             }
  927.          }
  928.       } else if (this.field_0.sym == 13) {
  929.          var3 = new Apply(this.field_0.pos, var1, this.argList());
  930.       } else {
  931.          var3 = AST.error;
  932.          this.syntaxError("'(' or '[' expected");
  933.       }
  934.  
  935.       return (AST)var3;
  936.    }
  937.  
  938.    private ASTS argList() {
  939.       int var1 = this.field_0.pos;
  940.       this.accept(13);
  941.       ASTS var2 = new ASTS();
  942.       if (this.field_0.sym != 14) {
  943.          var2.append(this.expr());
  944.  
  945.          while(this.field_0.sym == 11) {
  946.             this.field_0.nextsym();
  947.             var2.append(this.expr());
  948.          }
  949.       }
  950.  
  951.       this.accept(14);
  952.       return var2;
  953.    }
  954.  
  955.    private AST parExpr() {
  956.       this.accept(13);
  957.       AST var1 = this.expr();
  958.       this.accept(14);
  959.       return var1;
  960.    }
  961.  
  962.    private AST type() {
  963.       return this.term(1);
  964.    }
  965.  
  966.    private AST expr() {
  967.       return this.term(2);
  968.    }
  969.  
  970.    private AST term4(int var1) {
  971.       if ((var1 & 2) != 0) {
  972.          switch (this.field_0.sym) {
  973.             case 20:
  974.             case 21:
  975.             case 22:
  976.             case 28:
  977.             case 35:
  978.             case 36:
  979.                int var2 = this.field_0.sym;
  980.                int var3 = this.field_0.pos;
  981.                this.field_0.nextsym();
  982.                return this.makePreop(var3, var2, this.term4(2));
  983.             case 23:
  984.             case 24:
  985.             case 25:
  986.             case 26:
  987.             case 27:
  988.             case 29:
  989.             case 30:
  990.             case 31:
  991.             case 32:
  992.             case 33:
  993.             case 34:
  994.          }
  995.       }
  996.  
  997.       int var4 = this.field_0.pos;
  998.       Object var5;
  999.       if (this.field_0.sym == 13 && (var1 & 2) != 0 | Switches.extended) {
  1000.          var5 = this.parTerm(var1);
  1001.       } else if ((var1 & 1) == 0 || this.field_0.sym != 1 && (97 > this.field_0.sym || this.field_0.sym > 105)) {
  1002.          if ((var1 & 2) != 0) {
  1003.             switch (this.field_0.sym) {
  1004.                case 79:
  1005.                   this.field_0.nextsym();
  1006.                   var5 = new New(var4, this.constructor());
  1007.                   break;
  1008.                case 1:
  1009.                   var5 = this.qualident();
  1010.                   break;
  1011.                case 89:
  1012.                   var5 = new Self(this.field_0.pos, 80);
  1013.                   this.field_0.nextsym();
  1014.                   break;
  1015.                case 86:
  1016.                   var5 = new Self(this.field_0.pos, 81);
  1017.                   this.field_0.nextsym();
  1018.                   break;
  1019.                case 3:
  1020.                   var5 = new Literal(this.field_0.pos, 95, this.field_0.name);
  1021.                   this.field_0.nextsym();
  1022.                   break;
  1023.                case 2:
  1024.                   var5 = new Literal(this.field_0.pos, 94, new Integer((int)this.field_0.intVal));
  1025.                   this.field_0.nextsym();
  1026.                   break;
  1027.                case 4:
  1028.                   if ((long)Integer.MIN_VALUE <= this.field_0.intVal && this.field_0.intVal <= (long)Integer.MAX_VALUE) {
  1029.                      var5 = new Literal(this.field_0.pos, 90, new Integer((int)this.field_0.intVal));
  1030.                   } else {
  1031.                      var5 = new Literal(this.field_0.pos, 91, new Long(this.field_0.intVal));
  1032.                   }
  1033.  
  1034.                   this.field_0.nextsym();
  1035.                   break;
  1036.                case 5:
  1037.                   var5 = new Literal(this.field_0.pos, 91, new Long(this.field_0.intVal));
  1038.                   this.field_0.nextsym();
  1039.                   break;
  1040.                case 6:
  1041.                   var5 = new Literal(this.field_0.pos, 92, new Float((float)this.field_0.floatVal));
  1042.                   this.field_0.nextsym();
  1043.                   break;
  1044.                case 7:
  1045.                   var5 = new Literal(this.field_0.pos, 93, new Double(this.field_0.floatVal));
  1046.                   this.field_0.nextsym();
  1047.                   break;
  1048.                case 106:
  1049.                   var5 = new Ident(this.field_0.pos, nullS);
  1050.                   this.field_0.nextsym();
  1051.                   break;
  1052.                case 107:
  1053.                   var5 = this.lambda();
  1054.                   break;
  1055.                case 108:
  1056.                   this.field_0.nextsym();
  1057.                   var5 = new Sequence(var4, this.block());
  1058.                   break;
  1059.                default:
  1060.                   if (Switches.extended && this.field_0.sym == 17) {
  1061.                      var5 = this.aggregate();
  1062.                   } else {
  1063.                      var5 = AST.error;
  1064.                      this.syntaxError("illegal start of expression");
  1065.                   }
  1066.             }
  1067.          } else {
  1068.             var5 = AST.error;
  1069.             this.syntaxError("illegal start of type");
  1070.          }
  1071.       } else {
  1072.          var5 = this.typeident();
  1073.       }
  1074.  
  1075.       while(true) {
  1076.          switch (this.field_0.sym) {
  1077.             case 10:
  1078.                if ((var1 & 2) == 0 || !((AST)var5).isExpr()) {
  1079.                   return (AST)var5;
  1080.                }
  1081.  
  1082.                var4 = this.field_0.pos;
  1083.                this.field_0.nextsym();
  1084.                var5 = new Select(var4, (AST)var5, this.ident());
  1085.                break;
  1086.             case 15:
  1087.                this.field_0.nextsym();
  1088.                if (this.field_0.sym == 16 && (var1 & 1) != 0 && ((AST)var5).isType()) {
  1089.                   this.field_0.nextsym();
  1090.                   var5 = new Subscript(((AST)var5).pos, (AST)var5, (AST)null);
  1091.                   break;
  1092.                }
  1093.  
  1094.                var5 = new Subscript(this.field_0.pos, (AST)var5, this.term(this.narrow(var1, (AST)var5)));
  1095.                this.accept(16);
  1096.                break;
  1097.             case 13:
  1098.                if ((var1 & 2) == 0 || !((AST)var5).isExpr()) {
  1099.                   return (AST)var5;
  1100.                }
  1101.  
  1102.                var5 = new Apply(this.field_0.pos, (AST)var5, this.argList());
  1103.                break;
  1104.             case 35:
  1105.             case 36:
  1106.                if ((var1 & 2) == 0 || !((AST)var5).isExpr()) {
  1107.                   return (AST)var5;
  1108.                }
  1109.  
  1110.                var5 = this.makePostop(this.field_0.pos, this.field_0.sym, (AST)var5);
  1111.                this.field_0.nextsym();
  1112.                break;
  1113.             case 107:
  1114.                if ((var1 & 1) != 0 && ((AST)var5).isType()) {
  1115.                   var4 = this.field_0.pos;
  1116.                   this.field_0.nextsym();
  1117.                   ASTS var6 = this.typargs();
  1118.                   ASTS var7 = this.throwsDcl();
  1119.                   var5 = new FunctionType(var4, (AST)var5, var6, var7);
  1120.                   break;
  1121.                }
  1122.  
  1123.                return (AST)var5;
  1124.             default:
  1125.                return (AST)var5;
  1126.          }
  1127.       }
  1128.    }
  1129.  
  1130.    private AST term3(int var1) {
  1131.       Object var2 = this.term4(var1);
  1132.       if (this.field_0.sym == 96 && (var1 & 2) != 0 && ((AST)var2).isExpr()) {
  1133.          int var3 = this.field_0.pos;
  1134.          this.field_0.nextsym();
  1135.          var2 = new Typeop(var3, 61, (AST)var2, this.type());
  1136.       }
  1137.  
  1138.       return (AST)var2;
  1139.    }
  1140.  
  1141.    private AST term2(int var1) {
  1142.       AST var2 = this.term3(var1);
  1143.       if (prec[this.field_0.sym] >= 0 && (var1 & 2) != 0 && var2.isExpr()) {
  1144.          AST[] var3 = new AST[11];
  1145.          int[] var4 = new int[10];
  1146.          int var5 = 0;
  1147.          var3[var5] = var2;
  1148.  
  1149.          while(prec[this.field_0.sym] >= 0) {
  1150.             var4[var5] = this.field_0.sym;
  1151.             ++var5;
  1152.             int var6 = this.field_0.pos;
  1153.             this.field_0.nextsym();
  1154.  
  1155.             for(var3[var5] = this.term3(2); var5 > 0 && prec[var4[var5 - 1]] >= prec[this.field_0.sym]; --var5) {
  1156.                var3[var5 - 1] = this.makeBinop(var6, var4[var5 - 1], var3[var5 - 1], var3[var5]);
  1157.             }
  1158.          }
  1159.  
  1160.          var2 = var3[var5];
  1161.       }
  1162.  
  1163.       return var2;
  1164.    }
  1165.  
  1166.    private AST term1(int var1) {
  1167.       Object var2 = this.term2(var1);
  1168.       if (this.field_0.sym == 32 && (var1 & 2) != 0 && ((AST)var2).isExpr()) {
  1169.          int var3 = this.field_0.pos;
  1170.          this.field_0.nextsym();
  1171.          AST var4 = this.term1(2);
  1172.          this.accept(33);
  1173.          AST var5 = this.term1(2);
  1174.          var2 = new Conditional(var3, 4, (AST)var2, var4, var5);
  1175.       }
  1176.  
  1177.       return (AST)var2;
  1178.    }
  1179.  
  1180.    private AST term(int var1) {
  1181.       AST var2 = this.term1(var1);
  1182.       if ((this.field_0.sym == 34 || 44 <= this.field_0.sym && this.field_0.sym <= 54) && (var1 & 2) != 0 && var2.isExpr()) {
  1183.          int var3 = this.field_0.pos;
  1184.          int var4 = this.field_0.sym;
  1185.          this.field_0.nextsym();
  1186.          var2 = this.makeAssignment(var3, var4, var2, this.term(2));
  1187.       }
  1188.  
  1189.       return var2;
  1190.    }
  1191.  
  1192.    private int modifiers(int var1) {
  1193.       int var2 = var1;
  1194.  
  1195.       while(true) {
  1196.          short var3;
  1197.          switch (this.field_0.sym) {
  1198.             case 60:
  1199.                var3 = 1024;
  1200.                break;
  1201.             case 61:
  1202.             case 62:
  1203.             case 63:
  1204.             case 64:
  1205.             case 65:
  1206.             case 66:
  1207.             case 67:
  1208.             case 68:
  1209.             case 69:
  1210.             case 70:
  1211.             case 72:
  1212.             case 73:
  1213.             case 74:
  1214.             case 75:
  1215.             case 76:
  1216.             case 77:
  1217.             case 79:
  1218.             case 80:
  1219.             case 84:
  1220.             case 86:
  1221.             case 87:
  1222.             case 89:
  1223.             case 91:
  1224.             case 92:
  1225.             default:
  1226.                return var2;
  1227.             case 71:
  1228.                var3 = 16;
  1229.                break;
  1230.             case 78:
  1231.                var3 = 256;
  1232.                break;
  1233.             case 81:
  1234.                var3 = 2;
  1235.                break;
  1236.             case 82:
  1237.                var3 = 4;
  1238.                break;
  1239.             case 83:
  1240.                var3 = 1;
  1241.                break;
  1242.             case 85:
  1243.                var3 = 8;
  1244.                break;
  1245.             case 88:
  1246.                var3 = 32;
  1247.                break;
  1248.             case 90:
  1249.                var3 = 64;
  1250.                break;
  1251.             case 93:
  1252.                var3 = 128;
  1253.          }
  1254.  
  1255.          if ((var2 & var3) != 0) {
  1256.             Report.error(this.field_0.pos, "repeated modifier");
  1257.          }
  1258.  
  1259.          var2 |= var3;
  1260.          this.field_0.nextsym();
  1261.       }
  1262.    }
  1263.  
  1264.    private IdRef typeident() {
  1265.       int var1 = this.field_0.pos;
  1266.       switch (this.field_0.sym) {
  1267.          case 1:
  1268.             return this.qualident();
  1269.          case 98:
  1270.             this.field_0.nextsym();
  1271.             return new TypeIdent(var1, byteS);
  1272.          case 97:
  1273.             this.field_0.nextsym();
  1274.             return new TypeIdent(var1, booleanS);
  1275.          case 99:
  1276.             this.field_0.nextsym();
  1277.             return new TypeIdent(var1, charS);
  1278.          case 100:
  1279.             this.field_0.nextsym();
  1280.             return new TypeIdent(var1, doubleS);
  1281.          case 101:
  1282.             this.field_0.nextsym();
  1283.             return new TypeIdent(var1, floatS);
  1284.          case 102:
  1285.             this.field_0.nextsym();
  1286.             return new TypeIdent(var1, intS);
  1287.          case 103:
  1288.             this.field_0.nextsym();
  1289.             return new TypeIdent(var1, longS);
  1290.          case 104:
  1291.             this.field_0.nextsym();
  1292.             return new TypeIdent(var1, shortS);
  1293.          case 105:
  1294.             this.field_0.nextsym();
  1295.             return new TypeIdent(var1, voidS);
  1296.          default:
  1297.             this.syntaxError("illegal start of type");
  1298.             return new TypeIdent(var1, Name.fromString("<error>"));
  1299.       }
  1300.    }
  1301.  
  1302.    private IdRef qualident() {
  1303.       int var1 = this.field_0.pos;
  1304.  
  1305.       Object var2;
  1306.       for(var2 = new Ident(var1, this.ident()); this.field_0.sym == 10; var2 = new Select(var1, (AST)var2, this.ident())) {
  1307.          this.field_0.nextsym();
  1308.       }
  1309.  
  1310.       return (IdRef)var2;
  1311.    }
  1312.  
  1313.    private Name ident() {
  1314.       if (this.field_0.sym == 1) {
  1315.          Name var1 = this.field_0.name;
  1316.          this.field_0.nextsym();
  1317.          return var1;
  1318.       } else {
  1319.          this.accept(1);
  1320.          return Name.fromString("<error>");
  1321.       }
  1322.    }
  1323.  
  1324.    private void accept(int var1) {
  1325.       if (this.field_0.sym == var1) {
  1326.          this.field_0.nextsym();
  1327.       } else {
  1328.          int var2;
  1329.          if (this.field_0.pos >>> 10 > this.field_0.lastpos >>> 10) {
  1330.             var2 = this.field_0.lastpos;
  1331.          } else {
  1332.             var2 = this.field_0.pos;
  1333.          }
  1334.  
  1335.          this.syntaxError(String.valueOf(this.field_0.sym2string(var1)).concat(String.valueOf(" expected")), var2);
  1336.          if (this.field_0.sym == var1) {
  1337.             this.field_0.nextsym();
  1338.          }
  1339.       }
  1340.  
  1341.    }
  1342.  
  1343.    private void syntaxError(String var1) {
  1344.       this.syntaxError(var1, this.field_0.pos);
  1345.    }
  1346.  
  1347.    private void syntaxError(String var1, int var2) {
  1348.       if (this.field_0.pos != this.field_0.errPos) {
  1349.          Report.error(var2, var1);
  1350.       }
  1351.  
  1352.       this.skip();
  1353.       this.field_0.errPos = this.field_0.pos;
  1354.    }
  1355.  
  1356.    private void skip() {
  1357.       int var1 = 0;
  1358.       int var2 = 0;
  1359.  
  1360.       while(true) {
  1361.          switch (this.field_0.sym) {
  1362.             case 111:
  1363.             case 64:
  1364.                return;
  1365.             case 12:
  1366.                if (var1 == 0 && var2 == 0) {
  1367.                   return;
  1368.                }
  1369.                break;
  1370.             case 18:
  1371.                if (var1 == 0) {
  1372.                   return;
  1373.                }
  1374.  
  1375.                --var1;
  1376.                break;
  1377.             case 14:
  1378.                if (var2 > 0) {
  1379.                   --var2;
  1380.                }
  1381.                break;
  1382.             case 17:
  1383.                ++var1;
  1384.                break;
  1385.             case 13:
  1386.                ++var2;
  1387.          }
  1388.  
  1389.          this.field_0.nextsym();
  1390.       }
  1391.    }
  1392.  
  1393.    Parser(Scanner var1) {
  1394.       this.field_0 = var1;
  1395.    }
  1396. }
  1397.