You are viewing a plain text version of this content. The canonical link for it is here.
Posted to imperius-commits@incubator.apache.org by jn...@apache.org on 2007/12/22 19:34:03 UTC
svn commit: r606479 [5/30] - in /incubator/imperius/trunk/trunk: ./ modules/
modules/imperius-javaspl/ modules/imperius-javaspl/resources/
modules/imperius-javaspl/resources/samples/
modules/imperius-javaspl/resources/samples/computersystem/ modules/im...
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLParser.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLParser.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLParser.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLParser.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,2845 @@
+// $ANTLR : "cimspl.g" -> "SPLParser.java"$
+
+ /*
+ * Copyright 2007 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.
+ */
+
+ /**
+ * @author Neeraj Joshi <jn...@us.ibm.com>
+ *
+ */
+ package org.apache.imperius.spl.parser.compiler;
+
+import antlr.TokenBuffer;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.ANTLRException;
+import antlr.LLkParser;
+import antlr.Token;
+import antlr.TokenStream;
+import antlr.RecognitionException;
+import antlr.NoViableAltException;
+import antlr.MismatchedTokenException;
+import antlr.SemanticException;
+import antlr.ParserSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.collections.AST;
+import java.util.Hashtable;
+import antlr.ASTFactory;
+import antlr.ASTPair;
+import antlr.collections.impl.ASTArray;
+
+public class SPLParser extends antlr.LLkParser implements cimsplTokenTypes
+ {
+
+protected SPLParser(TokenBuffer tokenBuf, int k) {
+ super(tokenBuf,k);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public SPLParser(TokenBuffer tokenBuf) {
+ this(tokenBuf,1);
+}
+
+protected SPLParser(TokenStream lexer, int k) {
+ super(lexer,k);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public SPLParser(TokenStream lexer) {
+ this(lexer,1);
+}
+
+public SPLParser(ParserSharedInputState state) {
+ super(state,1);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+ public final void splpolicy() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber splpolicy_AST = null;
+
+ try { // for error handling
+ {
+ int _cnt2628=0;
+ _loop2628:
+ do {
+ if ((LA(1)==LITERAL_Import)) {
+ importstatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ if ( _cnt2628>=1 ) { break _loop2628; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt2628++;
+ } while (true);
+ }
+ strategystatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ declarationstatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ int _cnt2630=0;
+ _loop2630:
+ do {
+ if ((LA(1)==LITERAL_Policy||LA(1)==LITERAL_PolicyGroup)) {
+ policystatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ if ( _cnt2630>=1 ) { break _loop2630; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt2630++;
+ } while (true);
+ }
+ splpolicy_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ }
+ returnAST = splpolicy_AST;
+ }
+
+ public final void importstatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber importstatement_AST = null;
+ Token i = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber i_AST = null;
+
+ try { // for error handling
+ i = LT(1);
+ i_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(i);
+ astFactory.makeASTRoot(currentAST, i_AST);
+ match(LITERAL_Import);
+ i_AST.setType(IMPORT_DEF);
+ {
+ switch ( LA(1)) {
+ case LITERAL_Qualifier:
+ {
+ qualifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LITERAL_Class:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(LITERAL_Class);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp2_AST = null;
+ tmp2_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp2_AST);
+ match(IDENT);
+ {
+ _loop2634:
+ do {
+ if ((LA(1)==DOT)) {
+ match(DOT);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp4_AST = null;
+ tmp4_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp4_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop2634;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case COLON:
+ {
+ identList();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case IDENT:
+ case SEMI:
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_Self:
+ case LPAREN:
+ case LITERAL_collect:
+ case LBRACK:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_Self:
+ case LPAREN:
+ case LITERAL_collect:
+ case LBRACK:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ importstatement_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_1);
+ }
+ returnAST = importstatement_AST;
+ }
+
+ public final void strategystatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber strategystatement_AST = null;
+ Token s = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber s_AST = null;
+
+ try { // for error handling
+ s = LT(1);
+ s_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(s);
+ astFactory.makeASTRoot(currentAST, s_AST);
+ match(LITERAL_Strategy);
+ s_AST.setType(STRATEGY_DEF);
+ {
+ switch ( LA(1)) {
+ case LITERAL_Execute_All_Applicable:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp6_AST = null;
+ tmp6_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp6_AST);
+ match(LITERAL_Execute_All_Applicable);
+ break;
+ }
+ case LITERAL_Execute_First_Applicable:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp7_AST = null;
+ tmp7_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp7_AST);
+ match(LITERAL_Execute_First_Applicable);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ strategystatement_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_2);
+ }
+ returnAST = strategystatement_AST;
+ }
+
+ public final void declarationstatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber declarationstatement_AST = null;
+ Token d = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber d_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LITERAL_Declaration:
+ {
+ d = LT(1);
+ d_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(d);
+ astFactory.makeASTRoot(currentAST, d_AST);
+ match(LITERAL_Declaration);
+ d_AST.setType(DECL_DEF);
+ match(LCURLY);
+ {
+ _loop2648:
+ do {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ {
+ constantDefinitions();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ break;
+ }
+ case LITERAL_Macro:
+ {
+ {
+ macroDeclarations();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ break;
+ }
+ default:
+ {
+ break _loop2648;
+ }
+ }
+ } while (true);
+ }
+ match(RCURLY);
+ break;
+ }
+ case LITERAL_Policy:
+ case LITERAL_Condition:
+ case LITERAL_Decision:
+ case LITERAL_PolicyGroup:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ declarationstatement_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_3);
+ }
+ returnAST = declarationstatement_AST;
+ }
+
+ public final void policystatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber policystatement_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LITERAL_Policy:
+ {
+ policydef();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LITERAL_PolicyGroup:
+ {
+ policyGroup();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ policystatement_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_4);
+ }
+ returnAST = policystatement_AST;
+ }
+
+ public final void qualifier() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber qualifier_AST = null;
+ Token q = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber q_AST = null;
+
+ try { // for error handling
+ q = LT(1);
+ q_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(q);
+ astFactory.makeASTRoot(currentAST, q_AST);
+ match(LITERAL_Qualifier);
+ q_AST.setType(QUALIFIER);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp12_AST = null;
+ tmp12_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp12_AST);
+ match(IDENT);
+ qualifier_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_5);
+ }
+ returnAST = qualifier_AST;
+ }
+
+ public final void identList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber identList_AST = null;
+ Token c = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber c_AST = null;
+
+ try { // for error handling
+ c = LT(1);
+ c_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(c);
+ astFactory.makeASTRoot(currentAST, c_AST);
+ match(COLON);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp13_AST = null;
+ tmp13_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp13_AST);
+ match(IDENT);
+ {
+ _loop2640:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp15_AST = null;
+ tmp15_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp15_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop2640;
+ }
+
+ } while (true);
+ }
+ identList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ }
+ returnAST = identList_AST;
+ }
+
+ public final void expression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber expression_AST = null;
+
+ try { // for error handling
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ expression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ expression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(EXPR,"EXPR")).add(expression_AST));
+ currentAST.root = expression_AST;
+ currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
+ expression_AST.getFirstChild() : expression_AST;
+ currentAST.advanceChildToEnd();
+ expression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_7);
+ }
+ returnAST = expression_AST;
+ }
+
+ public final void constantDefinitions() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber constantDefinitions_AST = null;
+ Token id = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber id_AST = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber v_AST = null;
+
+ try { // for error handling
+ id = LT(1);
+ id_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(id);
+ match(IDENT);
+ varInitializer();
+ v_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)returnAST;
+ match(SEMI);
+ constantDefinitions_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ constantDefinitions_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(3)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(CONSTANT_DEFN,"CONSTANT_DEFN")).add(id_AST).add(v_AST));
+ currentAST.root = constantDefinitions_AST;
+ currentAST.child = constantDefinitions_AST!=null &&constantDefinitions_AST.getFirstChild()!=null ?
+ constantDefinitions_AST.getFirstChild() : constantDefinitions_AST;
+ currentAST.advanceChildToEnd();
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_8);
+ }
+ returnAST = constantDefinitions_AST;
+ }
+
+ public final void macroDeclarations() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber macroDeclarations_AST = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber m_AST = null;
+
+ try { // for error handling
+ match(LITERAL_Macro);
+ match(LCURLY);
+ macrodef();
+ m_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)returnAST;
+ match(RCURLY);
+ macroDeclarations_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ macroDeclarations_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(MACRO_DEFN,"MACRO")).add(m_AST));
+ currentAST.root = macroDeclarations_AST;
+ currentAST.child = macroDeclarations_AST!=null &¯oDeclarations_AST.getFirstChild()!=null ?
+ macroDeclarations_AST.getFirstChild() : macroDeclarations_AST;
+ currentAST.advanceChildToEnd();
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_8);
+ }
+ returnAST = macroDeclarations_AST;
+ }
+
+ public final void varInitializer() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber varInitializer_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp20_AST = null;
+ tmp20_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp20_AST);
+ match(ASSIGN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ varInitializer_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_9);
+ }
+ returnAST = varInitializer_AST;
+ }
+
+ public final void macrodef() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber macrodef_AST = null;
+ Token id = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber id_AST = null;
+
+ try { // for error handling
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp21_AST = null;
+ tmp21_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp21_AST);
+ match(LITERAL_Name);
+ match(ASSIGN);
+ id = LT(1);
+ id_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(id);
+ astFactory.addASTChild(currentAST, id_AST);
+ match(IDENT);
+ match(SEMI);
+ match(LITERAL_type);
+ match(ASSIGN);
+ splType();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ argumentList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(LITERAL_procedure);
+ match(ASSIGN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ macrodef_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ }
+ returnAST = macrodef_AST;
+ }
+
+ public final void splType() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber splType_AST = null;
+
+ try { // for error handling
+ basicSplTypes();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp29_AST = null;
+ tmp29_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp29_AST);
+ match(LBRACK);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp30_AST = null;
+ tmp30_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp30_AST);
+ match(RBRACK);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ splType_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_10);
+ }
+ returnAST = splType_AST;
+ }
+
+ public final void argumentList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber argumentList_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LITERAL_argument:
+ {
+ match(LITERAL_argument);
+ match(ASSIGN);
+ argument();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2657:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ argument();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2657;
+ }
+
+ } while (true);
+ }
+ match(SEMI);
+ break;
+ }
+ case LITERAL_procedure:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ argumentList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ argumentList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(ARGUMENTS,"ARGUMENTS")).add(argumentList_AST));
+ currentAST.root = argumentList_AST;
+ currentAST.child = argumentList_AST!=null &&argumentList_AST.getFirstChild()!=null ?
+ argumentList_AST.getFirstChild() : argumentList_AST;
+ currentAST.advanceChildToEnd();
+ argumentList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_11);
+ }
+ returnAST = argumentList_AST;
+ }
+
+ public final void argument() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber argument_AST = null;
+ Token id = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber id_AST = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber c_AST = null;
+
+ try { // for error handling
+ id = LT(1);
+ id_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(id);
+ match(IDENT);
+ match(COLON);
+ splType();
+ c_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)returnAST;
+ argument_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ argument_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(3)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(ARG_DEF,"ARG_DEF")).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(TYPE,"TYPE")).add(c_AST))).add(id_AST));
+ currentAST.root = argument_AST;
+ currentAST.child = argument_AST!=null &&argument_AST.getFirstChild()!=null ?
+ argument_AST.getFirstChild() : argument_AST;
+ currentAST.advanceChildToEnd();
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_10);
+ }
+ returnAST = argument_AST;
+ }
+
+ public final void policydef() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber policydef_AST = null;
+ Token p = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber p_AST = null;
+
+ try { // for error handling
+ p = LT(1);
+ p_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(p);
+ astFactory.makeASTRoot(currentAST, p_AST);
+ match(LITERAL_Policy);
+ p_AST.setType(POLICY_DEF);
+ match(LCURLY);
+ declarationstatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ conditionstatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ decision();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RCURLY);
+ match(COLON);
+ priority();
+ astFactory.addASTChild(currentAST, returnAST);
+ policydef_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_9);
+ }
+ returnAST = policydef_AST;
+ }
+
+ public final void policyGroup() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber policyGroup_AST = null;
+ Token p = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber p_AST = null;
+
+ try { // for error handling
+ p = LT(1);
+ p_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(p);
+ astFactory.makeASTRoot(currentAST, p_AST);
+ match(LITERAL_PolicyGroup);
+ p_AST.setType(POLICY_GRP_DEF);
+ assocName();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(LCURLY);
+ splpolicy();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RCURLY);
+ match(COLON);
+ priority();
+ astFactory.addASTChild(currentAST, returnAST);
+ policyGroup_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_9);
+ }
+ returnAST = policyGroup_AST;
+ }
+
+ public final void conditionstatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber conditionstatement_AST = null;
+ Token c = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber c_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LITERAL_Condition:
+ {
+ c = LT(1);
+ c_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(c);
+ astFactory.makeASTRoot(currentAST, c_AST);
+ match(LITERAL_Condition);
+ c_AST.setType(CONDITION_DEF);
+ match(LCURLY);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RCURLY);
+ break;
+ }
+ case LITERAL_Decision:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ conditionstatement_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_12);
+ }
+ returnAST = conditionstatement_AST;
+ }
+
+ public final void decision() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber decision_AST = null;
+ Token d = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber d_AST = null;
+
+ try { // for error handling
+ d = LT(1);
+ d_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(d);
+ astFactory.makeASTRoot(currentAST, d_AST);
+ match(LITERAL_Decision);
+ d_AST.setType(DECISION_DEF);
+ match(LCURLY);
+ actionBlock();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RCURLY);
+ decision_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ }
+ returnAST = decision_AST;
+ }
+
+ public final void priority() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber priority_AST = null;
+
+ try { // for error handling
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp46_AST = null;
+ tmp46_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp46_AST);
+ match(NUM_INT);
+ priority_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_9);
+ }
+ returnAST = priority_AST;
+ }
+
+ public final void actionBlock() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber actionBlock_AST = null;
+
+ try { // for error handling
+ actionBlockExpr();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2727:
+ do {
+ if ((_tokenSet_13.member(LA(1)))) {
+ {
+ switch ( LA(1)) {
+ case ARROW:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp47_AST = null;
+ tmp47_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp47_AST);
+ match(ARROW);
+ break;
+ }
+ case LAND:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp48_AST = null;
+ tmp48_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp48_AST);
+ match(LAND);
+ break;
+ }
+ case LOR:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp49_AST = null;
+ tmp49_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp49_AST);
+ match(LOR);
+ break;
+ }
+ case BOR:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp50_AST = null;
+ tmp50_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp50_AST);
+ match(BOR);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ actionBlockExpr();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2727;
+ }
+
+ } while (true);
+ }
+ actionBlock_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_14);
+ }
+ returnAST = actionBlock_AST;
+ }
+
+ public final void assignmentExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber assignmentExpression_AST = null;
+
+ try { // for error handling
+ conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp51_AST = null;
+ tmp51_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp51_AST);
+ match(ASSIGN);
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ assignmentExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_7);
+ }
+ returnAST = assignmentExpression_AST;
+ }
+
+ public final void exprList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber exprList_AST = null;
+
+ try { // for error handling
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2669:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2669;
+ }
+
+ } while (true);
+ }
+ exprList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ exprList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(ELIST,"ELIST")).add(exprList_AST));
+ currentAST.root = exprList_AST;
+ currentAST.child = exprList_AST!=null &&exprList_AST.getFirstChild()!=null ?
+ exprList_AST.getFirstChild() : exprList_AST;
+ currentAST.advanceChildToEnd();
+ exprList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_15);
+ }
+ returnAST = exprList_AST;
+ }
+
+ public final void conditionalExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber conditionalExpression_AST = null;
+
+ try { // for error handling
+ logicalOrexpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ conditionalExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ }
+ returnAST = conditionalExpression_AST;
+ }
+
+ public final void logicalOrexpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber logicalOrexpression_AST = null;
+
+ try { // for error handling
+ logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2675:
+ do {
+ if ((LA(1)==LOR)) {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp53_AST = null;
+ tmp53_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp53_AST);
+ match(LOR);
+ logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2675;
+ }
+
+ } while (true);
+ }
+ logicalOrexpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ }
+ returnAST = logicalOrexpression_AST;
+ }
+
+ public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber logicalAndExpression_AST = null;
+
+ try { // for error handling
+ exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2678:
+ do {
+ if ((LA(1)==LAND)) {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp54_AST = null;
+ tmp54_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp54_AST);
+ match(LAND);
+ exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2678;
+ }
+
+ } while (true);
+ }
+ logicalAndExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ }
+ returnAST = logicalAndExpression_AST;
+ }
+
+ public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber exclusiveOrExpression_AST = null;
+
+ try { // for error handling
+ equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2681:
+ do {
+ if ((LA(1)==BXOR)) {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp55_AST = null;
+ tmp55_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp55_AST);
+ match(BXOR);
+ equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2681;
+ }
+
+ } while (true);
+ }
+ exclusiveOrExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_18);
+ }
+ returnAST = exclusiveOrExpression_AST;
+ }
+
+ public final void equalityExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber equalityExpression_AST = null;
+
+ try { // for error handling
+ relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2685:
+ do {
+ if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
+ {
+ switch ( LA(1)) {
+ case NOT_EQUAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp56_AST = null;
+ tmp56_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp56_AST);
+ match(NOT_EQUAL);
+ break;
+ }
+ case EQUAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp57_AST = null;
+ tmp57_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp57_AST);
+ match(EQUAL);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2685;
+ }
+
+ } while (true);
+ }
+ equalityExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_19);
+ }
+ returnAST = equalityExpression_AST;
+ }
+
+ public final void relationalExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber relationalExpression_AST = null;
+
+ try { // for error handling
+ additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2689:
+ do {
+ if (((LA(1) >= LT && LA(1) <= GE))) {
+ {
+ switch ( LA(1)) {
+ case LT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp58_AST = null;
+ tmp58_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp58_AST);
+ match(LT);
+ break;
+ }
+ case GT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp59_AST = null;
+ tmp59_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp59_AST);
+ match(GT);
+ break;
+ }
+ case LE:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp60_AST = null;
+ tmp60_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp60_AST);
+ match(LE);
+ break;
+ }
+ case GE:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp61_AST = null;
+ tmp61_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp61_AST);
+ match(GE);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2689;
+ }
+
+ } while (true);
+ }
+ relationalExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_20);
+ }
+ returnAST = relationalExpression_AST;
+ }
+
+ public final void additiveExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber additiveExpression_AST = null;
+
+ try { // for error handling
+ multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2693:
+ do {
+ if ((LA(1)==PLUS||LA(1)==MINUS)) {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp62_AST = null;
+ tmp62_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp62_AST);
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp63_AST = null;
+ tmp63_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp63_AST);
+ match(MINUS);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2693;
+ }
+
+ } while (true);
+ }
+ additiveExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_21);
+ }
+ returnAST = additiveExpression_AST;
+ }
+
+ public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber multiplicativeExpression_AST = null;
+
+ try { // for error handling
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop2697:
+ do {
+ if ((LA(1)==STAR||LA(1)==DIV)) {
+ {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp64_AST = null;
+ tmp64_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp64_AST);
+ match(STAR);
+ break;
+ }
+ case DIV:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp65_AST = null;
+ tmp65_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp65_AST);
+ match(DIV);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop2697;
+ }
+
+ } while (true);
+ }
+ multiplicativeExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ }
+ returnAST = multiplicativeExpression_AST;
+ }
+
+ public final void unaryExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber unaryExpression_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case MINUS:
+ {
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp66_AST = null;
+ tmp66_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp66_AST);
+ match(MINUS);
+ tmp66_AST.setType(UNARY_MINUS);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ unaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case PLUS:
+ {
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp67_AST = null;
+ tmp67_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp67_AST);
+ match(PLUS);
+ tmp67_AST.setType(UNARY_PLUS);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ unaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case IDENT:
+ case NUM_INT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_Self:
+ case LPAREN:
+ case LITERAL_collect:
+ case LBRACK:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ {
+ unaryExpressionNotPlusMinus();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ unaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = unaryExpression_AST;
+ }
+
+ public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber unaryExpressionNotPlusMinus_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case LNOT:
+ {
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp68_AST = null;
+ tmp68_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp68_AST);
+ match(LNOT);
+ tmp68_AST.setType(UNARY_NOT);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ unaryExpressionNotPlusMinus_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case IDENT:
+ case NUM_INT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_Self:
+ case LPAREN:
+ case LITERAL_collect:
+ case LBRACK:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ {
+ primaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ unaryExpressionNotPlusMinus_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = unaryExpressionNotPlusMinus_AST;
+ }
+
+ public final void primaryExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber primaryExpression_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IDENT:
+ case LITERAL_collect:
+ case LBRACK:
+ {
+ identPrimary();
+ astFactory.addASTChild(currentAST, returnAST);
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ constant();
+ astFactory.addASTChild(currentAST, returnAST);
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_true:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp69_AST = null;
+ tmp69_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp69_AST);
+ match(LITERAL_true);
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_false:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp70_AST = null;
+ tmp70_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp70_AST);
+ match(LITERAL_false);
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_Self:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp71_AST = null;
+ tmp71_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp71_AST);
+ match(LITERAL_Self);
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LPAREN:
+ {
+ {
+ match(LPAREN);
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ }
+ primaryExpression_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = primaryExpression_AST;
+ }
+
+ public final void identPrimary() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber identPrimary_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp74_AST = null;
+ tmp74_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp74_AST);
+ match(IDENT);
+ {
+ switch ( LA(1)) {
+ case DOT:
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case ASSIGN:
+ case LOR:
+ case LAND:
+ case BXOR:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case DIV:
+ case RPAREN:
+ case RBRACK:
+ {
+ {
+ _loop2711:
+ do {
+ if ((LA(1)==DOT)) {
+ match(DOT);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp76_AST = null;
+ tmp76_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp76_AST);
+ match(IDENT);
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ indexOp();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LPAREN:
+ {
+ methodCall();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case DOT:
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case ASSIGN:
+ case LOR:
+ case LAND:
+ case BXOR:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case DIV:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop2711;
+ }
+
+ } while (true);
+ }
+ break;
+ }
+ case LPAREN:
+ {
+ methodCall();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ identPrimary_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_collect:
+ {
+ collectOperation();
+ astFactory.addASTChild(currentAST, returnAST);
+ identPrimary_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LBRACK:
+ {
+ basicCollectionOp();
+ astFactory.addASTChild(currentAST, returnAST);
+ identPrimary_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = identPrimary_AST;
+ }
+
+ public final void constant() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber constant_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp77_AST = null;
+ tmp77_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp77_AST);
+ match(NUM_INT);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case CHAR_LITERAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp78_AST = null;
+ tmp78_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp78_AST);
+ match(CHAR_LITERAL);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case STRING_LITERAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp79_AST = null;
+ tmp79_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp79_AST);
+ match(STRING_LITERAL);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case NUM_FLOAT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp80_AST = null;
+ tmp80_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp80_AST);
+ match(NUM_FLOAT);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case NUM_LONG:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp81_AST = null;
+ tmp81_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp81_AST);
+ match(NUM_LONG);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case NUM_DOUBLE:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp82_AST = null;
+ tmp82_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp82_AST);
+ match(NUM_DOUBLE);
+ constant_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_24);
+ }
+ returnAST = constant_AST;
+ }
+
+ public final void indexOp() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber indexOp_AST = null;
+ Token lb = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber lb_AST = null;
+
+ try { // for error handling
+ lb = LT(1);
+ lb_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ lb_AST.setType(INDEX_OP);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RBRACK);
+ indexOp_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_25);
+ }
+ returnAST = indexOp_AST;
+ }
+
+ public final void methodCall() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber methodCall_AST = null;
+ Token lp = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber lp_AST = null;
+
+ try { // for error handling
+ lp = LT(1);
+ lp_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(lp);
+ astFactory.makeASTRoot(currentAST, lp_AST);
+ match(LPAREN);
+ lp_AST.setType(METHOD_CALL);
+ paramList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ methodCall_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_26);
+ }
+ returnAST = methodCall_AST;
+ }
+
+ public final void collectOperation() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber collectOperation_AST = null;
+ Token c = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber c_AST = null;
+
+ try { // for error handling
+ c = LT(1);
+ c_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(c);
+ astFactory.makeASTRoot(currentAST, c_AST);
+ match(LITERAL_collect);
+ c_AST.setType(COLLECT_OP);
+ collectmethodcall();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ indexOp();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ methodOrPropertyOrArrayForCollect();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case ASSIGN:
+ case LOR:
+ case LAND:
+ case BXOR:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case DIV:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case ASSIGN:
+ case LOR:
+ case LAND:
+ case BXOR:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case DIV:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ collectOperation_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = collectOperation_AST;
+ }
+
+ public final void basicCollectionOp() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber basicCollectionOp_AST = null;
+ Token lb = null;
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber lb_AST = null;
+
+ try { // for error handling
+ lb = LT(1);
+ lb_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ lb_AST.setType(BASICCOLLECTION_OP);
+ exprList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RBRACK);
+ basicCollectionOp_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = basicCollectionOp_AST;
+ }
+
+ public final void collectmethodcall() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber collectmethodcall_AST = null;
+
+ try { // for error handling
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp86_AST = null;
+ tmp86_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp86_AST);
+ match(LPAREN);
+ tmp86_AST.setType(COLLECT_CALL);
+ paramList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ collectmethodcall_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_27);
+ }
+ returnAST = collectmethodcall_AST;
+ }
+
+ public final void methodOrPropertyOrArrayForCollect() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber methodOrPropertyOrArrayForCollect_AST = null;
+
+ try { // for error handling
+ match(DOT);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp89_AST = null;
+ tmp89_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp89_AST);
+ match(IDENT);
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ indexOp();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LPAREN:
+ {
+ methodCall();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RCURLY:
+ case ASSIGN:
+ case LOR:
+ case LAND:
+ case BXOR:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case DIV:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ methodOrPropertyOrArrayForCollect_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ }
+ returnAST = methodOrPropertyOrArrayForCollect_AST;
+ }
+
+ public final void paramList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber paramList_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_Self:
+ case LPAREN:
+ case LITERAL_collect:
+ case LBRACK:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ exprList();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ paramList_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_28);
+ }
+ returnAST = paramList_AST;
+ }
+
+ public final void actionBlockExpr() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber actionBlockExpr_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IDENT:
+ case LITERAL_Set:
+ case LITERAL_InvokePolicy:
+ {
+ basicActionBlock();
+ astFactory.addASTChild(currentAST, returnAST);
+ actionBlockExpr_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LPAREN:
+ {
+ match(LPAREN);
+ actionBlock();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ actionBlockExpr_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_29);
+ }
+ returnAST = actionBlockExpr_AST;
+ }
+
+ public final void basicActionBlock() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber basicActionBlock_AST = null;
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp92_AST = null;
+ tmp92_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp92_AST);
+ match(IDENT);
+ break;
+ }
+ case LITERAL_Set:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp93_AST = null;
+ tmp93_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp93_AST);
+ match(LITERAL_Set);
+ break;
+ }
+ case LITERAL_InvokePolicy:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp94_AST = null;
+ tmp94_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp94_AST);
+ match(LITERAL_InvokePolicy);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ match(DOT);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp96_AST = null;
+ tmp96_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp96_AST);
+ match(IDENT);
+ break;
+ }
+ case LPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ methodCall();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ {
+ switch ( LA(1)) {
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ {
+ {
+ switch ( LA(1)) {
+ case EQUAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp97_AST = null;
+ tmp97_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp97_AST);
+ match(EQUAL);
+ break;
+ }
+ case NOT_EQUAL:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp98_AST = null;
+ tmp98_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp98_AST);
+ match(NOT_EQUAL);
+ break;
+ }
+ case GE:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp99_AST = null;
+ tmp99_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp99_AST);
+ match(GE);
+ break;
+ }
+ case GT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp100_AST = null;
+ tmp100_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp100_AST);
+ match(GT);
+ break;
+ }
+ case LT:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp101_AST = null;
+ tmp101_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp101_AST);
+ match(LT);
+ break;
+ }
+ case LE:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp102_AST = null;
+ tmp102_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp102_AST);
+ match(LE);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ constant();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case RCURLY:
+ case LOR:
+ case LAND:
+ case RPAREN:
+ case ARROW:
+ case BOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ basicActionBlock_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ basicActionBlock_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(ACTIONBLOCK,"ACTIONBLK")).add(basicActionBlock_AST));
+ currentAST.root = basicActionBlock_AST;
+ currentAST.child = basicActionBlock_AST!=null &&basicActionBlock_AST.getFirstChild()!=null ?
+ basicActionBlock_AST.getFirstChild() : basicActionBlock_AST;
+ currentAST.advanceChildToEnd();
+ basicActionBlock_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_29);
+ }
+ returnAST = basicActionBlock_AST;
+ }
+
+ public final void assocName() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber assocName_AST = null;
+
+ try { // for error handling
+ match(COLON);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp104_AST = null;
+ tmp104_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp104_AST);
+ match(IDENT);
+ match(LPAREN);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp106_AST = null;
+ tmp106_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp106_AST);
+ match(IDENT);
+ match(COMMA);
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp108_AST = null;
+ tmp108_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp108_AST);
+ match(IDENT);
+ match(RPAREN);
+ assocName_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ assocName_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.make( (new ASTArray(2)).add((org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(ASSOCIATION,"ASSOC")).add(assocName_AST));
+ currentAST.root = assocName_AST;
+ currentAST.child = assocName_AST!=null &&assocName_AST.getFirstChild()!=null ?
+ assocName_AST.getFirstChild() : assocName_AST;
+ currentAST.advanceChildToEnd();
+ assocName_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ }
+ returnAST = assocName_AST;
+ }
+
+ public final void basicSplTypes() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber basicSplTypes_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case 88:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp110_AST = null;
+ tmp110_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp110_AST);
+ match(88);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 89:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp111_AST = null;
+ tmp111_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp111_AST);
+ match(89);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 90:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp112_AST = null;
+ tmp112_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp112_AST);
+ match(90);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 91:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp113_AST = null;
+ tmp113_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp113_AST);
+ match(91);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 92:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp114_AST = null;
+ tmp114_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp114_AST);
+ match(92);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 93:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp115_AST = null;
+ tmp115_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp115_AST);
+ match(93);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 94:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp116_AST = null;
+ tmp116_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp116_AST);
+ match(94);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 95:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp117_AST = null;
+ tmp117_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp117_AST);
+ match(95);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 96:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp118_AST = null;
+ tmp118_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp118_AST);
+ match(96);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 97:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp119_AST = null;
+ tmp119_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp119_AST);
+ match(97);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_Boolean:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp120_AST = null;
+ tmp120_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp120_AST);
+ match(LITERAL_Boolean);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case 99:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp121_AST = null;
+ tmp121_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp121_AST);
+ match(99);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_String:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp122_AST = null;
+ tmp122_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp122_AST);
+ match(LITERAL_String);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_DateTime:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp123_AST = null;
+ tmp123_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp123_AST);
+ match(LITERAL_DateTime);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ case LITERAL_Reference:
+ {
+ org.apache.imperius.spl.parser.compiler.ASTWithLineNumber tmp124_AST = null;
+ tmp124_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp124_AST);
+ match(LITERAL_Reference);
+ basicSplTypes_AST = (org.apache.imperius.spl.parser.compiler.ASTWithLineNumber)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ reportError(ex);
+ recover(ex,_tokenSet_31);
+ }
+ returnAST = basicSplTypes_AST;
+ }
+
+
+ public static final String[] _tokenNames = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "STRATEGY_DEF",
+ "IMPORT_DEF",
+ "DECL_DEF",
+ "CONSTANT_DEFN",
+ "MACRO_DEFN",
+ "POLICY_DEF",
+ "CONDITION_DEF",
+ "POLICY_GRP_DEF",
+ "DECISION_DEF",
+ "TYPE",
+ "ARGUMENTS",
+ "ARG_DEF",
+ "EXPR",
+ "ELIST",
+ "METHOD_CALL",
+ "UNARY_MINUS",
+ "QUALIFIER",
+ "PARAMETERS",
+ "PARAMETER_DEF",
+ "UNARY_PLUS",
+ "ARRAY_DECLARATOR",
+ "INDEX_OP",
+ "COLLECT_OP",
+ "ASSOCIATION",
+ "ACTIONBLOCK",
+ "COLLECT_CALL",
+ "UNARY_NOT",
+ "BASICCOLLECTION_OP",
+ "\"Import\"",
+ "\"Class\"",
+ "IDENT",
+ "DOT",
+ "SEMI",
+ "\"Qualifier\"",
+ "COLON",
+ "COMMA",
+ "\"Strategy\"",
+ "\"Execute_All_Applicable\"",
+ "\"Execute_First_Applicable\"",
+ "\"Declaration\"",
+ "LCURLY",
+ "RCURLY",
+ "ASSIGN",
+ "\"Macro\"",
+ "\"Name\"",
+ "\"type\"",
+ "\"procedure\"",
+ "\"argument\"",
+ "\"Policy\"",
+ "\"Condition\"",
+ "\"Decision\"",
+ "NUM_INT",
+ "LOR",
+ "LAND",
+ "BXOR",
+ "NOT_EQUAL",
+ "EQUAL",
+ "LT",
+ "GT",
+ "LE",
+ "GE",
+ "PLUS",
+ "MINUS",
+ "STAR",
+ "DIV",
+ "LNOT",
+ "\"true\"",
+ "\"false\"",
+ "\"Self\"",
+ "LPAREN",
+ "RPAREN",
+ "\"collect\"",
+ "LBRACK",
+ "RBRACK",
+ "CHAR_LITERAL",
+ "STRING_LITERAL",
+ "NUM_FLOAT",
+ "NUM_LONG",
+ "NUM_DOUBLE",
+ "ARROW",
+ "BOR",
+ "\"Set\"",
+ "\"InvokePolicy\"",
+ "\"PolicyGroup\"",
+ "\"Sint8\"",
+ "\"Sint16\"",
+ "\"Uint8\"",
+ "\"Uint16\"",
+ "\"Sint32\"",
+ "\"Sint64\"",
+ "\"Uint32\"",
+ "\"Uint64\"",
+ "\"Real32\"",
+ "\"Real64\"",
+ "\"Boolean\"",
+ "\"Char16\"",
+ "\"String\"",
+ "\"DateTime\"",
+ "\"Reference\"",
+ "WS",
+ "SL_COMMENT",
+ "ML_COMMENT",
+ "ESC",
+ "HEX_DIGIT",
+ "EXPONENT",
+ "FLOAT_SUFFIX"
+ };
+
+ protected void buildTokenTypeASTClassMap() {
+ tokenTypeToASTClassMap=null;
+ };
+
+ private static final long[] mk_tokenSet_0() {
+ long[] data = { 35184372088832L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
+ private static final long[] mk_tokenSet_1() {
+ long[] data = { 1103806595072L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
+ private static final long[] mk_tokenSet_2() {
+ long[] data = { 4512395720392704L, 8388608L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
+ private static final long[] mk_tokenSet_3() {
+ long[] data = { 31525197391593472L, 8388608L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
+ private static final long[] mk_tokenSet_4() {
+ long[] data = { 4538783999459328L, 8388608L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
+ private static final long[] mk_tokenSet_5() {
+ long[] data = { 8589934592L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
+ private static final long[] mk_tokenSet_6() {
+ long[] data = { 36028882918309888L, 515046L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
+ private static final long[] mk_tokenSet_7() {
+ long[] data = { 35802847379456L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
+ private static final long[] mk_tokenSet_8() {
+ long[] data = { 175939040313344L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
+ private static final long[] mk_tokenSet_9() {
+ long[] data = { 68719476736L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
+ private static final long[] mk_tokenSet_10() {
+ long[] data = { 618475290624L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
+ private static final long[] mk_tokenSet_11() {
+ long[] data = { 1125899906842624L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
+ private static final long[] mk_tokenSet_12() {
+ long[] data = { 18014398509481984L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
+ private static final long[] mk_tokenSet_13() {
+ long[] data = { 216172782113783808L, 1572864L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
+ private static final long[] mk_tokenSet_14() {
+ long[] data = { 35184372088832L, 1024L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
+ private static final long[] mk_tokenSet_15() {
+ long[] data = { 0L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
+ private static final long[] mk_tokenSet_16() {
+ long[] data = { 106171591557120L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
+ private static final long[] mk_tokenSet_17() {
+ long[] data = { 72163765629485056L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
+ private static final long[] mk_tokenSet_18() {
+ long[] data = { 216278953705340928L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
+ private static final long[] mk_tokenSet_19() {
+ long[] data = { 504509329857052672L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
+ private static final long[] mk_tokenSet_20() {
+ long[] data = { 2233891586767323136L, 9216L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
+ private static final long[] mk_tokenSet_21() {
+ long[] data = { -71951422446370816L, 9217L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
+ private static final long[] mk_tokenSet_22() {
[... 52 lines stripped ...]