home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / sun / tools / java / Parser.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  26.9 KB  |  1,653 lines
  1. package sun.tools.java;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Vector;
  6. import sun.tools.tree.AddExpression;
  7. import sun.tools.tree.AndExpression;
  8. import sun.tools.tree.ArrayAccessExpression;
  9. import sun.tools.tree.ArrayExpression;
  10. import sun.tools.tree.AssignAddExpression;
  11. import sun.tools.tree.AssignBitAndExpression;
  12. import sun.tools.tree.AssignBitOrExpression;
  13. import sun.tools.tree.AssignBitXorExpression;
  14. import sun.tools.tree.AssignDivideExpression;
  15. import sun.tools.tree.AssignExpression;
  16. import sun.tools.tree.AssignMultiplyExpression;
  17. import sun.tools.tree.AssignRemainderExpression;
  18. import sun.tools.tree.AssignShiftLeftExpression;
  19. import sun.tools.tree.AssignShiftRightExpression;
  20. import sun.tools.tree.AssignSubtractExpression;
  21. import sun.tools.tree.AssignUnsignedShiftRightExpression;
  22. import sun.tools.tree.BitAndExpression;
  23. import sun.tools.tree.BitNotExpression;
  24. import sun.tools.tree.BitOrExpression;
  25. import sun.tools.tree.BitXorExpression;
  26. import sun.tools.tree.BooleanExpression;
  27. import sun.tools.tree.BreakStatement;
  28. import sun.tools.tree.CaseStatement;
  29. import sun.tools.tree.CastExpression;
  30. import sun.tools.tree.CatchStatement;
  31. import sun.tools.tree.CharExpression;
  32. import sun.tools.tree.CommaExpression;
  33. import sun.tools.tree.CompoundStatement;
  34. import sun.tools.tree.ConditionalExpression;
  35. import sun.tools.tree.ContinueStatement;
  36. import sun.tools.tree.DeclarationStatement;
  37. import sun.tools.tree.DivideExpression;
  38. import sun.tools.tree.DoStatement;
  39. import sun.tools.tree.DoubleExpression;
  40. import sun.tools.tree.EqualExpression;
  41. import sun.tools.tree.ExprExpression;
  42. import sun.tools.tree.Expression;
  43. import sun.tools.tree.ExpressionStatement;
  44. import sun.tools.tree.FieldExpression;
  45. import sun.tools.tree.FinallyStatement;
  46. import sun.tools.tree.FloatExpression;
  47. import sun.tools.tree.ForStatement;
  48. import sun.tools.tree.GreaterExpression;
  49. import sun.tools.tree.GreaterOrEqualExpression;
  50. import sun.tools.tree.IdentifierExpression;
  51. import sun.tools.tree.IfStatement;
  52. import sun.tools.tree.InstanceOfExpression;
  53. import sun.tools.tree.IntExpression;
  54. import sun.tools.tree.LessExpression;
  55. import sun.tools.tree.LessOrEqualExpression;
  56. import sun.tools.tree.LocalField;
  57. import sun.tools.tree.LongExpression;
  58. import sun.tools.tree.MethodExpression;
  59. import sun.tools.tree.MultiplyExpression;
  60. import sun.tools.tree.NegativeExpression;
  61. import sun.tools.tree.NewArrayExpression;
  62. import sun.tools.tree.NewInstanceExpression;
  63. import sun.tools.tree.Node;
  64. import sun.tools.tree.NotEqualExpression;
  65. import sun.tools.tree.NotExpression;
  66. import sun.tools.tree.NullExpression;
  67. import sun.tools.tree.OrExpression;
  68. import sun.tools.tree.PositiveExpression;
  69. import sun.tools.tree.PostDecExpression;
  70. import sun.tools.tree.PostIncExpression;
  71. import sun.tools.tree.PreDecExpression;
  72. import sun.tools.tree.PreIncExpression;
  73. import sun.tools.tree.RemainderExpression;
  74. import sun.tools.tree.ReturnStatement;
  75. import sun.tools.tree.ShiftLeftExpression;
  76. import sun.tools.tree.ShiftRightExpression;
  77. import sun.tools.tree.Statement;
  78. import sun.tools.tree.StringExpression;
  79. import sun.tools.tree.SubtractExpression;
  80. import sun.tools.tree.SuperExpression;
  81. import sun.tools.tree.SwitchStatement;
  82. import sun.tools.tree.SynchronizedStatement;
  83. import sun.tools.tree.ThisExpression;
  84. import sun.tools.tree.ThrowStatement;
  85. import sun.tools.tree.TryStatement;
  86. import sun.tools.tree.TypeExpression;
  87. import sun.tools.tree.UnsignedShiftRightExpression;
  88. import sun.tools.tree.VarDeclarationStatement;
  89. import sun.tools.tree.WhileStatement;
  90.  
  91. public class Parser extends Scanner implements ParserActions, Constants {
  92.    ParserActions actions;
  93.    private Node[] args;
  94.    protected int argIndex;
  95.    private int aCount;
  96.    private Type[] aTypes;
  97.    private IdentifierToken[] aNames;
  98.    private ClassDefinition curClass;
  99.    protected Scanner scanner;
  100.  
  101.    protected Parser(Environment var1, InputStream var2) throws IOException {
  102.       super(var1, var2);
  103.       this.args = new Node[32];
  104.       this.aTypes = new Type[8];
  105.       this.aNames = new IdentifierToken[this.aTypes.length];
  106.       this.scanner = this;
  107.       this.actions = this;
  108.    }
  109.  
  110.    protected Parser(Scanner var1) throws IOException {
  111.       super(var1.env);
  112.       this.args = new Node[32];
  113.       this.aTypes = new Type[8];
  114.       this.aNames = new IdentifierToken[this.aTypes.length];
  115.       this.scanner = var1;
  116.       super.env = var1.env;
  117.       super.token = var1.token;
  118.       super.pos = var1.pos;
  119.       this.actions = this;
  120.    }
  121.  
  122.    public Parser(Scanner var1, ParserActions var2) throws IOException {
  123.       this(var1);
  124.       this.actions = var2;
  125.    }
  126.  
  127.    public void packageDeclaration(int var1, IdentifierToken var2) {
  128.       this.packageDeclaration(var1, var2.id);
  129.    }
  130.  
  131.    protected void packageDeclaration(int var1, Identifier var2) {
  132.       throw new RuntimeException("beginClass method is abstract");
  133.    }
  134.  
  135.    public void importClass(int var1, IdentifierToken var2) {
  136.       this.importClass(var1, var2.id);
  137.    }
  138.  
  139.    protected void importClass(int var1, Identifier var2) {
  140.       throw new RuntimeException("importClass method is abstract");
  141.    }
  142.  
  143.    public void importPackage(int var1, IdentifierToken var2) {
  144.       this.importPackage(var1, var2.id);
  145.    }
  146.  
  147.    protected void importPackage(int var1, Identifier var2) {
  148.       throw new RuntimeException("importPackage method is abstract");
  149.    }
  150.  
  151.    public ClassDefinition beginClass(int var1, String var2, int var3, IdentifierToken var4, IdentifierToken var5, IdentifierToken[] var6) {
  152.       Identifier var7 = var5 == null ? null : var5.id;
  153.       Identifier[] var8 = null;
  154.       if (var6 != null) {
  155.          var8 = new Identifier[var6.length];
  156.  
  157.          for(int var9 = 0; var9 < var6.length; ++var9) {
  158.             var8[var9] = var6[var9].id;
  159.          }
  160.       }
  161.  
  162.       this.beginClass(var1, var2, var3, var4.id, var7, var8);
  163.       return this.getCurrentClass();
  164.    }
  165.  
  166.    protected void beginClass(int var1, String var2, int var3, Identifier var4, Identifier var5, Identifier[] var6) {
  167.       throw new RuntimeException("beginClass method is abstract");
  168.    }
  169.  
  170.    protected ClassDefinition getCurrentClass() {
  171.       return null;
  172.    }
  173.  
  174.    public void endClass(int var1, ClassDefinition var2) {
  175.       this.endClass(var1, var2.getName().getFlatName().getName());
  176.    }
  177.  
  178.    protected void endClass(int var1, Identifier var2) {
  179.       throw new RuntimeException("endClass method is abstract");
  180.    }
  181.  
  182.    public void defineField(int var1, ClassDefinition var2, String var3, int var4, Type var5, IdentifierToken var6, IdentifierToken[] var7, IdentifierToken[] var8, Node var9) {
  183.       Identifier[] var10 = null;
  184.       Identifier[] var11 = null;
  185.       if (var7 != null) {
  186.          var10 = new Identifier[var7.length];
  187.  
  188.          for(int var12 = 0; var12 < var7.length; ++var12) {
  189.             var10[var12] = var7[var12].id;
  190.          }
  191.       }
  192.  
  193.       if (var8 != null) {
  194.          var11 = new Identifier[var8.length];
  195.  
  196.          for(int var13 = 0; var13 < var8.length; ++var13) {
  197.             var11[var13] = var8[var13].id;
  198.          }
  199.       }
  200.  
  201.       this.defineField(var1, var3, var4, var5, var6.id, var10, var11, var9);
  202.    }
  203.  
  204.    protected void defineField(int var1, String var2, int var3, Type var4, Identifier var5, Identifier[] var6, Identifier[] var7, Node var8) {
  205.       throw new RuntimeException("defineField method is abstract");
  206.    }
  207.  
  208.    protected final void addArgument(Node var1) {
  209.       if (this.argIndex == this.args.length) {
  210.          Node[] var2 = new Node[this.args.length * 2];
  211.          System.arraycopy(this.args, 0, var2, 0, this.args.length);
  212.          this.args = var2;
  213.       }
  214.  
  215.       this.args[this.argIndex++] = var1;
  216.    }
  217.  
  218.    protected final Expression[] exprArgs(int var1) {
  219.       Expression[] var2 = new Expression[this.argIndex - var1];
  220.       System.arraycopy(this.args, var1, var2, 0, this.argIndex - var1);
  221.       this.argIndex = var1;
  222.       return var2;
  223.    }
  224.  
  225.    protected final Statement[] statArgs(int var1) {
  226.       Statement[] var2 = new Statement[this.argIndex - var1];
  227.       System.arraycopy(this.args, var1, var2, 0, this.argIndex - var1);
  228.       this.argIndex = var1;
  229.       return var2;
  230.    }
  231.  
  232.    protected void expect(int var1) throws SyntaxError, IOException {
  233.       if (super.token != var1) {
  234.          switch (var1) {
  235.             case 60:
  236.                super.env.error(this.scanner.prevPos, "identifier.expected");
  237.                break;
  238.             default:
  239.                super.env.error(this.scanner.prevPos, "token.expected", Constants.opNames[var1]);
  240.          }
  241.  
  242.          throw new SyntaxError();
  243.       } else {
  244.          this.scan();
  245.       }
  246.    }
  247.  
  248.    protected Expression parseTypeExpression() throws SyntaxError, IOException {
  249.       switch (super.token) {
  250.          case 60:
  251.             Object var1 = new IdentifierExpression(super.pos, this.scanner.idValue);
  252.             this.scan();
  253.  
  254.             while(super.token == 46) {
  255.                var1 = new FieldExpression(this.scan(), (Expression)var1, this.scanner.idValue);
  256.                this.expect(60);
  257.             }
  258.  
  259.             return (Expression)var1;
  260.          case 70:
  261.             return new TypeExpression(this.scan(), Type.tByte);
  262.          case 71:
  263.             return new TypeExpression(this.scan(), Type.tChar);
  264.          case 72:
  265.             return new TypeExpression(this.scan(), Type.tShort);
  266.          case 73:
  267.             return new TypeExpression(this.scan(), Type.tInt);
  268.          case 74:
  269.             return new TypeExpression(this.scan(), Type.tLong);
  270.          case 75:
  271.             return new TypeExpression(this.scan(), Type.tFloat);
  272.          case 76:
  273.             return new TypeExpression(this.scan(), Type.tDouble);
  274.          case 77:
  275.             return new TypeExpression(this.scan(), Type.tVoid);
  276.          case 78:
  277.             return new TypeExpression(this.scan(), Type.tBoolean);
  278.          default:
  279.             super.env.error(super.pos, "type.expected");
  280.             throw new SyntaxError();
  281.       }
  282.    }
  283.  
  284.    protected Expression parseMethodExpression(Expression var1, Identifier var2) throws SyntaxError, IOException {
  285.       int var3 = this.scan();
  286.       int var4 = this.argIndex;
  287.       if (super.token != 141) {
  288.          this.addArgument(this.parseExpression());
  289.  
  290.          while(super.token == 0) {
  291.             this.scan();
  292.             this.addArgument(this.parseExpression());
  293.          }
  294.       }
  295.  
  296.       this.expect(141);
  297.       return new MethodExpression(var3, var1, var2, this.exprArgs(var4));
  298.    }
  299.  
  300.    protected Expression parseNewInstanceExpression(int var1, Expression var2, Expression var3) throws SyntaxError, IOException {
  301.       int var4 = this.argIndex;
  302.       this.expect(140);
  303.       if (super.token != 141) {
  304.          this.addArgument(this.parseExpression());
  305.  
  306.          while(super.token == 0) {
  307.             this.scan();
  308.             this.addArgument(this.parseExpression());
  309.          }
  310.       }
  311.  
  312.       this.expect(141);
  313.       ClassDefinition var5 = null;
  314.       if (super.token == 138 && !(var3 instanceof TypeExpression)) {
  315.          int var6 = super.pos;
  316.          super.env.innerClassesUsed(var1);
  317.          Identifier var7 = FieldExpression.toIdentifier(var3);
  318.          if (var7 == null) {
  319.             super.env.error(((Node)var3).getWhere(), "type.expected");
  320.          }
  321.  
  322.          Vector var8 = new Vector(1);
  323.          Vector var9 = new Vector(0);
  324.          var8.addElement(new IdentifierToken(Constants.idNull));
  325.          if (super.token == 113 || super.token == 112) {
  326.             super.env.error(super.pos, "anonymous.extends");
  327.             this.parseInheritance(var8, var9);
  328.          }
  329.  
  330.          var5 = this.parseClassBody(new IdentifierToken(var6, Constants.idNull), 196608, 56, (String)null, var8, var9, ((Node)var3).getWhere());
  331.       }
  332.  
  333.       return var2 == null && var5 == null ? new NewInstanceExpression(var1, var3, this.exprArgs(var4)) : new NewInstanceExpression(var1, var3, this.exprArgs(var4), var2, var5);
  334.    }
  335.  
  336.    protected Expression parseTerm() throws SyntaxError, IOException {
  337.       switch (super.token) {
  338.          case 29:
  339.             int var17 = this.scan();
  340.             switch (super.token) {
  341.                case 65:
  342.                   int var29 = this.scanner.intValue;
  343.                   int var31 = this.scan();
  344.                   if (var29 < 0 && super.radix == 10) {
  345.                      super.env.error(var31, "overflow");
  346.                   }
  347.  
  348.                   return new IntExpression(var31, var29);
  349.                case 66:
  350.                   long var28 = this.scanner.longValue;
  351.                   int var32 = this.scan();
  352.                   if (var28 < 0L && super.radix == 10) {
  353.                      super.env.error(var32, "overflow");
  354.                   }
  355.  
  356.                   return new LongExpression(var32, var28);
  357.                case 67:
  358.                   float var27 = this.scanner.floatValue;
  359.                   return new FloatExpression(this.scan(), var27);
  360.                case 68:
  361.                   double var26 = this.scanner.doubleValue;
  362.                   return new DoubleExpression(this.scan(), var26);
  363.                default:
  364.                   return new PositiveExpression(var17, this.parseTerm());
  365.             }
  366.          case 30:
  367.             int var16 = this.scan();
  368.             switch (super.token) {
  369.                case 65:
  370.                   int var25 = -this.scanner.intValue;
  371.                   return new IntExpression(this.scan(), var25);
  372.                case 66:
  373.                   long var24 = -this.scanner.longValue;
  374.                   return new LongExpression(this.scan(), var24);
  375.                case 67:
  376.                   float var23 = -this.scanner.floatValue;
  377.                   return new FloatExpression(this.scan(), var23);
  378.                case 68:
  379.                   double var22 = -this.scanner.doubleValue;
  380.                   return new DoubleExpression(this.scan(), var22);
  381.                default:
  382.                   return new NegativeExpression(var16, this.parseTerm());
  383.             }
  384.          case 37:
  385.             return new NotExpression(this.scan(), this.parseTerm());
  386.          case 38:
  387.             return new BitNotExpression(this.scan(), this.parseTerm());
  388.          case 49:
  389.             int var15 = this.scan();
  390.             int var21 = this.argIndex;
  391.             if (super.token == 140) {
  392.                this.scan();
  393.                this.parseExpression();
  394.                this.expect(141);
  395.                super.env.error(var15, "not.supported", "new(...)");
  396.                return new NullExpression(var15);
  397.             } else {
  398.                Expression var30 = this.parseTypeExpression();
  399.                if (super.token == 142) {
  400.                   while(super.token == 142) {
  401.                      this.scan();
  402.                      this.addArgument(super.token != 143 ? this.parseExpression() : null);
  403.                      this.expect(143);
  404.                   }
  405.  
  406.                   Expression[] var4 = this.exprArgs(var21);
  407.                   if (super.token == 138) {
  408.                      super.env.innerClassesUsed(var15);
  409.                      return new NewArrayExpression(var15, var30, var4, this.parseTerm());
  410.                   }
  411.  
  412.                   return new NewArrayExpression(var15, var30, var4);
  413.                }
  414.  
  415.                return this.parseNewInstanceExpression(var15, (Expression)null, var30);
  416.             }
  417.          case 50:
  418.             return new PreIncExpression(this.scan(), this.parseTerm());
  419.          case 51:
  420.             return new PreDecExpression(this.scan(), this.parseTerm());
  421.          case 60:
  422.             Identifier var14 = this.scanner.idValue;
  423.             int var20 = this.scan();
  424.             if (super.token == 140) {
  425.                return this.parseMethodExpression((Expression)null, var14);
  426.             }
  427.  
  428.             return new IdentifierExpression(var20, var14);
  429.          case 63:
  430.             char var13 = this.scanner.charValue;
  431.             return new CharExpression(this.scan(), var13);
  432.          case 65:
  433.             int var12 = this.scanner.intValue;
  434.             int var19 = this.scan();
  435.             if (var12 < 0 && super.radix == 10) {
  436.                super.env.error(var19, "overflow");
  437.             }
  438.  
  439.             return new IntExpression(var19, var12);
  440.          case 66:
  441.             long var11 = this.scanner.longValue;
  442.             int var3 = this.scan();
  443.             if (var11 < 0L && super.radix == 10) {
  444.                super.env.error(var3, "overflow");
  445.             }
  446.  
  447.             return new LongExpression(var3, var11);
  448.          case 67:
  449.             float var10 = this.scanner.floatValue;
  450.             return new FloatExpression(this.scan(), var10);
  451.          case 68:
  452.             double var9 = this.scanner.doubleValue;
  453.             return new DoubleExpression(this.scan(), var9);
  454.          case 69:
  455.             String var8 = this.scanner.stringValue;
  456.             return new StringExpression(this.scan(), var8);
  457.          case 70:
  458.          case 71:
  459.          case 72:
  460.          case 73:
  461.          case 74:
  462.          case 75:
  463.          case 76:
  464.          case 77:
  465.          case 78:
  466.             return this.parseTypeExpression();
  467.          case 80:
  468.             return new BooleanExpression(this.scan(), true);
  469.          case 81:
  470.             return new BooleanExpression(this.scan(), false);
  471.          case 82:
  472.             ThisExpression var7 = new ThisExpression(this.scan());
  473.             if (super.token == 140) {
  474.                return this.parseMethodExpression(var7, Constants.idInit);
  475.             }
  476.  
  477.             return var7;
  478.          case 83:
  479.             SuperExpression var6 = new SuperExpression(this.scan());
  480.             if (super.token == 140) {
  481.                return this.parseMethodExpression(var6, Constants.idInit);
  482.             }
  483.  
  484.             return var6;
  485.          case 84:
  486.             return new NullExpression(this.scan());
  487.          case 138:
  488.             int var5 = this.scan();
  489.             int var18 = this.argIndex;
  490.             if (super.token != 139) {
  491.                this.addArgument(this.parseExpression());
  492.  
  493.                while(super.token == 0) {
  494.                   this.scan();
  495.                   if (super.token == 139) {
  496.                      break;
  497.                   }
  498.  
  499.                   this.addArgument(this.parseExpression());
  500.                }
  501.             }
  502.  
  503.             this.expect(139);
  504.             return new ArrayExpression(var5, this.exprArgs(var18));
  505.          case 140:
  506.             int var1 = this.scan();
  507.             Expression var2 = this.parseExpression();
  508.             this.expect(141);
  509.             if (((Node)var2).getOp() == 147) {
  510.                return new CastExpression(var1, var2, this.parseTerm());
  511.             } else {
  512.                switch (super.token) {
  513.                   case 37:
  514.                   case 38:
  515.                   case 49:
  516.                   case 50:
  517.                   case 51:
  518.                   case 60:
  519.                   case 63:
  520.                   case 65:
  521.                   case 66:
  522.                   case 67:
  523.                   case 68:
  524.                   case 69:
  525.                   case 80:
  526.                   case 81:
  527.                   case 82:
  528.                   case 83:
  529.                   case 84:
  530.                   case 140:
  531.                      return new CastExpression(var1, var2, this.parseTerm());
  532.                   default:
  533.                      return new ExprExpression(var1, var2);
  534.                }
  535.             }
  536.          default:
  537.             super.env.error(this.scanner.prevPos, "missing.term");
  538.             return new IntExpression(super.pos, 0);
  539.       }
  540.    }
  541.  
  542.    protected Expression parseExpression() throws SyntaxError, IOException {
  543.       Expression var2;
  544.       for(Expression var1 = this.parseTerm(); var1 != null; var1 = var2.order()) {
  545.          var2 = this.parseBinaryExpression(var1);
  546.          if (var2 == null) {
  547.             return var1;
  548.          }
  549.       }
  550.  
  551.       return null;
  552.    }
  553.  
  554.    protected Expression parseBinaryExpression(Expression var1) throws SyntaxError, IOException {
  555.       if (var1 != null) {
  556.          switch (super.token) {
  557.             case 1:
  558.                var1 = new AssignExpression(this.scan(), (Expression)var1, this.parseTerm());
  559.                break;
  560.             case 2:
  561.                var1 = new AssignMultiplyExpression(this.scan(), (Expression)var1, this.parseTerm());
  562.                break;
  563.             case 3:
  564.                var1 = new AssignDivideExpression(this.scan(), (Expression)var1, this.parseTerm());
  565.                break;
  566.             case 4:
  567.                var1 = new AssignRemainderExpression(this.scan(), (Expression)var1, this.parseTerm());
  568.                break;
  569.             case 5:
  570.                var1 = new AssignAddExpression(this.scan(), (Expression)var1, this.parseTerm());
  571.                break;
  572.             case 6:
  573.                var1 = new AssignSubtractExpression(this.scan(), (Expression)var1, this.parseTerm());
  574.                break;
  575.             case 7:
  576.                var1 = new AssignShiftLeftExpression(this.scan(), (Expression)var1, this.parseTerm());
  577.                break;
  578.             case 8:
  579.                var1 = new AssignShiftRightExpression(this.scan(), (Expression)var1, this.parseTerm());
  580.                break;
  581.             case 9:
  582.                var1 = new AssignUnsignedShiftRightExpression(this.scan(), (Expression)var1, this.parseTerm());
  583.                break;
  584.             case 10:
  585.                var1 = new AssignBitAndExpression(this.scan(), (Expression)var1, this.parseTerm());
  586.                break;
  587.             case 11:
  588.                var1 = new AssignBitOrExpression(this.scan(), (Expression)var1, this.parseTerm());
  589.                break;
  590.             case 12:
  591.                var1 = new AssignBitXorExpression(this.scan(), (Expression)var1, this.parseTerm());
  592.                break;
  593.             case 14:
  594.                var1 = new OrExpression(this.scan(), (Expression)var1, this.parseTerm());
  595.                break;
  596.             case 15:
  597.                var1 = new AndExpression(this.scan(), (Expression)var1, this.parseTerm());
  598.                break;
  599.             case 16:
  600.                var1 = new BitOrExpression(this.scan(), (Expression)var1, this.parseTerm());
  601.                break;
  602.             case 17:
  603.                var1 = new BitXorExpression(this.scan(), (Expression)var1, this.parseTerm());
  604.                break;
  605.             case 18:
  606.                var1 = new BitAndExpression(this.scan(), (Expression)var1, this.parseTerm());
  607.                break;
  608.             case 19:
  609.                var1 = new NotEqualExpression(this.scan(), (Expression)var1, this.parseTerm());
  610.                break;
  611.             case 20:
  612.                var1 = new EqualExpression(this.scan(), (Expression)var1, this.parseTerm());
  613.                break;
  614.             case 21:
  615.                var1 = new GreaterOrEqualExpression(this.scan(), (Expression)var1, this.parseTerm());
  616.                break;
  617.             case 22:
  618.                var1 = new GreaterExpression(this.scan(), (Expression)var1, this.parseTerm());
  619.                break;
  620.             case 23:
  621.                var1 = new LessOrEqualExpression(this.scan(), (Expression)var1, this.parseTerm());
  622.                break;
  623.             case 24:
  624.                var1 = new LessExpression(this.scan(), (Expression)var1, this.parseTerm());
  625.                break;
  626.             case 25:
  627.                var1 = new InstanceOfExpression(this.scan(), (Expression)var1, this.parseTerm());
  628.                break;
  629.             case 26:
  630.                var1 = new ShiftLeftExpression(this.scan(), (Expression)var1, this.parseTerm());
  631.                break;
  632.             case 27:
  633.                var1 = new ShiftRightExpression(this.scan(), (Expression)var1, this.parseTerm());
  634.                break;
  635.             case 28:
  636.                var1 = new UnsignedShiftRightExpression(this.scan(), (Expression)var1, this.parseTerm());
  637.                break;
  638.             case 29:
  639.                var1 = new AddExpression(this.scan(), (Expression)var1, this.parseTerm());
  640.                break;
  641.             case 30:
  642.                var1 = new SubtractExpression(this.scan(), (Expression)var1, this.parseTerm());
  643.                break;
  644.             case 31:
  645.                var1 = new DivideExpression(this.scan(), (Expression)var1, this.parseTerm());
  646.                break;
  647.             case 32:
  648.                var1 = new RemainderExpression(this.scan(), (Expression)var1, this.parseTerm());
  649.                break;
  650.             case 33:
  651.                var1 = new MultiplyExpression(this.scan(), (Expression)var1, this.parseTerm());
  652.                break;
  653.             case 46:
  654.                int var6 = this.scan();
  655.                if (super.token == 82) {
  656.                   super.env.innerClassesUsed(var6);
  657.                   this.scan();
  658.                   var1 = new FieldExpression(var6, (Expression)var1, Constants.idThis);
  659.                } else if (super.token == 49) {
  660.                   super.env.innerClassesUsed(var6);
  661.                   this.scan();
  662.                   if (super.token != 60) {
  663.                      this.expect(60);
  664.                   }
  665.  
  666.                   var1 = this.parseNewInstanceExpression(var6, (Expression)var1, this.parseTypeExpression());
  667.                } else if (super.token == 111) {
  668.                   super.env.innerClassesUsed(var6);
  669.                   this.scan();
  670.                   var1 = new FieldExpression(var6, (Expression)var1, Constants.idClass);
  671.                } else if (super.token == 83) {
  672.                   super.env.innerClassesUsed(var6);
  673.                   SuperExpression var4 = new SuperExpression(this.scan(), (Expression)var1);
  674.                   if (super.token != 140) {
  675.                      this.expect(140);
  676.                   }
  677.  
  678.                   var1 = this.parseMethodExpression(var4, Constants.idInit);
  679.                } else {
  680.                   Identifier var8 = this.scanner.idValue;
  681.                   this.expect(60);
  682.                   if (super.token == 140) {
  683.                      var1 = this.parseMethodExpression((Expression)var1, var8);
  684.                   } else {
  685.                      var1 = new FieldExpression(var6, (Expression)var1, var8);
  686.                   }
  687.                }
  688.                break;
  689.             case 50:
  690.                var1 = new PostIncExpression(this.scan(), (Expression)var1);
  691.                break;
  692.             case 51:
  693.                var1 = new PostDecExpression(this.scan(), (Expression)var1);
  694.                break;
  695.             case 137:
  696.                int var5 = this.scan();
  697.                Expression var7 = this.parseExpression();
  698.                this.expect(136);
  699.                var1 = new ConditionalExpression(var5, (Expression)var1, var7, this.parseExpression());
  700.                break;
  701.             case 142:
  702.                int var2 = this.scan();
  703.                Expression var3 = super.token != 143 ? this.parseExpression() : null;
  704.                this.expect(143);
  705.                var1 = new ArrayAccessExpression(var2, (Expression)var1, var3);
  706.                break;
  707.             default:
  708.                return null;
  709.          }
  710.       }
  711.  
  712.       return (Expression)var1;
  713.    }
  714.  
  715.    protected boolean recoverStatement() throws SyntaxError, IOException {
  716.       while(true) {
  717.          switch (super.token) {
  718.             case -1:
  719.             case 90:
  720.             case 92:
  721.             case 93:
  722.             case 94:
  723.             case 98:
  724.             case 99:
  725.             case 100:
  726.             case 101:
  727.             case 102:
  728.             case 103:
  729.             case 138:
  730.             case 139:
  731.                return true;
  732.             case 77:
  733.             case 111:
  734.             case 114:
  735.             case 120:
  736.             case 121:
  737.             case 124:
  738.             case 125:
  739.             case 126:
  740.                this.expect(139);
  741.                return false;
  742.             case 140:
  743.                this.match(140, 141);
  744.                this.scan();
  745.                break;
  746.             case 142:
  747.                this.match(142, 143);
  748.                this.scan();
  749.                break;
  750.             default:
  751.                this.scan();
  752.          }
  753.       }
  754.    }
  755.  
  756.    protected Statement parseDeclaration(int var1, int var2, Expression var3) throws SyntaxError, IOException {
  757.       int var4 = this.argIndex;
  758.       if (super.token == 60) {
  759.          this.addArgument(new VarDeclarationStatement(super.pos, this.parseExpression()));
  760.  
  761.          while(super.token == 0) {
  762.             this.scan();
  763.             this.addArgument(new VarDeclarationStatement(super.pos, this.parseExpression()));
  764.          }
  765.       }
  766.  
  767.       return new DeclarationStatement(var1, var2, var3, this.statArgs(var4));
  768.    }
  769.  
  770.    protected void topLevelExpression(Expression var1) {
  771.       switch (((Node)var1).getOp()) {
  772.          case 1:
  773.          case 2:
  774.          case 3:
  775.          case 4:
  776.          case 5:
  777.          case 6:
  778.          case 7:
  779.          case 8:
  780.          case 9:
  781.          case 10:
  782.          case 11:
  783.          case 12:
  784.          case 39:
  785.          case 40:
  786.          case 42:
  787.          case 44:
  788.          case 45:
  789.          case 47:
  790.             return;
  791.          default:
  792.             super.env.error(((Node)var1).getWhere(), "invalid.expr");
  793.       }
  794.    }
  795.  
  796.    protected Statement parseStatement() throws SyntaxError, IOException {
  797.       switch (super.token) {
  798.          case 58:
  799.             int var23 = this.scan();
  800.             this.expect(60);
  801.             this.expect(135);
  802.             super.env.error(var23, "not.supported", "goto");
  803.             return new CompoundStatement(var23, new Statement[0]);
  804.          case 77:
  805.          case 120:
  806.          case 121:
  807.          case 124:
  808.          case 125:
  809.             super.env.error(super.pos, "statement.expected");
  810.             throw new SyntaxError();
  811.          case 90:
  812.             int var22 = this.scan();
  813.             this.expect(140);
  814.             Expression var35 = this.parseExpression();
  815.             this.expect(141);
  816.             Statement var41 = this.parseStatement();
  817.             if (super.token == 91) {
  818.                this.scan();
  819.                return new IfStatement(var22, var35, var41, this.parseStatement());
  820.             }
  821.  
  822.             return new IfStatement(var22, var35, var41, (Statement)null);
  823.          case 91:
  824.             super.env.error(this.scan(), "else.without.if");
  825.             return this.parseStatement();
  826.          case 92:
  827.             int var21 = this.scan();
  828.             Object var34 = null;
  829.             Expression var40 = null;
  830.             Object var46 = null;
  831.             this.expect(140);
  832.             if (super.token != 135) {
  833.                int var47 = super.pos;
  834.                int var49 = this.parseModifiers(16);
  835.                if (var49 != 0) {
  836.                   super.env.innerClassesUsed(super.pos);
  837.                }
  838.  
  839.                Object var51 = this.parseExpression();
  840.                if (super.token == 60) {
  841.                   var34 = this.parseDeclaration(var47, var49, (Expression)var51);
  842.                } else {
  843.                   if (var49 != 0) {
  844.                      this.expect(60);
  845.                   }
  846.  
  847.                   this.topLevelExpression((Expression)var51);
  848.  
  849.                   while(super.token == 0) {
  850.                      int var52 = this.scan();
  851.                      Expression var9 = this.parseExpression();
  852.                      this.topLevelExpression(var9);
  853.                      var51 = new CommaExpression(var52, (Expression)var51, var9);
  854.                   }
  855.  
  856.                   var34 = new ExpressionStatement(var47, (Expression)var51);
  857.                }
  858.             }
  859.  
  860.             this.expect(135);
  861.             if (super.token != 135) {
  862.                var40 = this.parseExpression();
  863.             }
  864.  
  865.             this.expect(135);
  866.             if (super.token != 141) {
  867.                var46 = this.parseExpression();
  868.                this.topLevelExpression((Expression)var46);
  869.  
  870.                while(super.token == 0) {
  871.                   int var48 = this.scan();
  872.                   Expression var50 = this.parseExpression();
  873.                   this.topLevelExpression(var50);
  874.                   var46 = new CommaExpression(var48, (Expression)var46, var50);
  875.                }
  876.             }
  877.  
  878.             this.expect(141);
  879.             return new ForStatement(var21, (Statement)var34, var40, (Expression)var46, this.parseStatement());
  880.          case 93:
  881.             int var20 = this.scan();
  882.             this.expect(140);
  883.             Expression var33 = this.parseExpression();
  884.             this.expect(141);
  885.             return new WhileStatement(var20, var33, this.parseStatement());
  886.          case 94:
  887.             int var19 = this.scan();
  888.             Statement var32 = this.parseStatement();
  889.             this.expect(93);
  890.             this.expect(140);
  891.             Expression var39 = this.parseExpression();
  892.             this.expect(141);
  893.             this.expect(135);
  894.             return new DoStatement(var19, var32, var39);
  895.          case 95:
  896.             int var18 = this.scan();
  897.             int var31 = this.argIndex;
  898.             this.expect(140);
  899.             Expression var38 = this.parseExpression();
  900.             this.expect(141);
  901.             this.expect(138);
  902.  
  903.             while(super.token != -1 && super.token != 139) {
  904.                int var45 = this.argIndex;
  905.  
  906.                try {
  907.                   switch (super.token) {
  908.                      case 96:
  909.                         this.addArgument(new CaseStatement(this.scan(), this.parseExpression()));
  910.                         this.expect(136);
  911.                         break;
  912.                      case 97:
  913.                         this.addArgument(new CaseStatement(this.scan(), (Expression)null));
  914.                         this.expect(136);
  915.                         break;
  916.                      default:
  917.                         this.addArgument(this.parseStatement());
  918.                   }
  919.                } catch (SyntaxError var10) {
  920.                   this.argIndex = var45;
  921.                   if (!this.recoverStatement()) {
  922.                      throw var10;
  923.                   }
  924.                }
  925.             }
  926.  
  927.             this.expect(139);
  928.             return new SwitchStatement(var18, var38, this.statArgs(var31));
  929.          case 96:
  930.             super.env.error(super.pos, "case.without.switch");
  931.  
  932.             while(super.token == 96) {
  933.                this.scan();
  934.                this.parseExpression();
  935.                this.expect(136);
  936.             }
  937.  
  938.             return this.parseStatement();
  939.          case 97:
  940.             super.env.error(super.pos, "default.without.switch");
  941.             this.scan();
  942.             this.expect(136);
  943.             return this.parseStatement();
  944.          case 98:
  945.             int var17 = this.scan();
  946.             Identifier var30 = null;
  947.             if (super.token == 60) {
  948.                var30 = this.scanner.idValue;
  949.                this.scan();
  950.             }
  951.  
  952.             this.expect(135);
  953.             return new BreakStatement(var17, var30);
  954.          case 99:
  955.             int var16 = this.scan();
  956.             Identifier var29 = null;
  957.             if (super.token == 60) {
  958.                var29 = this.scanner.idValue;
  959.                this.scan();
  960.             }
  961.  
  962.             this.expect(135);
  963.             return new ContinueStatement(var16, var29);
  964.          case 100:
  965.             int var15 = this.scan();
  966.             Expression var28 = null;
  967.             if (super.token != 135) {
  968.                var28 = this.parseExpression();
  969.             }
  970.  
  971.             this.expect(135);
  972.             return new ReturnStatement(var15, var28);
  973.          case 101:
  974.             int var14 = this.scan();
  975.             int var27 = this.argIndex;
  976.             boolean var37 = false;
  977.  
  978.             Object var44;
  979.             for(var44 = this.parseBlockStatement(); super.token == 102; var37 = true) {
  980.                int var5 = super.pos;
  981.                this.expect(102);
  982.                this.expect(140);
  983.                int var6 = this.parseModifiers(16);
  984.                Expression var7 = this.parseExpression();
  985.                IdentifierToken var8 = this.scanner.getIdToken();
  986.                this.expect(60);
  987.                var8.modifiers = var6;
  988.                this.expect(141);
  989.                this.addArgument(new CatchStatement(var5, var7, var8, this.parseBlockStatement()));
  990.             }
  991.  
  992.             if (var37) {
  993.                var44 = new TryStatement(var14, (Statement)var44, this.statArgs(var27));
  994.             }
  995.  
  996.             if (super.token == 103) {
  997.                this.scan();
  998.                return new FinallyStatement(var14, (Statement)var44, this.parseBlockStatement());
  999.             } else {
  1000.                if (var37) {
  1001.                   return (Statement)var44;
  1002.                }
  1003.  
  1004.                super.env.error(super.pos, "try.without.catch.finally");
  1005.                return new TryStatement(var14, (Statement)var44, (Statement[])null);
  1006.             }
  1007.          case 102:
  1008.             super.env.error(super.pos, "catch.without.try");
  1009.  
  1010.             Statement var13;
  1011.             do {
  1012.                this.scan();
  1013.                this.expect(140);
  1014.                this.parseModifiers(16);
  1015.                this.parseExpression();
  1016.                this.expect(60);
  1017.                this.expect(141);
  1018.                var13 = this.parseBlockStatement();
  1019.             } while(super.token == 102);
  1020.  
  1021.             if (super.token == 103) {
  1022.                this.scan();
  1023.                var13 = this.parseBlockStatement();
  1024.             }
  1025.  
  1026.             return var13;
  1027.          case 103:
  1028.             super.env.error(super.pos, "finally.without.try");
  1029.             this.scan();
  1030.             return this.parseBlockStatement();
  1031.          case 104:
  1032.             int var12 = this.scan();
  1033.             Expression var26 = this.parseExpression();
  1034.             this.expect(135);
  1035.             return new ThrowStatement(var12, var26);
  1036.          case 111:
  1037.          case 114:
  1038.             return this.parseLocalClass(0);
  1039.          case 126:
  1040.             int var11 = this.scan();
  1041.             this.expect(140);
  1042.             Expression var25 = this.parseExpression();
  1043.             this.expect(141);
  1044.             return new SynchronizedStatement(var11, var25, this.parseBlockStatement());
  1045.          case 128:
  1046.          case 130:
  1047.             int var1 = super.pos;
  1048.             super.env.innerClassesUsed(super.pos);
  1049.             int var2 = this.parseModifiers(1040);
  1050.             switch (super.token) {
  1051.                case 60:
  1052.                case 70:
  1053.                case 71:
  1054.                case 72:
  1055.                case 73:
  1056.                case 74:
  1057.                case 75:
  1058.                case 76:
  1059.                case 78:
  1060.                   if ((var2 & 1024) != 0) {
  1061.                      var2 &= -1025;
  1062.                      this.expect(111);
  1063.                   }
  1064.  
  1065.                   Expression var3 = this.parseExpression();
  1066.                   if (super.token != 60) {
  1067.                      this.expect(60);
  1068.                   }
  1069.  
  1070.                   Statement var4 = this.parseDeclaration(var1, var2, var3);
  1071.                   this.expect(135);
  1072.                   return var4;
  1073.                case 111:
  1074.                case 114:
  1075.                   return this.parseLocalClass(var2);
  1076.                default:
  1077.                   super.env.error(super.pos, "type.expected");
  1078.                   throw new SyntaxError();
  1079.             }
  1080.          case 135:
  1081.             return new CompoundStatement(this.scan(), new Statement[0]);
  1082.          case 138:
  1083.             return this.parseBlockStatement();
  1084.          default:
  1085.             int var24 = super.pos;
  1086.             Expression var36 = this.parseExpression();
  1087.             if (super.token == 60) {
  1088.                Statement var43 = this.parseDeclaration(var24, 0, var36);
  1089.                this.expect(135);
  1090.                return var43;
  1091.             } else if (super.token == 136) {
  1092.                this.scan();
  1093.                Statement var42 = this.parseStatement();
  1094.                var42.setLabel(super.env, var36);
  1095.                return var42;
  1096.             } else {
  1097.                this.topLevelExpression(var36);
  1098.                this.expect(135);
  1099.                return new ExpressionStatement(var24, var36);
  1100.             }
  1101.       }
  1102.    }
  1103.  
  1104.    protected Statement parseBlockStatement() throws SyntaxError, IOException {
  1105.       if (super.token != 138) {
  1106.          super.env.error(this.scanner.prevPos, "token.expected", Constants.opNames[138]);
  1107.          return this.parseStatement();
  1108.       } else {
  1109.          int var1 = this.scan();
  1110.          int var2 = this.argIndex;
  1111.  
  1112.          while(super.token != -1 && super.token != 139) {
  1113.             int var3 = this.argIndex;
  1114.  
  1115.             try {
  1116.                this.addArgument(this.parseStatement());
  1117.             } catch (SyntaxError var5) {
  1118.                this.argIndex = var3;
  1119.                if (!this.recoverStatement()) {
  1120.                   throw var5;
  1121.                }
  1122.             }
  1123.          }
  1124.  
  1125.          this.expect(139);
  1126.          return new CompoundStatement(var1, this.statArgs(var2));
  1127.       }
  1128.    }
  1129.  
  1130.    protected IdentifierToken parseName(boolean var1) throws SyntaxError, IOException {
  1131.       IdentifierToken var2 = this.scanner.getIdToken();
  1132.       this.expect(60);
  1133.       if (super.token != 46) {
  1134.          return var2;
  1135.       } else {
  1136.          StringBuffer var3;
  1137.          for(var3 = new StringBuffer(var2.id.toString()); super.token == 46; this.expect(60)) {
  1138.             this.scan();
  1139.             if (super.token == 33 && var1) {
  1140.                this.scan();
  1141.                var3.append(".*");
  1142.                break;
  1143.             }
  1144.  
  1145.             var3.append('.');
  1146.             if (super.token == 60) {
  1147.                var3.append(this.scanner.idValue);
  1148.             }
  1149.          }
  1150.  
  1151.          var2.id = Identifier.lookup(var3.toString());
  1152.          return var2;
  1153.       }
  1154.    }
  1155.  
  1156.    protected Identifier parseIdentifier(boolean var1) throws SyntaxError, IOException {
  1157.       return this.parseName(var1).id;
  1158.    }
  1159.  
  1160.    protected Type parseType() throws SyntaxError, IOException {
  1161.       Type var1;
  1162.       switch (super.token) {
  1163.          case 60:
  1164.             var1 = Type.tClass(this.parseName(false).id);
  1165.             break;
  1166.          case 70:
  1167.             this.scan();
  1168.             var1 = Type.tByte;
  1169.             break;
  1170.          case 71:
  1171.             this.scan();
  1172.             var1 = Type.tChar;
  1173.             break;
  1174.          case 72:
  1175.             this.scan();
  1176.             var1 = Type.tShort;
  1177.             break;
  1178.          case 73:
  1179.             this.scan();
  1180.             var1 = Type.tInt;
  1181.             break;
  1182.          case 74:
  1183.             this.scan();
  1184.             var1 = Type.tLong;
  1185.             break;
  1186.          case 75:
  1187.             this.scan();
  1188.             var1 = Type.tFloat;
  1189.             break;
  1190.          case 76:
  1191.             this.scan();
  1192.             var1 = Type.tDouble;
  1193.             break;
  1194.          case 77:
  1195.             this.scan();
  1196.             var1 = Type.tVoid;
  1197.             break;
  1198.          case 78:
  1199.             this.scan();
  1200.             var1 = Type.tBoolean;
  1201.             break;
  1202.          default:
  1203.             super.env.error(super.pos, "type.expected");
  1204.             throw new SyntaxError();
  1205.       }
  1206.  
  1207.       return this.parseArrayBrackets(var1);
  1208.    }
  1209.  
  1210.    protected Type parseArrayBrackets(Type var1) throws SyntaxError, IOException {
  1211.       while(super.token == 142) {
  1212.          this.scan();
  1213.          if (super.token != 143) {
  1214.             super.env.error(super.pos, "array.dim.in.decl");
  1215.             this.parseExpression();
  1216.          }
  1217.  
  1218.          this.expect(143);
  1219.          var1 = Type.tArray(var1);
  1220.       }
  1221.  
  1222.       return var1;
  1223.    }
  1224.  
  1225.    private void addArgument(int var1, Type var2, IdentifierToken var3) {
  1226.       var3.modifiers = var1;
  1227.       if (this.aCount >= this.aTypes.length) {
  1228.          Type[] var4 = new Type[this.aCount * 2];
  1229.          System.arraycopy(this.aTypes, 0, var4, 0, this.aCount);
  1230.          this.aTypes = var4;
  1231.          IdentifierToken[] var5 = new IdentifierToken[this.aCount * 2];
  1232.          System.arraycopy(this.aNames, 0, var5, 0, this.aCount);
  1233.          this.aNames = var5;
  1234.       }
  1235.  
  1236.       this.aTypes[this.aCount] = var2;
  1237.       this.aNames[this.aCount++] = var3;
  1238.    }
  1239.  
  1240.    protected int parseModifiers(int var1) throws IOException {
  1241.       int var2 = 0;
  1242.  
  1243.       while(true) {
  1244.          short var3 = 0;
  1245.          switch (super.token) {
  1246.             case 120:
  1247.                var3 = 2;
  1248.                break;
  1249.             case 121:
  1250.                var3 = 1;
  1251.                break;
  1252.             case 122:
  1253.                var3 = 4;
  1254.             case 123:
  1255.             default:
  1256.                break;
  1257.             case 124:
  1258.                var3 = 8;
  1259.                break;
  1260.             case 125:
  1261.                var3 = 128;
  1262.                break;
  1263.             case 126:
  1264.                var3 = 32;
  1265.                break;
  1266.             case 127:
  1267.                var3 = 256;
  1268.                break;
  1269.             case 128:
  1270.                var3 = 16;
  1271.                break;
  1272.             case 129:
  1273.                var3 = 64;
  1274.                break;
  1275.             case 130:
  1276.                var3 = 1024;
  1277.          }
  1278.  
  1279.          if ((var3 & var1) == 0) {
  1280.             return var2;
  1281.          }
  1282.  
  1283.          if ((var3 & var2) != 0) {
  1284.             super.env.error(super.pos, "repeated.modifier");
  1285.          }
  1286.  
  1287.          var2 |= var3;
  1288.          this.scan();
  1289.       }
  1290.    }
  1291.  
  1292.    protected void parseField() throws SyntaxError, IOException {
  1293.       if (super.token == 135) {
  1294.          this.scan();
  1295.       } else {
  1296.          String var1 = this.scanner.docComment;
  1297.          int var2 = super.pos;
  1298.          int var3 = this.parseModifiers(1535);
  1299.          if (var3 == (var3 & 8) && super.token == 138) {
  1300.             this.actions.defineField(var2, this.curClass, var1, var3, Type.tMethod(Type.tVoid), new IdentifierToken(Constants.idClassInit), (IdentifierToken[])null, (IdentifierToken[])null, this.parseStatement());
  1301.          } else if (super.token != 111 && super.token != 114) {
  1302.             var2 = super.pos;
  1303.             Type var4 = this.parseType();
  1304.             IdentifierToken var5 = null;
  1305.             switch (super.token) {
  1306.                case 60:
  1307.                   var5 = this.scanner.getIdToken();
  1308.                   var2 = this.scan();
  1309.                   break;
  1310.                case 140:
  1311.                   var5 = new IdentifierToken(Constants.idInit);
  1312.                   break;
  1313.                default:
  1314.                   this.expect(60);
  1315.             }
  1316.  
  1317.             if (super.token == 140) {
  1318.                this.scan();
  1319.                this.aCount = 0;
  1320.                if (super.token != 141) {
  1321.                   int var14 = this.parseModifiers(16);
  1322.                   Type var17 = this.parseType();
  1323.                   IdentifierToken var8 = this.scanner.getIdToken();
  1324.                   this.expect(60);
  1325.                   var17 = this.parseArrayBrackets(var17);
  1326.                   this.addArgument(var14, var17, var8);
  1327.  
  1328.                   while(super.token == 0) {
  1329.                      this.scan();
  1330.                      var14 = this.parseModifiers(16);
  1331.                      var17 = this.parseType();
  1332.                      var8 = this.scanner.getIdToken();
  1333.                      this.expect(60);
  1334.                      var17 = this.parseArrayBrackets(var17);
  1335.                      this.addArgument(var14, var17, var8);
  1336.                   }
  1337.                }
  1338.  
  1339.                this.expect(141);
  1340.                var4 = this.parseArrayBrackets(var4);
  1341.                Type[] var16 = new Type[this.aCount];
  1342.                System.arraycopy(this.aTypes, 0, var16, 0, this.aCount);
  1343.                IdentifierToken[] var21 = new IdentifierToken[this.aCount];
  1344.                System.arraycopy(this.aNames, 0, var21, 0, this.aCount);
  1345.                var4 = Type.tMethod(var4, var16);
  1346.                IdentifierToken[] var23 = null;
  1347.                if (super.token == 144) {
  1348.                   Vector var9 = new Vector();
  1349.                   this.scan();
  1350.                   var9.addElement(this.parseName(false));
  1351.  
  1352.                   while(super.token == 0) {
  1353.                      this.scan();
  1354.                      var9.addElement(this.parseName(false));
  1355.                   }
  1356.  
  1357.                   var23 = new IdentifierToken[var9.size()];
  1358.                   var9.copyInto(var23);
  1359.                }
  1360.  
  1361.                switch (super.token) {
  1362.                   case 135:
  1363.                      this.scan();
  1364.                      this.actions.defineField(var2, this.curClass, var1, var3, var4, var5, var21, var23, (Node)null);
  1365.                      return;
  1366.                   case 138:
  1367.                      this.actions.defineField(var2, this.curClass, var1, var3, var4, var5, var21, var23, this.parseStatement());
  1368.                      return;
  1369.                   default:
  1370.                      if ((var3 & 1280) == 0) {
  1371.                         this.expect(138);
  1372.                      } else {
  1373.                         this.expect(135);
  1374.                      }
  1375.                }
  1376.             } else {
  1377.                while(true) {
  1378.                   var2 = super.pos;
  1379.                   Type var6 = this.parseArrayBrackets(var4);
  1380.                   Expression var7 = null;
  1381.                   if (super.token == 1) {
  1382.                      this.scan();
  1383.                      var7 = this.parseExpression();
  1384.                   }
  1385.  
  1386.                   this.actions.defineField(var2, this.curClass, var1, var3, var6, var5, (IdentifierToken[])null, (IdentifierToken[])null, var7);
  1387.                   if (super.token != 0) {
  1388.                      this.expect(135);
  1389.                      return;
  1390.                   }
  1391.  
  1392.                   this.scan();
  1393.                   var5 = this.scanner.getIdToken();
  1394.                   this.expect(60);
  1395.                }
  1396.             }
  1397.          } else {
  1398.             super.env.innerClassesUsed(var2);
  1399.             this.parseNamedClass(var3, 111, var1);
  1400.          }
  1401.       }
  1402.    }
  1403.  
  1404.    protected void recoverField(ClassDefinition var1) throws SyntaxError, IOException {
  1405.       while(true) {
  1406.          switch (super.token) {
  1407.             case -1:
  1408.             case 70:
  1409.             case 71:
  1410.             case 72:
  1411.             case 73:
  1412.             case 74:
  1413.             case 75:
  1414.             case 76:
  1415.             case 77:
  1416.             case 78:
  1417.             case 120:
  1418.             case 121:
  1419.             case 124:
  1420.             case 125:
  1421.             case 126:
  1422.             case 128:
  1423.                return;
  1424.             case 110:
  1425.             case 111:
  1426.             case 114:
  1427.             case 115:
  1428.             case 139:
  1429.                this.actions.endClass(super.pos, var1);
  1430.                throw new SyntaxError();
  1431.             case 138:
  1432.                this.match(138, 139);
  1433.                this.scan();
  1434.                break;
  1435.             case 140:
  1436.                this.match(140, 141);
  1437.                this.scan();
  1438.                break;
  1439.             case 142:
  1440.                this.match(142, 143);
  1441.                this.scan();
  1442.                break;
  1443.             default:
  1444.                this.scan();
  1445.          }
  1446.       }
  1447.    }
  1448.  
  1449.    protected void parseClass() throws SyntaxError, IOException {
  1450.       String var1 = this.scanner.docComment;
  1451.       int var2 = this.parseModifiers(1599);
  1452.       this.parseNamedClass(var2, 115, var1);
  1453.    }
  1454.  
  1455.    protected Statement parseLocalClass(int var1) throws SyntaxError, IOException {
  1456.       int var2 = super.pos;
  1457.       super.env.innerClassesUsed(var2);
  1458.       ClassDefinition var3 = this.parseNamedClass(131072 | var1, 105, (String)null);
  1459.       Statement[] var4 = new Statement[]{new VarDeclarationStatement(var2, new LocalField(var3), (Expression)null)};
  1460.       TypeExpression var5 = new TypeExpression(var2, var3.getType());
  1461.       return new DeclarationStatement(var2, 0, var5, var4);
  1462.    }
  1463.  
  1464.    protected ClassDefinition parseNamedClass(int var1, int var2, String var3) throws SyntaxError, IOException {
  1465.       switch (super.token) {
  1466.          case 111:
  1467.             this.scan();
  1468.             break;
  1469.          case 114:
  1470.             this.scan();
  1471.             var1 |= 512;
  1472.             break;
  1473.          default:
  1474.             super.env.error(super.pos, "class.expected");
  1475.       }
  1476.  
  1477.       IdentifierToken var4 = this.scanner.getIdToken();
  1478.       int var5 = super.pos;
  1479.       this.expect(60);
  1480.       Vector var6 = new Vector();
  1481.       Vector var7 = new Vector();
  1482.       this.parseInheritance(var6, var7);
  1483.       return this.parseClassBody(var4, var1, var2, var3, var6, var7, var5);
  1484.    }
  1485.  
  1486.    protected void parseInheritance(Vector var1, Vector var2) throws SyntaxError, IOException {
  1487.       if (super.token == 112) {
  1488.          this.scan();
  1489.          var1.addElement(this.parseName(false));
  1490.  
  1491.          while(super.token == 0) {
  1492.             this.scan();
  1493.             var1.addElement(this.parseName(false));
  1494.          }
  1495.       }
  1496.  
  1497.       if (super.token == 113) {
  1498.          this.scan();
  1499.          var2.addElement(this.parseName(false));
  1500.  
  1501.          while(super.token == 0) {
  1502.             this.scan();
  1503.             var2.addElement(this.parseName(false));
  1504.          }
  1505.       }
  1506.  
  1507.    }
  1508.  
  1509.    protected ClassDefinition parseClassBody(IdentifierToken var1, int var2, int var3, String var4, Vector var5, Vector var6, int var7) throws SyntaxError, IOException {
  1510.       IdentifierToken var8 = null;
  1511.       if ((var2 & 512) != 0) {
  1512.          if (var6.size() > 0) {
  1513.             super.env.error(((IdentifierToken)var6.elementAt(0)).getWhere(), "intf.impl.intf");
  1514.          }
  1515.  
  1516.          var6 = var5;
  1517.       } else if (var5.size() > 0) {
  1518.          if (var5.size() > 1) {
  1519.             super.env.error(((IdentifierToken)var5.elementAt(1)).getWhere(), "multiple.inherit");
  1520.          }
  1521.  
  1522.          var8 = (IdentifierToken)var5.elementAt(0);
  1523.       }
  1524.  
  1525.       ClassDefinition var9 = this.curClass;
  1526.       IdentifierToken[] var10 = new IdentifierToken[var6.size()];
  1527.       var6.copyInto(var10);
  1528.       ClassDefinition var11 = this.actions.beginClass(var7, var4, var2, var1, var8, var10);
  1529.       this.expect(138);
  1530.  
  1531.       while(super.token != -1 && super.token != 139) {
  1532.          try {
  1533.             this.curClass = var11;
  1534.             this.parseField();
  1535.          } catch (SyntaxError var16) {
  1536.             this.recoverField(var11);
  1537.          } finally {
  1538.             this.curClass = var9;
  1539.          }
  1540.       }
  1541.  
  1542.       this.expect(139);
  1543.       this.actions.endClass(this.scanner.prevPos, var11);
  1544.       return var11;
  1545.    }
  1546.  
  1547.    protected void recoverFile() throws IOException {
  1548.       while(true) {
  1549.          switch (super.token) {
  1550.             case -1:
  1551.                return;
  1552.             case 111:
  1553.             case 114:
  1554.                return;
  1555.             case 138:
  1556.                this.match(138, 139);
  1557.                this.scan();
  1558.                break;
  1559.             case 140:
  1560.                this.match(140, 141);
  1561.                this.scan();
  1562.                break;
  1563.             case 142:
  1564.                this.match(142, 143);
  1565.                this.scan();
  1566.                break;
  1567.             default:
  1568.                this.scan();
  1569.          }
  1570.       }
  1571.    }
  1572.  
  1573.    public void parseFile() {
  1574.       try {
  1575.          try {
  1576.             if (super.token == 115) {
  1577.                int var1 = this.scan();
  1578.                IdentifierToken var2 = this.parseName(false);
  1579.                this.expect(135);
  1580.                this.actions.packageDeclaration(var1, var2);
  1581.             }
  1582.          } catch (SyntaxError var5) {
  1583.             this.recoverFile();
  1584.          }
  1585.  
  1586.          while(super.token == 110) {
  1587.             try {
  1588.                int var7 = this.scan();
  1589.                IdentifierToken var8 = this.parseName(true);
  1590.                this.expect(135);
  1591.                if (var8.id.getName().equals(Constants.idStar)) {
  1592.                   var8.id = var8.id.getQualifier();
  1593.                   this.actions.importPackage(var7, var8);
  1594.                } else {
  1595.                   this.actions.importClass(var7, var8);
  1596.                }
  1597.             } catch (SyntaxError var4) {
  1598.                this.recoverFile();
  1599.             }
  1600.          }
  1601.  
  1602.          while(super.token != -1) {
  1603.             try {
  1604.                switch (super.token) {
  1605.                   case -1:
  1606.                      return;
  1607.                   case 111:
  1608.                   case 114:
  1609.                   case 120:
  1610.                   case 121:
  1611.                   case 128:
  1612.                   case 130:
  1613.                      this.parseClass();
  1614.                      break;
  1615.                   case 135:
  1616.                      this.scan();
  1617.                      break;
  1618.                   default:
  1619.                      super.env.error(super.pos, "toplevel.expected");
  1620.                      throw new SyntaxError();
  1621.                }
  1622.             } catch (SyntaxError var3) {
  1623.                this.recoverFile();
  1624.             }
  1625.          }
  1626.  
  1627.       } catch (IOException var6) {
  1628.          super.env.error(super.pos, "io.exception", super.env.getSource());
  1629.       }
  1630.    }
  1631.  
  1632.    public int scan() throws IOException {
  1633.       if (this.scanner != this && this.scanner != null) {
  1634.          int var1 = this.scanner.scan();
  1635.          super.token = this.scanner.token;
  1636.          super.pos = this.scanner.pos;
  1637.          return var1;
  1638.       } else {
  1639.          return super.scan();
  1640.       }
  1641.    }
  1642.  
  1643.    public void match(int var1, int var2) throws IOException {
  1644.       if (this.scanner != this) {
  1645.          this.scanner.match(var1, var2);
  1646.          super.token = this.scanner.token;
  1647.          super.pos = this.scanner.pos;
  1648.       } else {
  1649.          super.match(var1, var2);
  1650.       }
  1651.    }
  1652. }
  1653.