Commits

ph...@d4b077e3-5828-0410-b394-cb2b42183085  committed ce6d68a

Committing original 2.6.9 CVS checkout.

  • Participants
  • Parent commits 60d76ef
  • Branches ognl_2-6-9

Comments (0)

Files changed (190)

File build/java/ognl/ASTAdd.class

Binary file added.

File build/java/ognl/ASTAnd.class

Binary file added.

File build/java/ognl/ASTAssign.class

Binary file added.

File build/java/ognl/ASTBitAnd.class

Binary file added.

File build/java/ognl/ASTBitNegate.class

Binary file added.

File build/java/ognl/ASTBitOr.class

Binary file added.

File build/java/ognl/ASTChain.class

Binary file added.

File build/java/ognl/ASTConst.class

Binary file added.

File build/java/ognl/ASTCtor.class

Binary file added.

File build/java/ognl/ASTDivide.class

Binary file added.

File build/java/ognl/ASTEq.class

Binary file added.

File build/java/ognl/ASTEval.class

Binary file added.

File build/java/ognl/ASTGreater.class

Binary file added.

File build/java/ognl/ASTGreaterEq.class

Binary file added.

File build/java/ognl/ASTIn.class

Binary file added.

File build/java/ognl/ASTInstanceof.class

Binary file added.

File build/java/ognl/ASTKeyValue.class

Binary file added.

File build/java/ognl/ASTLess.class

Binary file added.

File build/java/ognl/ASTLessEq.class

Binary file added.

File build/java/ognl/ASTList.class

Binary file added.

File build/java/ognl/ASTMap.class

Binary file added.

File build/java/ognl/ASTMethod.class

Binary file added.

File build/java/ognl/ASTMultiply.class

Binary file added.

File build/java/ognl/ASTNegate.class

Binary file added.

File build/java/ognl/ASTNot.class

Binary file added.

File build/java/ognl/ASTNotEq.class

Binary file added.

File build/java/ognl/ASTNotIn.class

Binary file added.

File build/java/ognl/ASTOr.class

Binary file added.

File build/java/ognl/ASTProject.class

Binary file added.

File build/java/ognl/ASTProperty.class

Binary file added.

File build/java/ognl/ASTRemainder.class

Binary file added.

File build/java/ognl/ASTRootVarRef.class

Binary file added.

File build/java/ognl/ASTSelect.class

Binary file added.

File build/java/ognl/ASTSelectFirst.class

Binary file added.

File build/java/ognl/ASTSelectLast.class

Binary file added.

File build/java/ognl/ASTSequence.class

Binary file added.

File build/java/ognl/ASTShiftLeft.class

Binary file added.

File build/java/ognl/ASTShiftRight.class

Binary file added.

File build/java/ognl/ASTStaticField.class

Binary file added.

File build/java/ognl/ASTStaticMethod.class

Binary file added.

File build/java/ognl/ASTSubtract.class

Binary file added.

File build/java/ognl/ASTTest.class

Binary file added.

File build/java/ognl/ASTThisVarRef.class

Binary file added.

File build/java/ognl/ASTUnsignedShiftRight.class

Binary file added.

File build/java/ognl/ASTVarRef.class

Binary file added.

File build/java/ognl/ASTXor.class

Binary file added.

File build/java/ognl/ArrayElementsAccessor$1.class

Binary file added.

File build/java/ognl/ArrayElementsAccessor.class

Binary file added.

File build/java/ognl/ArrayPropertyAccessor.class

Binary file added.

File build/java/ognl/ClassResolver.class

Binary file added.

File build/java/ognl/CollectionElementsAccessor.class

Binary file added.

File build/java/ognl/DefaultClassResolver.class

Binary file added.

File build/java/ognl/DefaultMemberAccess.class

Binary file added.

File build/java/ognl/DefaultTypeConverter.class

Binary file added.

File build/java/ognl/DynamicSubscript.class

Binary file added.

File build/java/ognl/ElementsAccessor.class

Binary file added.

File build/java/ognl/EnumerationElementsAccessor.class

Binary file added.

File build/java/ognl/EnumerationIterator.class

Binary file added.

File build/java/ognl/EnumerationPropertyAccessor.class

Binary file added.

File build/java/ognl/Evaluation.class

Binary file added.

File build/java/ognl/EvaluationPool.class

Binary file added.

File build/java/ognl/ExpressionNode.class

Binary file added.

File build/java/ognl/ExpressionSyntaxException.class

Binary file added.

File build/java/ognl/InappropriateExpressionException.class

Binary file added.

File build/java/ognl/IntHashMap$Entry.class

Binary file added.

File build/java/ognl/IntHashMap$IntHashMapIterator.class

Binary file added.

File build/java/ognl/IntHashMap.class

Binary file added.

File build/java/ognl/IteratorElementsAccessor.class

Binary file added.

File build/java/ognl/IteratorEnumeration.class

Binary file added.

File build/java/ognl/IteratorPropertyAccessor.class

Binary file added.

File build/java/ognl/JJTOgnlParserState.class

Binary file added.

File build/java/ognl/JavaCharStream.class

Binary file added.

File build/java/ognl/ListPropertyAccessor.class

Binary file added.

File build/java/ognl/MapElementsAccessor.class

Binary file added.

File build/java/ognl/MapPropertyAccessor.class

Binary file added.

File build/java/ognl/MemberAccess.class

Binary file added.

File build/java/ognl/MethodAccessor.class

Binary file added.

File build/java/ognl/MethodFailedException.class

Binary file added.

File build/java/ognl/NoSuchPropertyException.class

Binary file added.

File build/java/ognl/Node.class

Binary file added.

File build/java/ognl/NullHandler.class

Binary file added.

File build/java/ognl/NumberElementsAccessor$1.class

Binary file added.

File build/java/ognl/NumberElementsAccessor.class

Binary file added.

File build/java/ognl/NumericTypes.class

Binary file added.

File build/java/ognl/ObjectArrayPool$SizePool.class

Binary file added.

File build/java/ognl/ObjectArrayPool.class

Binary file added.

File build/java/ognl/ObjectElementsAccessor$1.class

Binary file added.

File build/java/ognl/ObjectElementsAccessor.class

Binary file added.

File build/java/ognl/ObjectIndexedPropertyDescriptor.class

Binary file added.

File build/java/ognl/ObjectMethodAccessor.class

Binary file added.

File build/java/ognl/ObjectNullHandler.class

Binary file added.

File build/java/ognl/ObjectPropertyAccessor.class

Binary file added.

File build/java/ognl/Ognl.class

Binary file added.

File build/java/ognl/OgnlContext.class

Binary file added.

File build/java/ognl/OgnlException.class

Binary file added.

File build/java/ognl/OgnlInvokePermission.class

Binary file added.

File build/java/ognl/OgnlOps.class

Binary file added.

File build/java/ognl/OgnlParser$JJCalls.class

Binary file added.

File build/java/ognl/OgnlParser$LookaheadSuccess.class

Binary file added.

File build/java/ognl/OgnlParser.class

Binary file added.

File build/java/ognl/OgnlParserConstants.class

Binary file added.

File build/java/ognl/OgnlParserTokenManager.class

Binary file added.

File build/java/ognl/OgnlParserTreeConstants.class

Binary file added.

File build/java/ognl/OgnlRuntime$ClassCache$Entry.class

Binary file added.

File build/java/ognl/OgnlRuntime$ClassCache.class

Binary file added.

File build/java/ognl/OgnlRuntime.class

Binary file added.

File build/java/ognl/ParseException.class

Binary file added.

File build/java/ognl/PropertyAccessor.class

Binary file added.

File build/java/ognl/SetPropertyAccessor.class

Binary file added.

File build/java/ognl/SimpleNode.class

Binary file added.

File build/java/ognl/Token.class

Binary file added.

File build/java/ognl/TokenMgrError.class

Binary file added.

File build/java/ognl/TypeConverter.class

Binary file added.

File build/java/ognl/ognl.jj

+/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. src/java/ognl\ognl.jj */
+/*@egen*///--------------------------------------------------------------------------
+//	Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
+//  All rights reserved.
+//
+//	Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are
+//  met:
+//
+//	Redistributions of source code must retain the above copyright notice,
+//  this list of conditions and the following disclaimer.
+//	Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+//	Neither the name of the Drew Davidson nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+//
+//	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+//  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+//  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+//  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+//  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+//  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+//  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+//  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+//  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+//  DAMAGE.
+//--------------------------------------------------------------------------
+
+/*
+ * This file defines the syntax of OGNL, the Object-Graph Navigation Language.  This
+ * language was devised by Drew Davidson, who called it Key-Value Coding Language.  Luke
+ * Blanshard then made up the new name and reimplemented it using ANTLR, refining and
+ * polishing the language a bit on the way.  Drew maintained the system for a couple of
+ * years; then Luke converted the ANTLR grammar to JavaCC, to eliminate the run-time
+ * dependency on ANTLR.
+ *
+ * See package.html for a description of the language.
+ */
+
+options {
+      // Parser options
+    LOOKAHEAD           = 1;
+    STATIC              = false;
+    JAVA_UNICODE_ESCAPE = true;
+    UNICODE_INPUT       = true;                                                                                       
+}
+
+PARSER_BEGIN(OgnlParser)
+
+package ognl;
+
+import java.math.*;
+
+/**
+ * OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract
+ * syntax trees (ASTs) that can then be interpreted by the getValue and setValue methods.
+ */
+public class OgnlParser/*@bgen(jjtree)*/implements OgnlParserTreeConstants/*@egen*/
+{/*@bgen(jjtree)*/
+  protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
+
+/*@egen*/
+}
+
+PARSER_END(OgnlParser)
+
+
+
+
+/**
+ * This is the top-level construct of OGNL.
+ */
+Node topLevelExpression() : {}
+{
+    expression() <EOF> { return jjtree.rootNode(); }
+}
+
+// sequence (level 14)
+void expression() : {}
+{
+    assignmentExpression() ( ","/*@bgen(jjtree) #Sequence( 2) */
+                                 {
+                                   ASTSequence jjtn001 = new ASTSequence(JJTSEQUENCE);
+                                   boolean jjtc001 = true;
+                                   jjtree.openNodeScope(jjtn001);
+                                 }
+                                 try {
+/*@egen*/ assignmentExpression()/*@bgen(jjtree)*/
+                                 } catch (Throwable jjte001) {
+                                   if (jjtc001) {
+                                     jjtree.clearNodeScope(jjtn001);
+                                     jjtc001 = false;
+                                   } else {
+                                     jjtree.popNode();
+                                   }
+                                   if (jjte001 instanceof RuntimeException) {
+                                     throw (RuntimeException)jjte001;
+                                   }
+                                   if (jjte001 instanceof ParseException) {
+                                     throw (ParseException)jjte001;
+                                   }
+                                   throw (Error)jjte001;
+                                 } finally {
+                                   if (jjtc001) {
+                                     jjtree.closeNodeScope(jjtn001,  2);
+                                   }
+                                 }
+/*@egen*/ )*
+}
+
+// assignment expression (level 13)
+void assignmentExpression() : {}
+{
+    conditionalTestExpression() [ "="/*@bgen(jjtree) #Assign( 2) */
+                                      {
+                                        ASTAssign jjtn001 = new ASTAssign(JJTASSIGN);
+                                        boolean jjtc001 = true;
+                                        jjtree.openNodeScope(jjtn001);
+                                      }
+                                      try {
+/*@egen*/ assignmentExpression()/*@bgen(jjtree)*/
+                                      } catch (Throwable jjte001) {
+                                        if (jjtc001) {
+                                          jjtree.clearNodeScope(jjtn001);
+                                          jjtc001 = false;
+                                        } else {
+                                          jjtree.popNode();
+                                        }
+                                        if (jjte001 instanceof RuntimeException) {
+                                          throw (RuntimeException)jjte001;
+                                        }
+                                        if (jjte001 instanceof ParseException) {
+                                          throw (ParseException)jjte001;
+                                        }
+                                        throw (Error)jjte001;
+                                      } finally {
+                                        if (jjtc001) {
+                                          jjtree.closeNodeScope(jjtn001,  2);
+                                        }
+                                      }
+/*@egen*/ ]
+}
+
+// conditional test (level 12)
+void conditionalTestExpression() : {}
+{
+    logicalOrExpression()
+        [ "?" conditionalTestExpression() ":"/*@bgen(jjtree) #Test( 3) */
+                                              {
+                                                ASTTest jjtn001 = new ASTTest(JJTTEST);
+                                                boolean jjtc001 = true;
+                                                jjtree.openNodeScope(jjtn001);
+                                              }
+                                              try {
+/*@egen*/ conditionalTestExpression()/*@bgen(jjtree)*/
+                                              } catch (Throwable jjte001) {
+                                                if (jjtc001) {
+                                                  jjtree.clearNodeScope(jjtn001);
+                                                  jjtc001 = false;
+                                                } else {
+                                                  jjtree.popNode();
+                                                }
+                                                if (jjte001 instanceof RuntimeException) {
+                                                  throw (RuntimeException)jjte001;
+                                                }
+                                                if (jjte001 instanceof ParseException) {
+                                                  throw (ParseException)jjte001;
+                                                }
+                                                throw (Error)jjte001;
+                                              } finally {
+                                                if (jjtc001) {
+                                                  jjtree.closeNodeScope(jjtn001,  3);
+                                                }
+                                              }
+/*@egen*/ ]
+}
+
+// logical or (||)  (level 11)
+void logicalOrExpression() : {}
+{
+    logicalAndExpression() (("||" | "or")/*@bgen(jjtree) #Or( 2) */
+                                          {
+                                            ASTOr jjtn001 = new ASTOr(JJTOR);
+                                            boolean jjtc001 = true;
+                                            jjtree.openNodeScope(jjtn001);
+                                          }
+                                          try {
+/*@egen*/ logicalAndExpression()/*@bgen(jjtree)*/
+                                          } catch (Throwable jjte001) {
+                                            if (jjtc001) {
+                                              jjtree.clearNodeScope(jjtn001);
+                                              jjtc001 = false;
+                                            } else {
+                                              jjtree.popNode();
+                                            }
+                                            if (jjte001 instanceof RuntimeException) {
+                                              throw (RuntimeException)jjte001;
+                                            }
+                                            if (jjte001 instanceof ParseException) {
+                                              throw (ParseException)jjte001;
+                                            }
+                                            throw (Error)jjte001;
+                                          } finally {
+                                            if (jjtc001) {
+                                              jjtree.closeNodeScope(jjtn001,  2);
+                                            }
+                                          }
+/*@egen*/ )*
+}
+
+
+// logical and (&&)  (level 10)
+void logicalAndExpression() : {}
+{
+    inclusiveOrExpression() (("&&" | "and")/*@bgen(jjtree) #And( 2) */
+                                            {
+                                              ASTAnd jjtn001 = new ASTAnd(JJTAND);
+                                              boolean jjtc001 = true;
+                                              jjtree.openNodeScope(jjtn001);
+                                            }
+                                            try {
+/*@egen*/ inclusiveOrExpression()/*@bgen(jjtree)*/
+                                            } catch (Throwable jjte001) {
+                                              if (jjtc001) {
+                                                jjtree.clearNodeScope(jjtn001);
+                                                jjtc001 = false;
+                                              } else {
+                                                jjtree.popNode();
+                                              }
+                                              if (jjte001 instanceof RuntimeException) {
+                                                throw (RuntimeException)jjte001;
+                                              }
+                                              if (jjte001 instanceof ParseException) {
+                                                throw (ParseException)jjte001;
+                                              }
+                                              throw (Error)jjte001;
+                                            } finally {
+                                              if (jjtc001) {
+                                                jjtree.closeNodeScope(jjtn001,  2);
+                                              }
+                                            }
+/*@egen*/ )*
+}
+
+
+// bitwise or non-short-circuiting or (|)  (level 9)
+void inclusiveOrExpression() : {}
+{
+    exclusiveOrExpression() (("|" | "bor")/*@bgen(jjtree) #BitOr( 2) */
+                                           {
+                                             ASTBitOr jjtn001 = new ASTBitOr(JJTBITOR);
+                                             boolean jjtc001 = true;
+                                             jjtree.openNodeScope(jjtn001);
+                                           }
+                                           try {
+/*@egen*/ exclusiveOrExpression()/*@bgen(jjtree)*/
+                                           } catch (Throwable jjte001) {
+                                             if (jjtc001) {
+                                               jjtree.clearNodeScope(jjtn001);
+                                               jjtc001 = false;
+                                             } else {
+                                               jjtree.popNode();
+                                             }
+                                             if (jjte001 instanceof RuntimeException) {
+                                               throw (RuntimeException)jjte001;
+                                             }
+                                             if (jjte001 instanceof ParseException) {
+                                               throw (ParseException)jjte001;
+                                             }
+                                             throw (Error)jjte001;
+                                           } finally {
+                                             if (jjtc001) {
+                                               jjtree.closeNodeScope(jjtn001,  2);
+                                             }
+                                           }
+/*@egen*/ )*
+}
+
+
+// exclusive or (^)  (level 8)
+void exclusiveOrExpression() : {}
+{
+    andExpression() (("^" | "xor")/*@bgen(jjtree) #Xor( 2) */
+                                   {
+                                     ASTXor jjtn001 = new ASTXor(JJTXOR);
+                                     boolean jjtc001 = true;
+                                     jjtree.openNodeScope(jjtn001);
+                                   }
+                                   try {
+/*@egen*/ andExpression()/*@bgen(jjtree)*/
+                                   } catch (Throwable jjte001) {
+                                     if (jjtc001) {
+                                       jjtree.clearNodeScope(jjtn001);
+                                       jjtc001 = false;
+                                     } else {
+                                       jjtree.popNode();
+                                     }
+                                     if (jjte001 instanceof RuntimeException) {
+                                       throw (RuntimeException)jjte001;
+                                     }
+                                     if (jjte001 instanceof ParseException) {
+                                       throw (ParseException)jjte001;
+                                     }
+                                     throw (Error)jjte001;
+                                   } finally {
+                                     if (jjtc001) {
+                                       jjtree.closeNodeScope(jjtn001,  2);
+                                     }
+                                   }
+/*@egen*/ )*
+}
+
+
+// bitwise or non-short-circuiting and (&)  (level 7)
+void andExpression() : {}
+{
+    equalityExpression() (("&" | "band")/*@bgen(jjtree) #BitAnd( 2) */
+                                         {
+                                           ASTBitAnd jjtn001 = new ASTBitAnd(JJTBITAND);
+                                           boolean jjtc001 = true;
+                                           jjtree.openNodeScope(jjtn001);
+                                         }
+                                         try {
+/*@egen*/ equalityExpression()/*@bgen(jjtree)*/
+                                         } catch (Throwable jjte001) {
+                                           if (jjtc001) {
+                                             jjtree.clearNodeScope(jjtn001);
+                                             jjtc001 = false;
+                                           } else {
+                                             jjtree.popNode();
+                                           }
+                                           if (jjte001 instanceof RuntimeException) {
+                                             throw (RuntimeException)jjte001;
+                                           }
+                                           if (jjte001 instanceof ParseException) {
+                                             throw (ParseException)jjte001;
+                                           }
+                                           throw (Error)jjte001;
+                                         } finally {
+                                           if (jjtc001) {
+                                             jjtree.closeNodeScope(jjtn001,  2);
+                                           }
+                                         }
+/*@egen*/ )*
+}
+
+
+// equality/inequality (==/!=) (level 6)
+void equalityExpression() : {}
+{
+    relationalExpression()
+    (
+        ("==" | "eq")/*@bgen(jjtree) #Eq( 2) */
+                      {
+                        ASTEq jjtn001 = new ASTEq(JJTEQ);
+                        boolean jjtc001 = true;
+                        jjtree.openNodeScope(jjtn001);
+                      }
+                      try {
+/*@egen*/ relationalExpression()/*@bgen(jjtree)*/
+                      } catch (Throwable jjte001) {
+                        if (jjtc001) {
+                          jjtree.clearNodeScope(jjtn001);
+                          jjtc001 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte001 instanceof RuntimeException) {
+                          throw (RuntimeException)jjte001;
+                        }
+                        if (jjte001 instanceof ParseException) {
+                          throw (ParseException)jjte001;
+                        }
+                        throw (Error)jjte001;
+                      } finally {
+                        if (jjtc001) {
+                          jjtree.closeNodeScope(jjtn001,  2);
+                        }
+                      }
+/*@egen*/
+     |
+        ("!=" | "neq")/*@bgen(jjtree) #NotEq( 2) */
+                       {
+                         ASTNotEq jjtn002 = new ASTNotEq(JJTNOTEQ);
+                         boolean jjtc002 = true;
+                         jjtree.openNodeScope(jjtn002);
+                       }
+                       try {
+/*@egen*/ relationalExpression()/*@bgen(jjtree)*/
+                       } catch (Throwable jjte002) {
+                         if (jjtc002) {
+                           jjtree.clearNodeScope(jjtn002);
+                           jjtc002 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte002 instanceof RuntimeException) {
+                           throw (RuntimeException)jjte002;
+                         }
+                         if (jjte002 instanceof ParseException) {
+                           throw (ParseException)jjte002;
+                         }
+                         throw (Error)jjte002;
+                       } finally {
+                         if (jjtc002) {
+                           jjtree.closeNodeScope(jjtn002,  2);
+                         }
+                       }
+/*@egen*/
+    )*
+}
+
+
+// boolean relational expressions (level 5)
+void relationalExpression() : {}
+{
+    shiftExpression()
+    (
+        ("<" | "lt")/*@bgen(jjtree) #Less( 2) */
+                     {
+                       ASTLess jjtn001 = new ASTLess(JJTLESS);
+                       boolean jjtc001 = true;
+                       jjtree.openNodeScope(jjtn001);
+                     }
+                     try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+                     } catch (Throwable jjte001) {
+                       if (jjtc001) {
+                         jjtree.clearNodeScope(jjtn001);
+                         jjtc001 = false;
+                       } else {
+                         jjtree.popNode();
+                       }
+                       if (jjte001 instanceof RuntimeException) {
+                         throw (RuntimeException)jjte001;
+                       }
+                       if (jjte001 instanceof ParseException) {
+                         throw (ParseException)jjte001;
+                       }
+                       throw (Error)jjte001;
+                     } finally {
+                       if (jjtc001) {
+                         jjtree.closeNodeScope(jjtn001,  2);
+                       }
+                     }
+/*@egen*/
+     |
+        (">" | "gt")/*@bgen(jjtree) #Greater( 2) */
+                     {
+                       ASTGreater jjtn002 = new ASTGreater(JJTGREATER);
+                       boolean jjtc002 = true;
+                       jjtree.openNodeScope(jjtn002);
+                     }
+                     try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+                     } catch (Throwable jjte002) {
+                       if (jjtc002) {
+                         jjtree.clearNodeScope(jjtn002);
+                         jjtc002 = false;
+                       } else {
+                         jjtree.popNode();
+                       }
+                       if (jjte002 instanceof RuntimeException) {
+                         throw (RuntimeException)jjte002;
+                       }
+                       if (jjte002 instanceof ParseException) {
+                         throw (ParseException)jjte002;
+                       }
+                       throw (Error)jjte002;
+                     } finally {
+                       if (jjtc002) {
+                         jjtree.closeNodeScope(jjtn002,  2);
+                       }
+                     }
+/*@egen*/
+     |
+        ("<=" | "lte")/*@bgen(jjtree) #LessEq( 2) */
+                       {
+                         ASTLessEq jjtn003 = new ASTLessEq(JJTLESSEQ);
+                         boolean jjtc003 = true;
+                         jjtree.openNodeScope(jjtn003);
+                       }
+                       try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+                       } catch (Throwable jjte003) {
+                         if (jjtc003) {
+                           jjtree.clearNodeScope(jjtn003);
+                           jjtc003 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte003 instanceof RuntimeException) {
+                           throw (RuntimeException)jjte003;
+                         }
+                         if (jjte003 instanceof ParseException) {
+                           throw (ParseException)jjte003;
+                         }
+                         throw (Error)jjte003;
+                       } finally {
+                         if (jjtc003) {
+                           jjtree.closeNodeScope(jjtn003,  2);
+                         }
+                       }
+/*@egen*/
+     |
+        (">=" | "gte")/*@bgen(jjtree) #GreaterEq( 2) */
+                       {
+                         ASTGreaterEq jjtn004 = new ASTGreaterEq(JJTGREATEREQ);
+                         boolean jjtc004 = true;
+                         jjtree.openNodeScope(jjtn004);
+                       }
+                       try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+                       } catch (Throwable jjte004) {
+                         if (jjtc004) {
+                           jjtree.clearNodeScope(jjtn004);
+                           jjtc004 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte004 instanceof RuntimeException) {
+                           throw (RuntimeException)jjte004;
+                         }
+                         if (jjte004 instanceof ParseException) {
+                           throw (ParseException)jjte004;
+                         }
+                         throw (Error)jjte004;
+                       } finally {
+                         if (jjtc004) {
+                           jjtree.closeNodeScope(jjtn004,  2);
+                         }
+                       }
+/*@egen*/
+     |
+        "in"/*@bgen(jjtree) #In( 2) */
+             {
+               ASTIn jjtn005 = new ASTIn(JJTIN);
+               boolean jjtc005 = true;
+               jjtree.openNodeScope(jjtn005);
+             }
+             try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+             } catch (Throwable jjte005) {
+               if (jjtc005) {
+                 jjtree.clearNodeScope(jjtn005);
+                 jjtc005 = false;
+               } else {
+                 jjtree.popNode();
+               }
+               if (jjte005 instanceof RuntimeException) {
+                 throw (RuntimeException)jjte005;
+               }
+               if (jjte005 instanceof ParseException) {
+                 throw (ParseException)jjte005;
+               }
+               throw (Error)jjte005;
+             } finally {
+               if (jjtc005) {
+                 jjtree.closeNodeScope(jjtn005,  2);
+               }
+             }
+/*@egen*/
+     |
+        "not" "in"/*@bgen(jjtree) #NotIn( 2) */
+                   {
+                     ASTNotIn jjtn006 = new ASTNotIn(JJTNOTIN);
+                     boolean jjtc006 = true;
+                     jjtree.openNodeScope(jjtn006);
+                   }
+                   try {
+/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
+                   } catch (Throwable jjte006) {
+                     if (jjtc006) {
+                       jjtree.clearNodeScope(jjtn006);
+                       jjtc006 = false;
+                     } else {
+                       jjtree.popNode();
+                     }
+                     if (jjte006 instanceof RuntimeException) {
+                       throw (RuntimeException)jjte006;
+                     }
+                     if (jjte006 instanceof ParseException) {
+                       throw (ParseException)jjte006;
+                     }
+                     throw (Error)jjte006;
+                   } finally {
+                     if (jjtc006) {
+                       jjtree.closeNodeScope(jjtn006,  2);
+                     }
+                   }
+/*@egen*/
+    )*
+}
+
+
+// bit shift expressions (level 4)
+void shiftExpression() : {}
+{
+    additiveExpression()
+    (
+        ("<<" | "shl")/*@bgen(jjtree) #ShiftLeft( 2) */
+                       {
+                         ASTShiftLeft jjtn001 = new ASTShiftLeft(JJTSHIFTLEFT);
+                         boolean jjtc001 = true;
+                         jjtree.openNodeScope(jjtn001);
+                       }
+                       try {
+/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
+                       } catch (Throwable jjte001) {
+                         if (jjtc001) {
+                           jjtree.clearNodeScope(jjtn001);
+                           jjtc001 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte001 instanceof RuntimeException) {
+                           throw (RuntimeException)jjte001;
+                         }
+                         if (jjte001 instanceof ParseException) {
+                           throw (ParseException)jjte001;
+                         }
+                         throw (Error)jjte001;
+                       } finally {
+                         if (jjtc001) {
+                           jjtree.closeNodeScope(jjtn001,  2);
+                         }
+                       }
+/*@egen*/
+     |
+        (">>" | "shr")/*@bgen(jjtree) #ShiftRight( 2) */
+                       {
+                         ASTShiftRight jjtn002 = new ASTShiftRight(JJTSHIFTRIGHT);
+                         boolean jjtc002 = true;
+                         jjtree.openNodeScope(jjtn002);
+                       }
+                       try {
+/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
+                       } catch (Throwable jjte002) {
+                         if (jjtc002) {
+                           jjtree.clearNodeScope(jjtn002);
+                           jjtc002 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte002 instanceof RuntimeException) {
+                           throw (RuntimeException)jjte002;
+                         }
+                         if (jjte002 instanceof ParseException) {
+                           throw (ParseException)jjte002;
+                         }
+                         throw (Error)jjte002;
+                       } finally {
+                         if (jjtc002) {
+                           jjtree.closeNodeScope(jjtn002,  2);
+                         }
+                       }
+/*@egen*/
+     |
+        (">>>" | "ushr")/*@bgen(jjtree) #UnsignedShiftRight( 2) */
+                         {
+                           ASTUnsignedShiftRight jjtn003 = new ASTUnsignedShiftRight(JJTUNSIGNEDSHIFTRIGHT);
+                           boolean jjtc003 = true;
+                           jjtree.openNodeScope(jjtn003);
+                         }
+                         try {
+/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
+                         } catch (Throwable jjte003) {
+                           if (jjtc003) {
+                             jjtree.clearNodeScope(jjtn003);
+                             jjtc003 = false;
+                           } else {
+                             jjtree.popNode();
+                           }
+                           if (jjte003 instanceof RuntimeException) {
+                             throw (RuntimeException)jjte003;
+                           }
+                           if (jjte003 instanceof ParseException) {
+                             throw (ParseException)jjte003;
+                           }
+                           throw (Error)jjte003;
+                         } finally {
+                           if (jjtc003) {
+                             jjtree.closeNodeScope(jjtn003,  2);
+                           }
+                         }
+/*@egen*/
+    )*
+}
+
+
+// binary addition/subtraction (level 3)
+void additiveExpression() : {}
+{
+    multiplicativeExpression()
+    (
+        "+"/*@bgen(jjtree) #Add( 2) */
+            {
+              ASTAdd jjtn001 = new ASTAdd(JJTADD);
+              boolean jjtc001 = true;
+              jjtree.openNodeScope(jjtn001);
+            }
+            try {
+/*@egen*/ multiplicativeExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte001) {
+              if (jjtc001) {
+                jjtree.clearNodeScope(jjtn001);
+                jjtc001 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte001 instanceof RuntimeException) {
+                throw (RuntimeException)jjte001;
+              }
+              if (jjte001 instanceof ParseException) {
+                throw (ParseException)jjte001;
+              }
+              throw (Error)jjte001;
+            } finally {
+              if (jjtc001) {
+                jjtree.closeNodeScope(jjtn001,  2);
+              }
+            }
+/*@egen*/
+     |
+        "-"/*@bgen(jjtree) #Subtract( 2) */
+            {
+              ASTSubtract jjtn002 = new ASTSubtract(JJTSUBTRACT);
+              boolean jjtc002 = true;
+              jjtree.openNodeScope(jjtn002);
+            }
+            try {
+/*@egen*/ multiplicativeExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte002) {
+              if (jjtc002) {
+                jjtree.clearNodeScope(jjtn002);
+                jjtc002 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte002 instanceof RuntimeException) {
+                throw (RuntimeException)jjte002;
+              }
+              if (jjte002 instanceof ParseException) {
+                throw (ParseException)jjte002;
+              }
+              throw (Error)jjte002;
+            } finally {
+              if (jjtc002) {
+                jjtree.closeNodeScope(jjtn002,  2);
+              }
+            }
+/*@egen*/
+    )*
+}
+
+
+// multiplication/division/remainder (level 2)
+void multiplicativeExpression() : {}
+{
+    unaryExpression()
+    (
+        "*"/*@bgen(jjtree) #Multiply( 2) */
+            {
+              ASTMultiply jjtn001 = new ASTMultiply(JJTMULTIPLY);
+              boolean jjtc001 = true;
+              jjtree.openNodeScope(jjtn001);
+            }
+            try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte001) {
+              if (jjtc001) {
+                jjtree.clearNodeScope(jjtn001);
+                jjtc001 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte001 instanceof RuntimeException) {
+                throw (RuntimeException)jjte001;
+              }
+              if (jjte001 instanceof ParseException) {
+                throw (ParseException)jjte001;
+              }
+              throw (Error)jjte001;
+            } finally {
+              if (jjtc001) {
+                jjtree.closeNodeScope(jjtn001,  2);
+              }
+            }
+/*@egen*/
+     |
+        "/"/*@bgen(jjtree) #Divide( 2) */
+            {
+              ASTDivide jjtn002 = new ASTDivide(JJTDIVIDE);
+              boolean jjtc002 = true;
+              jjtree.openNodeScope(jjtn002);
+            }
+            try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte002) {
+              if (jjtc002) {
+                jjtree.clearNodeScope(jjtn002);
+                jjtc002 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte002 instanceof RuntimeException) {
+                throw (RuntimeException)jjte002;
+              }
+              if (jjte002 instanceof ParseException) {
+                throw (ParseException)jjte002;
+              }
+              throw (Error)jjte002;
+            } finally {
+              if (jjtc002) {
+                jjtree.closeNodeScope(jjtn002,  2);
+              }
+            }
+/*@egen*/
+     |
+        "%"/*@bgen(jjtree) #Remainder( 2) */
+            {
+              ASTRemainder jjtn003 = new ASTRemainder(JJTREMAINDER);
+              boolean jjtc003 = true;
+              jjtree.openNodeScope(jjtn003);
+            }
+            try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte003) {
+              if (jjtc003) {
+                jjtree.clearNodeScope(jjtn003);
+                jjtc003 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte003 instanceof RuntimeException) {
+                throw (RuntimeException)jjte003;
+              }
+              if (jjte003 instanceof ParseException) {
+                throw (ParseException)jjte003;
+              }
+              throw (Error)jjte003;
+            } finally {
+              if (jjtc003) {
+                jjtree.closeNodeScope(jjtn003,  2);
+              }
+            }
+/*@egen*/
+    )*
+}
+
+// unary (level 1)
+void unaryExpression() : {
+    StringBuffer sb;
+    Token t;
+    ASTInstanceof ionode;
+}
+{
+    (
+        "-"/*@bgen(jjtree) #Negate( 1) */
+            {
+              ASTNegate jjtn001 = new ASTNegate(JJTNEGATE);
+              boolean jjtc001 = true;
+              jjtree.openNodeScope(jjtn001);
+            }
+            try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte001) {
+              if (jjtc001) {
+                jjtree.clearNodeScope(jjtn001);
+                jjtc001 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte001 instanceof RuntimeException) {
+                throw (RuntimeException)jjte001;
+              }
+              if (jjte001 instanceof ParseException) {
+                throw (ParseException)jjte001;
+              }
+              throw (Error)jjte001;
+            } finally {
+              if (jjtc001) {
+                jjtree.closeNodeScope(jjtn001,  1);
+              }
+            }
+/*@egen*/
+     |
+        "+" unaryExpression() // Just leave it there
+     |
+        "~"/*@bgen(jjtree) #BitNegate( 1) */
+            {
+              ASTBitNegate jjtn002 = new ASTBitNegate(JJTBITNEGATE);
+              boolean jjtc002 = true;
+              jjtree.openNodeScope(jjtn002);
+            }
+            try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+            } catch (Throwable jjte002) {
+              if (jjtc002) {
+                jjtree.clearNodeScope(jjtn002);
+                jjtc002 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte002 instanceof RuntimeException) {
+                throw (RuntimeException)jjte002;
+              }
+              if (jjte002 instanceof ParseException) {
+                throw (ParseException)jjte002;
+              }
+              throw (Error)jjte002;
+            } finally {
+              if (jjtc002) {
+                jjtree.closeNodeScope(jjtn002,  1);
+              }
+            }
+/*@egen*/
+     |
+        ("!" | "not")/*@bgen(jjtree) #Not( 1) */
+                      {
+                        ASTNot jjtn003 = new ASTNot(JJTNOT);
+                        boolean jjtc003 = true;
+                        jjtree.openNodeScope(jjtn003);
+                      }
+                      try {
+/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
+                      } catch (Throwable jjte003) {
+                        if (jjtc003) {
+                          jjtree.clearNodeScope(jjtn003);
+                          jjtc003 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte003 instanceof RuntimeException) {
+                          throw (RuntimeException)jjte003;
+                        }
+                        if (jjte003 instanceof ParseException) {
+                          throw (ParseException)jjte003;
+                        }
+                        throw (Error)jjte003;
+                      } finally {
+                        if (jjtc003) {
+                          jjtree.closeNodeScope(jjtn003,  1);
+                        }
+                      }
+/*@egen*/
+     |
+        navigationChain()
+        [
+            "instanceof"
+            t = <IDENT>/*@bgen(jjtree) #Instanceof( 1) */
+                         {
+                           ASTInstanceof jjtn004 = new ASTInstanceof(JJTINSTANCEOF);
+                           boolean jjtc004 = true;
+                           jjtree.openNodeScope(jjtn004);
+                         }
+                         try {
+/*@egen*//*@bgen(jjtree)*/
+                         {
+                           jjtree.closeNodeScope(jjtn004,  1);
+                           jjtc004 = false;
+                         }
+/*@egen*/  { sb = new StringBuffer(t.image); ionode = jjtn004; }/*@bgen(jjtree)*/
+                         } finally {
+                           if (jjtc004) {
+                             jjtree.closeNodeScope(jjtn004,  1);
+                           }
+                         }
+/*@egen*/
+            (   "." t = <IDENT>         { sb.append('.').append( t.image ); }
+            )*                          { ionode.setTargetType( new String(sb) ); }
+        ]
+    )
+}
+
+
+// navigation chain: property references, method calls, projections, selections, etc.
+void navigationChain() : {}
+{
+    primaryExpression()
+    (   "."/*@bgen(jjtree) #Chain( 2) */
+        {
+          ASTChain jjtn001 = new ASTChain(JJTCHAIN);
+          boolean jjtc001 = true;
+          jjtree.openNodeScope(jjtn001);
+        }
+        try {
+/*@egen*/
+        ( /* Prevent the "eval" ambiguity from issuing a warning; see discussion below. */
+            ( LOOKAHEAD(2) methodCall() | propertyName() )
+              // Also handle "{", which requires a lookahead of 2.
+        |   ( LOOKAHEAD(2) projection() | selection() )
+        |   "(" expression() ")"
+        )/*@bgen(jjtree)*/
+        } catch (Throwable jjte001) {
+          if (jjtc001) {
+            jjtree.clearNodeScope(jjtn001);
+            jjtc001 = false;
+          } else {
+            jjtree.popNode();
+          }
+          if (jjte001 instanceof RuntimeException) {
+            throw (RuntimeException)jjte001;
+          }
+          if (jjte001 instanceof ParseException) {
+            throw (ParseException)jjte001;
+          }
+          throw (Error)jjte001;
+        } finally {
+          if (jjtc001) {
+            jjtree.closeNodeScope(jjtn001,  2);
+          }
+        }
+/*@egen*/
+
+    |/*@bgen(jjtree) #Chain( 2) */
+        {
+          ASTChain jjtn002 = new ASTChain(JJTCHAIN);
+          boolean jjtc002 = true;
+          jjtree.openNodeScope(jjtn002);
+        }
+        try {
+/*@egen*/   index()/*@bgen(jjtree)*/
+        } catch (Throwable jjte002) {
+          if (jjtc002) {
+            jjtree.clearNodeScope(jjtn002);
+            jjtc002 = false;
+          } else {
+            jjtree.popNode();
+          }
+          if (jjte002 instanceof RuntimeException) {
+            throw (RuntimeException)jjte002;
+          }
+          if (jjte002 instanceof ParseException) {
+            throw (ParseException)jjte002;
+          }
+          throw (Error)jjte002;
+        } finally {
+          if (jjtc002) {
+            jjtree.closeNodeScope(jjtn002,  2);
+          }
+        }
+/*@egen*/
+
+    |   "(" expression()/*@bgen(jjtree) #Eval( 2) */
+                         {
+                           ASTEval jjtn003 = new ASTEval(JJTEVAL);
+                           boolean jjtc003 = true;
+                           jjtree.openNodeScope(jjtn003);
+                         }
+                         try {
+/*@egen*/ ")"/*@bgen(jjtree)*/
+                         } finally {
+                           if (jjtc003) {
+                             jjtree.closeNodeScope(jjtn003,  2);
+                           }
+                         }
+/*@egen*/
+
+            /* Using parentheses to indicate evaluation of the current
+               object makes this language ambiguous, because the
+               expression "ident(args)" could be seen as a single
+               method call or as a property name followed by an
+               evaluation.  We always put the method call first and
+               turn off the ambiguity warning; we always want to
+               interpret this as a method call. */
+
+    )*
+}
+
+
+void primaryExpression() : {
+    Token   t;
+    String  className = null;
+}
+{
+    (
+        (<CHAR_LITERAL> | <BACK_CHAR_LITERAL> | <STRING_LITERAL> | <INT_LITERAL> | <FLT_LITERAL>)/*@bgen(jjtree) #Const( 0) */
+                                                {
+                                                  ASTConst jjtn001 = new ASTConst(JJTCONST);
+                                                  boolean jjtc001 = true;
+                                                  jjtree.openNodeScope(jjtn001);
+                                                }
+                                                try {
+/*@egen*//*@bgen(jjtree)*/
+                                                {
+                                                  jjtree.closeNodeScope(jjtn001,  0);
+                                                  jjtc001 = false;
+                                                }
+/*@egen*/
+                                                { jjtn001.setValue( token_source.literalValue ); }/*@bgen(jjtree)*/
+                                                } finally {
+                                                  if (jjtc001) {
+                                                    jjtree.closeNodeScope(jjtn001,  0);
+                                                  }
+                                                }
+/*@egen*/
+     |
+        "true"/*@bgen(jjtree) #Const( 0) */
+                                                {
+                                                  ASTConst jjtn002 = new ASTConst(JJTCONST);
+                                                  boolean jjtc002 = true;
+                                                  jjtree.openNodeScope(jjtn002);
+                                                }
+                                                try {
+/*@egen*//*@bgen(jjtree)*/
+                                                {
+                                                  jjtree.closeNodeScope(jjtn002,  0);
+                                                  jjtc002 = false;
+                                                }
+/*@egen*/                                  { jjtn002.setValue( Boolean.TRUE ); }/*@bgen(jjtree)*/
+                                                } finally {
+                                                  if (jjtc002) {
+                                                    jjtree.closeNodeScope(jjtn002,  0);
+                                                  }
+                                                }
+/*@egen*/
+     |
+        "false"/*@bgen(jjtree) #Const( 0) */
+                                                {
+                                                  ASTConst jjtn003 = new ASTConst(JJTCONST);
+                                                  boolean jjtc003 = true;
+                                                  jjtree.openNodeScope(jjtn003);
+                                                }
+                                                try {
+/*@egen*//*@bgen(jjtree)*/
+                                                {
+                                                  jjtree.closeNodeScope(jjtn003,  0);
+                                                  jjtc003 = false;
+                                                }
+/*@egen*/                                 { jjtn003.setValue( Boolean.FALSE ); }/*@bgen(jjtree)*/
+                                                } finally {
+                                                  if (jjtc003) {
+                                                    jjtree.closeNodeScope(jjtn003,  0);
+                                                  }
+                                                }
+/*@egen*/
+     |/*@bgen(jjtree) #Const( 0) */
+        {
+          ASTConst jjtn004 = new ASTConst(JJTCONST);
+          boolean jjtc004 = true;
+          jjtree.openNodeScope(jjtn004);
+        }
+        try {
+/*@egen*/
+        "null"/*@bgen(jjtree)*/
+        } finally {
+          if (jjtc004) {
+            jjtree.closeNodeScope(jjtn004,  0);
+          }
+        }
+/*@egen*/                        // Null is the default value in an ASTConst
+     |
+        LOOKAHEAD(2) "#this"/*@bgen(jjtree) #ThisVarRef( 0) */
+                                             {
+                                               ASTThisVarRef jjtn005 = new ASTThisVarRef(JJTTHISVARREF);
+                                               boolean jjtc005 = true;
+                                               jjtree.openNodeScope(jjtn005);
+                                             }
+                                             try {
+/*@egen*//*@bgen(jjtree)*/
+                                             {
+                                               jjtree.closeNodeScope(jjtn005,  0);
+                                               jjtc005 = false;
+                                             }
+/*@egen*/                 { jjtn005.setName( "this" ); }/*@bgen(jjtree)*/
+                                             } finally {
+                                               if (jjtc005) {
+                                                 jjtree.closeNodeScope(jjtn005,  0);
+                                               }
+                                             }
+/*@egen*/
+     |
+        LOOKAHEAD(2) "#root"/*@bgen(jjtree) #RootVarRef( 0) */
+                                             {
+                                               ASTRootVarRef jjtn006 = new ASTRootVarRef(JJTROOTVARREF);
+                                               boolean jjtc006 = true;
+                                               jjtree.openNodeScope(jjtn006);
+                                             }
+                                             try {
+/*@egen*//*@bgen(jjtree)*/
+                                             {
+                                               jjtree.closeNodeScope(jjtn006,  0);
+                                               jjtc006 = false;
+                                             }
+/*@egen*/                 { jjtn006.setName( "root" ); }/*@bgen(jjtree)*/
+                                             } finally {
+                                               if (jjtc006) {
+                                                 jjtree.closeNodeScope(jjtn006,  0);
+                                               }
+                                             }
+/*@egen*/
+     |
+        LOOKAHEAD(2) "#" t=<IDENT>/*@bgen(jjtree) #VarRef( 0) */
+                                                {
+                                                  ASTVarRef jjtn007 = new ASTVarRef(JJTVARREF);
+                                                  boolean jjtc007 = true;
+                                                  jjtree.openNodeScope(jjtn007);
+                                                }
+                                                try {
+/*@egen*//*@bgen(jjtree)*/
+                                                {
+                                                  jjtree.closeNodeScope(jjtn007,  0);
+                                                  jjtc007 = false;
+                                                }
+/*@egen*/              { jjtn007.setName( t.image ); }/*@bgen(jjtree)*/
+                                                } finally {
+                                                  if (jjtc007) {
+                                                    jjtree.closeNodeScope(jjtn007,  0);
+                                                  }
+                                                }
+/*@egen*/
+     |
+        LOOKAHEAD(2) ":" "[" expression() "]"/*@bgen(jjtree) #Const( 1) */
+                                                {
+                                                  ASTConst jjtn008 = new ASTConst(JJTCONST);
+                                                  boolean jjtc008 = true;
+                                                  jjtree.openNodeScope(jjtn008);
+                                                }
+                                                try {
+/*@egen*//*@bgen(jjtree)*/
+                                                {
+                                                  jjtree.closeNodeScope(jjtn008,  1);
+                                                  jjtc008 = false;
+                                                }
+/*@egen*/   { jjtn008.setValue( jjtn008.jjtGetChild(0) ); }/*@bgen(jjtree)*/
+                                                } finally {
+                                                  if (jjtc008) {
+                                                    jjtree.closeNodeScope(jjtn008,  1);
+                                                  }
+                                                }
+/*@egen*/
+     |
+        staticReference()
+     |
+        LOOKAHEAD(2) constructorCall()
+     |
+          // Prevent the "eval" ambiguity from issuing a warning; see discussion elsewhere.
+        ( LOOKAHEAD(2) methodCall() | propertyName() )
+     |
+        index()
+     |
+        "(" expression() ")"
+     |
+        "{"/*@bgen(jjtree) List */
+            {
+              ASTList jjtn009 = new ASTList(JJTLIST);
+              boolean jjtc009 = true;
+              jjtree.openNodeScope(jjtn009);
+            }
+            try {
+/*@egen*/ [assignmentExpression() ("," assignmentExpression())*]/*@bgen(jjtree)*/
+            } catch (Throwable jjte009) {
+              if (jjtc009) {
+                jjtree.clearNodeScope(jjtn009);
+                jjtc009 = false;
+              } else {
+                jjtree.popNode();
+              }
+              if (jjte009 instanceof RuntimeException) {
+                throw (RuntimeException)jjte009;
+              }
+              if (jjte009 instanceof ParseException) {
+                throw (ParseException)jjte009;
+              }
+              throw (Error)jjte009;
+            } finally {
+              if (jjtc009) {
+                jjtree.closeNodeScope(jjtn009, true);
+              }
+            }
+/*@egen*/ "}"
+     |
+        LOOKAHEAD(2)/*@bgen(jjtree) Map */
+                     {
+                       ASTMap jjtn010 = new ASTMap(JJTMAP);
+                       boolean jjtc010 = true;
+                       jjtree.openNodeScope(jjtn010);
+                     }
+                     try {
+/*@egen*/ ( "#" (className=classReference())? "{" [keyValueExpression() ("," keyValueExpression())*] { jjtn010.setClassName(className); } "}" )/*@bgen(jjtree)*/
+                     } catch (Throwable jjte010) {
+                       if (jjtc010) {
+                         jjtree.clearNodeScope(jjtn010);
+                         jjtc010 = false;
+                       } else {
+                         jjtree.popNode();
+                       }
+                       if (jjte010 instanceof RuntimeException) {
+                         throw (RuntimeException)jjte010;
+                       }
+                       if (jjte010 instanceof ParseException) {
+                         throw (ParseException)jjte010;
+                       }
+                       throw (Error)jjte010;
+                     } finally {
+                       if (jjtc010) {
+                         jjtree.closeNodeScope(jjtn010, true);
+                       }
+                     }
+/*@egen*/
+    )
+}
+
+void keyValueExpression() : {}
+{/*@bgen(jjtree) KeyValue */
+        {
+          ASTKeyValue jjtn001 = new ASTKeyValue(JJTKEYVALUE);
+          boolean jjtc001 = true;
+          jjtree.openNodeScope(jjtn001);
+        }
+        try {
+/*@egen*/
+        ( assignmentExpression() (":" assignmentExpression())? )/*@bgen(jjtree)*/
+        } catch (Throwable jjte001) {
+          if (jjtc001) {
+            jjtree.clearNodeScope(jjtn001);
+            jjtc001 = false;
+          } else {
+            jjtree.popNode();
+          }
+          if (jjte001 instanceof RuntimeException) {
+            throw (RuntimeException)jjte001;
+          }
+          if (jjte001 instanceof ParseException) {
+            throw (ParseException)jjte001;
+          }
+          throw (Error)jjte001;
+        } finally {
+          if (jjtc001) {
+            jjtree.closeNodeScope(jjtn001, true);
+          }
+        }
+/*@egen*/
+}
+
+void staticReference() : {
+    String className = "java.lang.Math";
+    Token t;
+}
+{
+    className=classReference()
+        ( // Prevent the "eval" ambiguity from issuing a warning; see discussion elsewhere.
+            LOOKAHEAD(2)
+            staticMethodCall( className )
+         |
+            t=<IDENT>/*@bgen(jjtree) #StaticField( 0) */
+                                    {
+                                      ASTStaticField jjtn001 = new ASTStaticField(JJTSTATICFIELD);
+                                      boolean jjtc001 = true;
+                                      jjtree.openNodeScope(jjtn001);
+                                    }
+                                    try {
+/*@egen*//*@bgen(jjtree)*/
+                                    {
+                                      jjtree.closeNodeScope(jjtn001,  0);
+                                      jjtc001 = false;
+                                    }
+/*@egen*/               { jjtn001.init( className, t.image ); }/*@bgen(jjtree)*/
+                                    } finally {
+                                      if (jjtc001) {
+                                        jjtree.closeNodeScope(jjtn001,  0);
+                                      }
+                                    }
+/*@egen*/
+        )
+}
+
+String classReference(): {
+    String      result = "java.lang.Math";
+}
+{
+    "@" ( result=className() )? "@" { return result; }
+}
+
+String className(): {
+    Token t;
+    StringBuffer result;
+}
+{
+    t=<IDENT>               { result = new StringBuffer( t.image ); }
+    ( "." t=<IDENT>         { result.append('.').append( t.image ); }
+    )*                      { return new String(result); }
+}
+
+void constructorCall()       : {/*@bgen(jjtree) Ctor */
+    ASTCtor jjtn000 = new ASTCtor(JJTCTOR);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);
+/*@egen*/
+    String className;
+    Token t;
+    StringBuffer sb;
+}
+{/*@bgen(jjtree) Ctor */
+    try {
+/*@egen*/
+    "new" className=className()
+        (
+            LOOKAHEAD(2) (
<