/*
 * Copyright 2002,2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 *  Jexl : Java Expression Language
 *
 *  @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
 *  @author <a href="mailto:mhw@kremvax.net">Mark H. Wilkinson</a>
 *
 *  @version $Id: Parser.jj 136562 2004-02-28 13:45:22Z yoavs $
 */

options
{               
   STATIC=false;                                           
}

PARSER_BEGIN(Parser)

package org.apache.commons.jexl.parser;

import java.io.Reader;
import java.io.ByteArrayInputStream;

public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants/*@egen*/
{/*@bgen(jjtree)*/
  protected JJTParserState jjtree = new JJTParserState();

/*@egen*/
    public SimpleNode parse(Reader reader)
        throws Exception
    {
        ReInit(reader);

        /*
         *  lets do the 'Unique Init' in here to be
         *  safe - it's a pain to remember
         */

        SimpleNode tree = JexlScript();
        return tree;
    }
}

PARSER_END(Parser)


SKIP : /* WHITE SPACE */
{
    <COMMENT: ( "##" ( ~["\"","\n","\r"] )* ("\n" | "\r") ) >
|
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}

TOKEN : /* LITERALS */
{
  < INTEGER_LITERAL: (<DIGIT>)+ >
|
  < FLOAT_LITERAL: (<DIGIT>)+ "."(<DIGIT>)+ >
}

/*
 * Program structuring syntax follows.
 */

SimpleNode JexlScript() :
{/*@bgen(jjtree) JexlScript */
   ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
/*@egen*/
   String name;
}
{/*@bgen(jjtree) JexlScript */
    try {
/*@egen*/
    (
       Statement()
    )*
    <EOF>/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   { return jjtn000;}/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}


void Block() :
{/*@bgen(jjtree) Block */
  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Block */
  try {
/*@egen*/
  "{" ( Statement() )* "}"/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void EmptyFunction() : {/*@bgen(jjtree) EmptyFunction */
  ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) EmptyFunction */
    try {
/*@egen*/
    "empty"
    ( Reference() | "(" Reference() ")" )/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void SizeFunction() : {/*@bgen(jjtree) SizeFunction */
  ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SizeFunction */
    try {
/*@egen*/
    "size" "(" Reference() ")"/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void Identifier() :
{/*@bgen(jjtree) Identifier */
   ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
/*@egen*/
   Token t;
}
{/*@bgen(jjtree) Identifier */
    try {
/*@egen*/
    t=<IDENTIFIER>/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
       jjtn000.val = t.image;
    }/*@bgen(jjtree)*/
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}


/*
 * Expression syntax follows.
 */

void Expression() : {/*@bgen(jjtree) Expression */
  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Expression */
  try {
/*@egen*/
  LOOKAHEAD( PrimaryExpression() "=" )
  Assignment()
|
  ConditionalOrExpression()/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Assignment()                :
{/*@bgen(jjtree) #Assignment( 2) */
  ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) #Assignment( 2) */
  try {
/*@egen*/
  PrimaryExpression() "=" Expression()/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000,  2);
    }
  }
/*@egen*/
}

void ConditionalOrExpression()       :
{}
{
  ConditionalAndExpression()
  (
    "||"/*@bgen(jjtree) #OrNode( 2) */
         {
           ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
           boolean jjtc001 = true;
           jjtree.openNodeScope(jjtn001);
         }
         try {
/*@egen*/ ConditionalAndExpression()/*@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*/
  |
    "or"/*@bgen(jjtree) #OrNode( 2) */
         {
           ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);
           boolean jjtc002 = true;
           jjtree.openNodeScope(jjtn002);
         }
         try {
/*@egen*/ ConditionalAndExpression()/*@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*/
  )*
}

void ConditionalAndExpression()       :
{}
{
  InclusiveOrExpression()
  (
    "&&"/*@bgen(jjtree) #AndNode( 2) */
         {
           ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
           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*/
  |
    "and"/*@bgen(jjtree) #AndNode( 2) */
          {
            ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002);
          }
          try {
/*@egen*/ InclusiveOrExpression()/*@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*/
  )*
}

void InclusiveOrExpression()       :
{}
{
  ExclusiveOrExpression()
  ( "|"/*@bgen(jjtree) #BitwiseOrNode( 2) */
        {
          ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);
          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*/ )*
}

void ExclusiveOrExpression()       :
{}
{
  AndExpression()
  ( "^"/*@bgen(jjtree) #BitwiseXorNode( 2) */
        {
          ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);
          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*/ )*
}

void AndExpression()       :
{}
{
  EqualityExpression()
  ( "&"/*@bgen(jjtree) #BitwiseAndNode( 2) */
        {
          ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);
          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*/ )*
}

void EqualityExpression()       :
{}
{
  RelationalExpression()
  (
     "=="/*@bgen(jjtree) #EQNode( 2) */
          {
            ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
            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*/
   |
     "eq"/*@bgen(jjtree) #EQNode( 2) */
          {
            ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);
            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*/
   |
     "!="/*@bgen(jjtree) #NENode( 2) */
          {
            ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);
            boolean jjtc003 = true;
            jjtree.openNodeScope(jjtn003);
          }
          try {
/*@egen*/ RelationalExpression()/*@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*/
   |
     "ne"/*@bgen(jjtree) #NENode( 2) */
          {
            ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);
            boolean jjtc004 = true;
            jjtree.openNodeScope(jjtn004);
          }
          try {
/*@egen*/ RelationalExpression()/*@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*/
  )*
}

void RelationalExpression()       :
{}
{
  AdditiveExpression()
  (
    "<"/*@bgen(jjtree) #LTNode( 2) */
        {
          ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
          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*/
   |
    "lt"/*@bgen(jjtree) #LTNode( 2) */
         {
           ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);
           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*/
   |
    ">"/*@bgen(jjtree) #GTNode( 2) */
        {
          ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);
          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*/
   |
    "gt"/*@bgen(jjtree) #GTNode( 2) */
         {
           ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);
           boolean jjtc004 = true;
           jjtree.openNodeScope(jjtn004);
         }
         try {
/*@egen*/ AdditiveExpression()/*@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*/
   |
    "<="/*@bgen(jjtree) #LENode( 2) */
         {
           ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);
           boolean jjtc005 = true;
           jjtree.openNodeScope(jjtn005);
         }
         try {
/*@egen*/ AdditiveExpression()/*@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*/
   |
    "le"/*@bgen(jjtree) #LENode( 2) */
         {
           ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);
           boolean jjtc006 = true;
           jjtree.openNodeScope(jjtn006);
         }
         try {
/*@egen*/ AdditiveExpression()/*@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*/
   |
    ">="/*@bgen(jjtree) #GENode( 2) */
         {
           ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);
           boolean jjtc007 = true;
           jjtree.openNodeScope(jjtn007);
         }
         try {
/*@egen*/ AdditiveExpression()/*@bgen(jjtree)*/
         } catch (Throwable jjte007) {
           if (jjtc007) {
             jjtree.clearNodeScope(jjtn007);
             jjtc007 = false;
           } else {
             jjtree.popNode();
           }
           if (jjte007 instanceof RuntimeException) {
             throw (RuntimeException)jjte007;
           }
           if (jjte007 instanceof ParseException) {
             throw (ParseException)jjte007;
           }
           throw (Error)jjte007;
         } finally {
           if (jjtc007) {
             jjtree.closeNodeScope(jjtn007,  2);
           }
         }
/*@egen*/
   |
    "ge"/*@bgen(jjtree) #GENode( 2) */
         {
           ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);
           boolean jjtc008 = true;
           jjtree.openNodeScope(jjtn008);
         }
         try {
/*@egen*/ AdditiveExpression()/*@bgen(jjtree)*/
         } catch (Throwable jjte008) {
           if (jjtc008) {
             jjtree.clearNodeScope(jjtn008);
             jjtc008 = false;
           } else {
             jjtree.popNode();
           }
           if (jjte008 instanceof RuntimeException) {
             throw (RuntimeException)jjte008;
           }
           if (jjte008 instanceof ParseException) {
             throw (ParseException)jjte008;
           }
           throw (Error)jjte008;
         } finally {
           if (jjtc008) {
             jjtree.closeNodeScope(jjtn008,  2);
           }
         }
/*@egen*/
  )*
}

void AdditiveExpression()       :
{}
{
  MultiplicativeExpression()
  (
    "+"/*@bgen(jjtree) #AddNode( 2) */
        {
          ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
          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) #SubtractNode( 2) */
        {
          ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
          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*/
  )*
}

void MultiplicativeExpression()       :
{}
{
  UnaryExpression()
  (
    "*"/*@bgen(jjtree) #MulNode( 2) */
        {
          ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
          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) #DivNode( 2) */
        {
          ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
          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*/
   |
    "div"/*@bgen(jjtree) #DivNode( 2) */
          {
            ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);
            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*/
   |
    "%"/*@bgen(jjtree) #ModNode( 2) */
        {
          ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);
          boolean jjtc004 = true;
          jjtree.openNodeScope(jjtn004);
        }
        try {
/*@egen*/ UnaryExpression()/*@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*/
   |
    "mod"/*@bgen(jjtree) #ModNode( 2) */
          {
            ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);
            boolean jjtc005 = true;
            jjtree.openNodeScope(jjtn005);
          }
          try {
/*@egen*/ UnaryExpression()/*@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*/
  )*
}

void UnaryExpression()       :
{}
{
  "-"/*@bgen(jjtree) #UnaryMinusNode( 1) */
      {
        ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);
        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*/
|
  "~"/*@bgen(jjtree) #BitwiseComplNode( 1) */
      {
        ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);
        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*/
|
  "!"/*@bgen(jjtree) #NotNode( 1) */
      {
        ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);
        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*/
|
  "not"/*@bgen(jjtree) #NotNode( 1) */
        {
          ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);
          boolean jjtc004 = true;
          jjtree.openNodeScope(jjtn004);
        }
        try {
/*@egen*/ UnaryExpression()/*@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,  1);
          }
        }
/*@egen*/
|
  PrimaryExpression()
}

void PrimaryExpression()       :
{}
{
  Literal()
|
  Reference()
|
  "(" Expression() ")"
|
  EmptyFunction()
|
  SizeFunction()
}


void Literal()       :
{
   Token t;
}
{
  IntegerLiteral()
|
  FloatLiteral()
|
  BooleanLiteral()
|
  StringLiteral()
|
  NullLiteral()
}

void NullLiteral() : {/*@bgen(jjtree) NullLiteral */
  ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) NullLiteral */
    try {
/*@egen*/
    "null"/*@bgen(jjtree)*/
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void BooleanLiteral()       :
{}
{/*@bgen(jjtree) TrueNode */
  {
    ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*/
  "true"/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
  }
/*@egen*/
|/*@bgen(jjtree) FalseNode */
  {
    ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*/
  "false"/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002, true);
    }
  }
/*@egen*/
}

void IntegerLiteral() :
{/*@bgen(jjtree) IntegerLiteral */
  ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
  Token t;
}
{/*@bgen(jjtree) IntegerLiteral */
 try {
/*@egen*/
 (
  t=<INTEGER_LITERAL>/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
       jjtn000.val = Integer.valueOf(t.image);
    }
 )/*@bgen(jjtree)*/
 } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000, true);
   }
 }
/*@egen*/
}

void FloatLiteral() :
{/*@bgen(jjtree) FloatLiteral */
  ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
  Token t;
}
{/*@bgen(jjtree) FloatLiteral */
 try {
/*@egen*/
 (
  t=<FLOAT_LITERAL>/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
       jjtn000.val = Float.valueOf(t.image);
    }
 )/*@bgen(jjtree)*/
 } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000, true);
   }
 }
/*@egen*/
}

void StringLiteral() :
{/*@bgen(jjtree) StringLiteral */
   ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
/*@egen*/
   Token t;
}
{/*@bgen(jjtree) StringLiteral */
 try {
/*@egen*/
 (
  t=<STRING_LITERAL>/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
       jjtn000.literal = t.image.substring(1,t.image.length()-1);
    }
 )/*@bgen(jjtree)*/
 } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000, true);
   }
 }
/*@egen*/
}

/*
 * Statement syntax follows.
 */

void Statement()       :
{}
{
  ";"
|
  Block()
|
  LOOKAHEAD( Reference() ";" ) ReferenceExpression()
|
  LOOKAHEAD( PrimaryExpression() "=" ) StatementExpression()
|
  ExpressionExpression()
|
  IfStatement()
|
  ForeachStatement()
|
  WhileStatement()
}


void ExpressionExpression() : {/*@bgen(jjtree) ExpressionExpression */
  ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ExpressionExpression */
    try {
/*@egen*/
    Expression() ";"/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void StatementExpression() : {/*@bgen(jjtree) StatementExpression */
  ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) StatementExpression */
  try {
/*@egen*/
  Assignment() ";"/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ReferenceExpression() : {/*@bgen(jjtree) ReferenceExpression */
  ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ReferenceExpression */
  try {
/*@egen*/
  Reference() ";"/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void IfStatement() :{/*@bgen(jjtree) IfStatement */
  ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) IfStatement */
  try {
/*@egen*/
  "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" Statement() ]/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}


void WhileStatement() :
{/*@bgen(jjtree) WhileStatement */
  ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) WhileStatement */
  try {
/*@egen*/
  "while" "(" Expression() ")" Statement()/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ForeachStatement() :
{/*@bgen(jjtree) ForeachStatement */
  ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForeachStatement */
  try {
/*@egen*/
  "foreach" "(" Reference() "in"  Reference() ")" Statement()/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Method() : {/*@bgen(jjtree) Method */
  ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Method */
   try {
/*@egen*/
   Identifier() "("[ Parameter() ( "," Parameter() )* ] ")"/*@bgen(jjtree)*/
   } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       throw (RuntimeException)jjte000;
     }
     if (jjte000 instanceof ParseException) {
       throw (ParseException)jjte000;
     }
     throw (Error)jjte000;
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
/*@egen*/
}

void ArrayAccess() : {/*@bgen(jjtree) ArrayAccess */
  ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ArrayAccess */
    try {
/*@egen*/
    Identifier() ("[" ( LOOKAHEAD(3) Expression() | IntegerLiteral() | Reference() ) "]")+/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void SizeMethod() : {/*@bgen(jjtree) SizeMethod */
  ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SizeMethod */
        try {
/*@egen*/
	"size" "(" ")"/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void Reference() : {/*@bgen(jjtree) Reference */
  ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Reference */
  try {
/*@egen*/
  (LOOKAHEAD(Identifier() "[" ( Expression() | IntegerLiteral() | Reference()) "]") ArrayAccess() | Identifier())
  (LOOKAHEAD(2) "."
    (
      LOOKAHEAD(Identifier() "[" ( Expression() | IntegerLiteral() | Reference()) "]") ArrayAccess() |
//      (LOOKAHEAD(3) Method() | Identifier() |  IntegerLiteral() )
      (LOOKAHEAD(3) Method() | SizeMethod() | Identifier() |  IntegerLiteral() )

    )
  )*/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}


void Parameter()      : {}
{
   LOOKAHEAD(3) Expression() |  Literal() | Reference()
}

TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER: [ "a"-"z", "A"-"Z", "_", "$" ] >
|
  < #DIGIT: [ "0"-"9"] >
}

TOKEN :
{
    <STRING_LITERAL :
        ("\"" ( ~["\"","\n","\r"] )* "\"" )
     |
        ("\'" ( ~["\'","\n","\r"] )* "\'" )
    >
}