incubator-imperius-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jnee...@apache.org
Subject 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...
Date Sat, 22 Dec 2007 19:34:03 GMT
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 <jneeraj@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 &&macroDeclarations_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 ...]


Mime
View raw message