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 [4/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/manager/impl/PolicyManagerImpl.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/manager/impl/PolicyManagerImpl.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/manager/impl/PolicyManagerImpl.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/manager/impl/PolicyManagerImpl.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,283 @@
+/*
+ * 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 Prashant Baliga <pr...@in.ibm.com>
+ *
+ */
+
+
+
+package org.apache.imperius.spl.manager.impl;
+
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.datastore.PolicyDataStore;
+import org.apache.imperius.spl.datastore.impl.PolicyDataStoreImpl;
+import org.apache.imperius.spl.evaluator.PolicyEvaluator;
+import org.apache.imperius.spl.evaluator.impl.PolicyEvaluatorImpl;
+import org.apache.imperius.spl.external.Actuator;
+import org.apache.imperius.spl.external.DataCollector;
+import org.apache.imperius.spl.manager.PolicyManager;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.statements.impl.PolicyInfo;
+import org.apache.imperius.spl.parser.statements.impl.SPLPolicy;
+import org.apache.imperius.spl.parser.util.ActuatorFactory;
+import org.apache.imperius.spl.parser.util.DataCollectorFactory;
+import org.apache.imperius.util.SPLLogger;
+
+
+
+public class PolicyManagerImpl implements PolicyManager 
+{
+
+
+	private  PolicyDataStore _policyDataStore = null;
+	private  PolicyEvaluator _policyEvaluator = null;
+	private static Logger logger =  SPLLogger.getSPLLogger().getLogger(); 
+	private static final String sourceClass="PolicyManagerImpl";
+
+	private static Logger auditLogger = SPLLogger.getSPLLogger().getAuditLogger();
+
+
+
+
+	public PolicyManagerImpl(DataCollector dc, Actuator ac)
+	{
+		init(dc,ac);
+	}
+	public void init(DataCollector dc, Actuator ac)
+	{
+
+
+		ActuatorFactory.registerActuator(ac);
+		DataCollectorFactory.registerDataCollector(dc);
+		_policyDataStore = new PolicyDataStoreImpl();
+		_policyEvaluator = new PolicyEvaluatorImpl();
+
+
+
+	}
+
+
+
+	public Map getAllPolicies() throws SPLException
+	{
+
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getAllPolicies");
+		Map allPolicies = _policyDataStore.getAllPolicies();
+		if(auditLogger.isLoggable(Level.FINE))
+			auditLogger.fine(Thread.currentThread().getName()+"getAllPolicies invoked");
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getAllPolicies");
+		return allPolicies;
+	}
+
+	public List getAllPolicyNames()  throws SPLException 
+	{
+
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getAllPolicyNames");
+		List allPolicyNames = _policyDataStore.getAllPolicyNames();
+		if(auditLogger.isLoggable(Level.FINE))
+			auditLogger.fine(Thread.currentThread().getName()+"getAllPolicyNames invoked");
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getAllPolicyNames");
+		return allPolicyNames;
+
+	}
+
+	public String getPolicy(String policyName) throws SPLException  
+	{
+
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getPolicy");
+		String ci = _policyDataStore.getPolicy(policyName);
+		if(auditLogger.isLoggable(Level.FINE))
+			auditLogger.fine(Thread.currentThread().getName()+"getPolicy invoked :"+policyName);
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getPolicy");
+		return ci;
+
+	}
+
+
+
+	public void shutdown() 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "shutdown");
+		if(auditLogger.isLoggable(Level.FINE))
+			auditLogger.fine(Thread.currentThread().getName()+"Policy Manager Shut Down initiated");
+
+		
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "shutdown");
+
+
+	}
+
+	public void updatePolicy(String policyName, String policyString) throws SPLException  
+	{
+
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "updatePolicy");
+		System.out.println("***********"+"UpdatePolicy : "+policyName+"***********");
+		_policyDataStore.updatePolicy(policyName, policyString);
+		if(auditLogger.isLoggable(Level.FINE))
+			auditLogger.fine(Thread.currentThread().getName()+"updatePolicy invoked :"+policyName);
+		System.out.println("***********"+"UpdatePolicy complete"+"***********");
+		
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "updatePolicy");
+
+
+	}
+
+	public boolean createPolicy(String policyName, String policyString) throws SPLException 
+	{
+		try
+		{
+			logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "createPolicy");
+			System.out.println("***********"+"CreatePolicy : "+policyName+"***********");
+			
+			boolean res = _policyDataStore.createPolicy(policyName,policyString);
+			if(auditLogger.isLoggable(Level.FINE))
+				auditLogger.fine(Thread.currentThread().getName()+"createPolicy invoked :"+policyName);
+			System.out.println("***********"+"CreatePolicy complete"+"***********");
+			
+			
+			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "createPolicy");
+
+			return res;
+		}
+		catch (SPLException e){
+			logger.severe(e.getLocalizedMessage());
+			e.printStackTrace();
+			throw new SPLException(e.getLocalizedMessage());
+
+		}
+
+
+	}
+
+	public void deletePolicy(String policyName) throws SPLException 
+	{
+		try
+		{
+			logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "deletePolicy");
+			System.out.println("***********"+"DeletePolicy : "+policyName+"***********");
+			
+			_policyDataStore.deletePolicy(policyName);
+			if(auditLogger.isLoggable(Level.FINE))
+				auditLogger.fine(Thread.currentThread().getName()+"deletePolicy invoked :"+policyName);
+
+			System.out.println("***********"+"DeletePolicy complete"+"***********");
+			
+			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "deletePolicy");
+		}
+		catch (SPLException e)
+		{
+			logger.severe(e.getLocalizedMessage());
+			e.printStackTrace();
+			throw new SPLException(e.getLocalizedMessage());
+
+		}
+
+	}
+
+	public Object evaluatePolicy(String policyName, Map instances) throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluatePolicy");
+
+		SPLPolicy internalPolicyObject = _policyDataStore.getInternalPolicyObject(policyName);
+
+
+		Object result = _policyEvaluator.evaluatePolicy(internalPolicyObject,instances);
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluatePolicy");
+
+		return result;
+	}
+	public PolicyInfo getPolicyInfo(String policyName) throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName() + " " + "getPolicyInfo");
+		PolicyInfo pi=this._policyDataStore.getPolicyInfo(policyName);
+		logger.exiting(sourceClass,Thread.currentThread().getName() + " " + "getPolicyInfo");
+
+		return pi;
+	}
+
+
+	public Object evaluatePolicyString(String policyName, String policyString, Map instances) throws SPLException 
+	{
+		try
+		{
+			logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "createPolicy");
+			Object result;
+//			boolean res = _policyDataStore.createPolicy(policyName,policyString);
+//			if(res)
+//			{
+//			SPLPolicy internalPolicyObject = _policyDataStore.getInternalPolicyObject(policyName);
+
+
+//			result = _policyEvaluator.evaluatePolicy(internalPolicyObject,instances);
+			SPLPolicy cp=_policyDataStore.createSPLPolicyObject(policyName, policyString);
+			result=_policyEvaluator.evaluatePolicy(cp, instances);
+			if(auditLogger.isLoggable(Level.FINE))
+				auditLogger.fine(Thread.currentThread().getName()+"evaluatePolicyString invoked :"+policyName);
+
+			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "createPolicy");
+
+//			}
+//			else
+//			{
+//			result=null;
+//			}
+
+			return result;
+		}
+		catch (SPLException e){
+			logger.severe(e.getLocalizedMessage());
+			e.printStackTrace();
+			throw new SPLException(e.getLocalizedMessage());
+
+		}
+
+
+	}
+	public void setSPLHome(String location) 
+	{
+		SPLLogger.SPL_HOME = location;
+
+	}
+	public String getSPLHome()
+	{
+		return SPLLogger.SPL_HOME;
+	}
+	public void enableLogging(boolean enableOrDisable) 
+	{
+		SPLLogger.ENABLE_SPL_LOGGING = enableOrDisable;
+
+	}
+
+	public boolean validatePolicyString(String policyString) throws SPLException
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName() + " " + "validatePolicyString");
+		boolean pi=this._policyDataStore.validatePolicyString(policyString);
+		logger.exiting(sourceClass,Thread.currentThread().getName() + " " + "validatePolicyString");
+
+		return pi;
+	}
+    
+
+}

Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/ASTWithLineNumber.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/ASTWithLineNumber.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/ASTWithLineNumber.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/ASTWithLineNumber.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+package org.apache.imperius.spl.parser.compiler;
+
+
+
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import antlr.*;
+import antlr.collections.*;
+import antlr.debug.misc.ASTFrame;
+
+/**
+ * CommonAST(default) from Antlr does not store line information.
+ * So we extend it, so use setASTNodeClass() to set it up in parser. 
+ */
+public class ASTWithLineNumber extends CommonAST {
+
+	private static final long serialVersionUID = 1L;
+	private int line_ = 0;
+
+	public void initialize(Token tok) {
+		super.initialize(tok);
+		line_ = tok.getLine();
+	}
+
+	public void initialize (AST ast) {
+		super.initialize(ast);
+		if (ast instanceof ASTWithLineNumber){
+			line_ = ((ASTWithLineNumber)ast).getLine();
+		}
+	}
+
+	public int getLine() {
+		return line_;
+	}
+	
+	public void displayTree(AST r){
+		final ASTFrame frame = new ASTFrame("Java AST", r);
+		frame.setVisible(true);
+		frame.addWindowListener(
+			new WindowAdapter() {
+               public void windowClosing (WindowEvent e) {
+                   frame.setVisible(true); // hide the Frame
+                   frame.dispose();
+                   System.exit(0);
+               }
+	        }
+		);
+	}
+}

Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/IdentPrimaryTuple.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/IdentPrimaryTuple.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/IdentPrimaryTuple.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/IdentPrimaryTuple.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,224 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.imperius.spl.external.DataCollector;
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.external.InstanceInfo;
+import org.apache.imperius.spl.parser.compiler.symboltable.MethodSymbol;
+import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
+import org.apache.imperius.spl.parser.compiler.symboltable.Symbol;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.statements.actions.impl.AnchorMethodInvokeAction;
+import org.apache.imperius.spl.parser.util.DataCollectorFactory;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+
+
+public class IdentPrimaryTuple 
+{
+	private Expression _arrExp = null;
+    private List _paramList ;
+    private String _identifier = "";
+    private boolean _isMethod = false;
+	private SPLSymbolTable _symbolTable;
+	private String _classType = null;
+    
+    public IdentPrimaryTuple(Expression arrExp, 
+    		List paramList, String id, boolean isMethod,
+    		SPLSymbolTable sTab)
+    {
+    	_arrExp = arrExp;
+    	_paramList = paramList;
+    	_identifier = id;
+    	_isMethod = isMethod;
+    	_symbolTable = sTab;
+    	
+    }
+    
+    public String getPropertyName()
+    {
+    	return _identifier;
+    }
+    
+    public void setSymbolTable(SPLSymbolTable spt)
+    {
+    	_symbolTable = spt;
+    }
+    // no input object means that the symbol table already has anchor object
+    // populated
+    public Object evaluate() throws SPLException
+    {
+    	Object returnValue = null;
+    	if(_isMethod)
+    	{
+    		Object instance = _symbolTable.getInstance(_classType);
+    		String qualifier = _symbolTable.getQualifierForClass(_classType);
+    		returnValue = AnchorMethodInvokeAction.invokeClassMethod(_symbolTable, 
+    		_classType, qualifier, _identifier, _paramList,instance);
+    	}
+    	else
+    	{
+    		Symbol sym = _symbolTable.getSymbol(_classType + "." + _identifier);
+    		returnValue = sym.getValue();
+    	}
+    	
+    	
+    	return returnValue;
+    	
+    }
+    public Object evaluate(Object parentObject) throws SPLException
+    {
+    	Object returnValue = null;
+    	
+    	DataCollector dc = DataCollectorFactory.getDataCollector();
+    	String qualifier = _symbolTable.getQualifierForClass(_classType);
+		Map symbolsofInstance = dc.getSymbolsForInstance(_classType,
+				qualifier,
+				parentObject);
+		Map instanceMap = new HashMap();
+		instanceMap.put(_classType, parentObject);
+		_symbolTable.populateInstanceValuesForInstance(_classType, 
+				_classType, 
+				parentObject, 
+				symbolsofInstance);
+    	
+		Symbol sym = _symbolTable.getSymbol(_classType + "." + _identifier);
+		
+    	//_symbolTable.setAnchors(mapOfAnchorClassToInstance);
+    	if(_isMethod)
+    	{
+    	
+    		returnValue = AnchorMethodInvokeAction.invokeClassMethod(_symbolTable, 
+    		_classType, qualifier, _identifier, _paramList, parentObject);
+    	}
+    	else
+    	{
+    		
+    		//Symbol sym = _symbolTable.getSymbol(_classType + "." + _identifier);
+    		returnValue = sym.getValue();
+    		
+    	}
+    	
+    	return returnValue;
+    }
+    
+	public TypeInfo validate(String classTypeOrVariableName) throws SPLException
+	{
+		TypeInfo typeInfo = new TypeInfo();
+		_classType = classTypeOrVariableName;
+		// ensure symbol table is populated
+		_populateSymbolTable(_classType);
+		
+		Symbol sym = _symbolTable.getSymbol(classTypeOrVariableName + "." + _identifier);
+		
+		if(_isMethod)
+		{
+			if(sym instanceof MethodSymbol)
+			{
+				typeInfo = _validateActualParameters(sym,classTypeOrVariableName);
+				
+			}
+			else
+			{
+				throw new SPLException("Symbol " + _identifier + "is not a method");
+			}
+		}
+		else
+		{
+			TypeInfo tp = sym.getType();
+			boolean isArray = sym.isArray();
+			if(_arrExp != null) // expression is like A.b[2] which means
+			{ // the result is not an array
+				isArray = false;
+			}
+			String resultClass = null;
+			if(TypeResolver.isReference(tp))
+			{
+				resultClass = sym.getReferenceTypeName();
+				typeInfo.setReferenceTypeName(resultClass);
+				typeInfo.setType(tp.getType());
+				typeInfo.setIsArray(isArray);
+			}
+			else
+			{
+				typeInfo.setType(tp.getType());
+				typeInfo.setIsArray(isArray);
+			}
+			
+		}
+		
+		
+		
+		return typeInfo;
+		
+	}
+
+	private TypeInfo _validateActualParameters(Symbol sym, 
+			String classType) throws SPLException
+	{
+		TypeInfo returnTypeInfo = new TypeInfo();
+		String returnClassName = null;
+		AnchorMethodInvokeAction.validateActualParameters(_symbolTable,
+	    		classType, _identifier, _paramList);
+		TypeInfo returnType = sym.getType();
+		boolean isArray = sym.isArray();
+		if(TypeResolver.isReference(returnType))
+		{
+			returnClassName = sym.getReferenceTypeName();
+			returnTypeInfo.setIsArray(isArray);
+			returnTypeInfo.setReferenceTypeName(returnClassName);
+			returnTypeInfo.setType(returnType.getType());
+			
+		}
+		else
+		{
+			returnTypeInfo.setIsArray(isArray);
+			returnTypeInfo.setType(returnType.getType());
+		}
+		return returnTypeInfo;
+		
+			
+		
+	}
+
+	private void _populateSymbolTable(String classType) throws SPLException 
+	{
+		String qualifierName = null;
+		if(_symbolTable.getAnchorData() == null)
+		{
+			List instanceInfoList = new ArrayList();
+			instanceInfoList.add(new InstanceInfo(classType, new Object()));
+			_symbolTable.addAnchor(classType,qualifierName,instanceInfoList);
+			
+		}
+		
+	}
+    
+
+}

Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,1701 @@
+// $ANTLR : "cimspl.g" -> "SPLLexer.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 java.io.InputStream;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.TokenStreamRecognitionException;
+import antlr.CharStreamException;
+import antlr.CharStreamIOException;
+import antlr.ANTLRException;
+import java.io.Reader;
+import java.util.Hashtable;
+import antlr.CharScanner;
+import antlr.InputBuffer;
+import antlr.ByteBuffer;
+import antlr.CharBuffer;
+import antlr.Token;
+import antlr.CommonToken;
+import antlr.RecognitionException;
+import antlr.NoViableAltForCharException;
+import antlr.MismatchedCharException;
+import antlr.TokenStream;
+import antlr.ANTLRHashString;
+import antlr.LexerSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.SemanticException;
+
+public class SPLLexer extends antlr.CharScanner implements cimsplTokenTypes, TokenStream
+ {
+public SPLLexer(InputStream in) {
+	this(new ByteBuffer(in));
+}
+public SPLLexer(Reader in) {
+	this(new CharBuffer(in));
+}
+public SPLLexer(InputBuffer ib) {
+	this(new LexerSharedInputState(ib));
+}
+public SPLLexer(LexerSharedInputState state) {
+	super(state);
+	caseSensitiveLiterals = true;
+	setCaseSensitive(true);
+	literals = new Hashtable();
+	literals.put(new ANTLRHashString("Import", this), new Integer(32));
+	literals.put(new ANTLRHashString("Uint64", this), new Integer(95));
+	literals.put(new ANTLRHashString("Sint8", this), new Integer(88));
+	literals.put(new ANTLRHashString("String", this), new Integer(100));
+	literals.put(new ANTLRHashString("Condition", this), new Integer(53));
+	literals.put(new ANTLRHashString("procedure", this), new Integer(50));
+	literals.put(new ANTLRHashString("DateTime", this), new Integer(101));
+	literals.put(new ANTLRHashString("Qualifier", this), new Integer(37));
+	literals.put(new ANTLRHashString("Name", this), new Integer(48));
+	literals.put(new ANTLRHashString("Class", this), new Integer(33));
+	literals.put(new ANTLRHashString("false", this), new Integer(71));
+	literals.put(new ANTLRHashString("argument", this), new Integer(51));
+	literals.put(new ANTLRHashString("true", this), new Integer(70));
+	literals.put(new ANTLRHashString("Self", this), new Integer(72));
+	literals.put(new ANTLRHashString("Sint16", this), new Integer(89));
+	literals.put(new ANTLRHashString("Real64", this), new Integer(97));
+	literals.put(new ANTLRHashString("collect", this), new Integer(75));
+	literals.put(new ANTLRHashString("Decision", this), new Integer(54));
+	literals.put(new ANTLRHashString("Policy", this), new Integer(52));
+	literals.put(new ANTLRHashString("Uint8", this), new Integer(90));
+	literals.put(new ANTLRHashString("Char16", this), new Integer(99));
+	literals.put(new ANTLRHashString("Sint64", this), new Integer(93));
+	literals.put(new ANTLRHashString("PolicyGroup", this), new Integer(87));
+	literals.put(new ANTLRHashString("Boolean", this), new Integer(98));
+	literals.put(new ANTLRHashString("Uint32", this), new Integer(94));
+	literals.put(new ANTLRHashString("Macro", this), new Integer(47));
+	literals.put(new ANTLRHashString("Execute_First_Applicable", this), new Integer(42));
+	literals.put(new ANTLRHashString("InvokePolicy", this), new Integer(86));
+	literals.put(new ANTLRHashString("Strategy", this), new Integer(40));
+	literals.put(new ANTLRHashString("type", this), new Integer(49));
+	literals.put(new ANTLRHashString("Declaration", this), new Integer(43));
+	literals.put(new ANTLRHashString("Set", this), new Integer(85));
+	literals.put(new ANTLRHashString("Reference", this), new Integer(102));
+	literals.put(new ANTLRHashString("Real32", this), new Integer(96));
+	literals.put(new ANTLRHashString("Execute_All_Applicable", this), new Integer(41));
+	literals.put(new ANTLRHashString("Sint32", this), new Integer(92));
+	literals.put(new ANTLRHashString("Uint16", this), new Integer(91));
+}
+
+public Token nextToken() throws TokenStreamException {
+	Token theRetToken=null;
+tryAgain:
+	for (;;) {
+		Token _token = null;
+		int _ttype = Token.INVALID_TYPE;
+		resetText();
+		try {   // for char stream error handling
+			try {   // for lexical error handling
+				switch ( LA(1)) {
+				case '(':
+				{
+					mLPAREN(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case ')':
+				{
+					mRPAREN(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '[':
+				{
+					mLBRACK(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case ']':
+				{
+					mRBRACK(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '{':
+				{
+					mLCURLY(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '}':
+				{
+					mRCURLY(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case ':':
+				{
+					mCOLON(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case ',':
+				{
+					mCOMMA(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '+':
+				{
+					mPLUS(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '*':
+				{
+					mSTAR(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '^':
+				{
+					mBXOR(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '&':
+				{
+					mLAND(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case ';':
+				{
+					mSEMI(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '\t':  case '\n':  case '\u000c':  case '\r':
+				case ' ':
+				{
+					mWS(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '\'':
+				{
+					mCHAR_LITERAL(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '"':
+				{
+					mSTRING_LITERAL(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				case '$':  case 'A':  case 'B':  case 'C':
+				case 'D':  case 'E':  case 'F':  case 'G':
+				case 'H':  case 'I':  case 'J':  case 'K':
+				case 'L':  case 'M':  case 'N':  case 'O':
+				case 'P':  case 'Q':  case 'R':  case 'S':
+				case 'T':  case 'U':  case 'V':  case 'W':
+				case 'X':  case 'Y':  case 'Z':  case '_':
+				case 'a':  case 'b':  case 'c':  case 'd':
+				case 'e':  case 'f':  case 'g':  case 'h':
+				case 'i':  case 'j':  case 'k':  case 'l':
+				case 'm':  case 'n':  case 'o':  case 'p':
+				case 'q':  case 'r':  case 's':  case 't':
+				case 'u':  case 'v':  case 'w':  case 'x':
+				case 'y':  case 'z':
+				{
+					mIDENT(true);
+					theRetToken=_returnToken;
+					break;
+				}
+				default:
+					if ((LA(1)=='=') && (LA(2)=='=')) {
+						mEQUAL(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='!') && (LA(2)=='=')) {
+						mNOT_EQUAL(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='>') && (LA(2)=='=')) {
+						mGE(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='<') && (LA(2)=='=')) {
+						mLE(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='|') && (LA(2)=='|')) {
+						mLOR(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='-') && (LA(2)=='>')) {
+						mARROW(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='/') && (LA(2)=='/')) {
+						mSL_COMMENT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='/') && (LA(2)=='*')) {
+						mML_COMMENT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='.') && (true) && (true) && (true)) {
+						mDOT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='=') && (true)) {
+						mASSIGN(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='!') && (true)) {
+						mLNOT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='/') && (true)) {
+						mDIV(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='-') && (true)) {
+						mMINUS(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='>') && (true)) {
+						mGT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='<') && (true)) {
+						mLT(true);
+						theRetToken=_returnToken;
+					}
+					else if ((LA(1)=='|') && (true)) {
+						mBOR(true);
+						theRetToken=_returnToken;
+					}
+					else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
+						mNUM_INT(true);
+						theRetToken=_returnToken;
+					}
+				else {
+					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
+				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+				}
+				}
+				if ( _returnToken==null ) continue tryAgain; // found SKIP token
+				_ttype = _returnToken.getType();
+				_returnToken.setType(_ttype);
+				return _returnToken;
+			}
+			catch (RecognitionException e) {
+				throw new TokenStreamRecognitionException(e);
+			}
+		}
+		catch (CharStreamException cse) {
+			if ( cse instanceof CharStreamIOException ) {
+				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
+			}
+			else {
+				throw new TokenStreamException(cse.getMessage());
+			}
+		}
+	}
+}
+
+	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LPAREN;
+		int _saveIndex;
+		
+		match('(');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = RPAREN;
+		int _saveIndex;
+		
+		match(')');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LBRACK;
+		int _saveIndex;
+		
+		match('[');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = RBRACK;
+		int _saveIndex;
+		
+		match(']');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LCURLY;
+		int _saveIndex;
+		
+		match('{');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = RCURLY;
+		int _saveIndex;
+		
+		match('}');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = COLON;
+		int _saveIndex;
+		
+		match(':');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = COMMA;
+		int _saveIndex;
+		
+		match(',');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = DOT;
+		int _saveIndex;
+		
+		match('.');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = ASSIGN;
+		int _saveIndex;
+		
+		match('=');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = EQUAL;
+		int _saveIndex;
+		
+		match("==");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LNOT;
+		int _saveIndex;
+		
+		match('!');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = NOT_EQUAL;
+		int _saveIndex;
+		
+		match("!=");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = DIV;
+		int _saveIndex;
+		
+		match('/');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = PLUS;
+		int _saveIndex;
+		
+		match('+');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = MINUS;
+		int _saveIndex;
+		
+		match('-');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = STAR;
+		int _saveIndex;
+		
+		match('*');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = GE;
+		int _saveIndex;
+		
+		match(">=");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = GT;
+		int _saveIndex;
+		
+		match(">");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LE;
+		int _saveIndex;
+		
+		match("<=");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LT;
+		int _saveIndex;
+		
+		match('<');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = BXOR;
+		int _saveIndex;
+		
+		match('^');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = BOR;
+		int _saveIndex;
+		
+		match('|');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LOR;
+		int _saveIndex;
+		
+		match("||");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = LAND;
+		int _saveIndex;
+		
+		match("&&");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = SEMI;
+		int _saveIndex;
+		
+		match(';');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mARROW(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = ARROW;
+		int _saveIndex;
+		
+		match("->");
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = WS;
+		int _saveIndex;
+		
+		{
+		int _cnt2770=0;
+		_loop2770:
+		do {
+			switch ( LA(1)) {
+			case ' ':
+			{
+				match(' ');
+				break;
+			}
+			case '\t':
+			{
+				match('\t');
+				break;
+			}
+			case '\u000c':
+			{
+				match('\f');
+				break;
+			}
+			case '\n':  case '\r':
+			{
+				{
+				if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
+					match("\r\n");
+				}
+				else if ((LA(1)=='\r') && (true) && (true) && (true)) {
+					match('\r');
+				}
+				else if ((LA(1)=='\n')) {
+					match('\n');
+				}
+				else {
+					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+				}
+				
+				}
+				if ( inputState.guessing==0 ) {
+					newline();
+				}
+				break;
+			}
+			default:
+			{
+				if ( _cnt2770>=1 ) { break _loop2770; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+			}
+			}
+			_cnt2770++;
+		} while (true);
+		}
+		if ( inputState.guessing==0 ) {
+			_ttype = Token.SKIP;
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = SL_COMMENT;
+		int _saveIndex;
+		
+		match("//");
+		{
+		_loop2774:
+		do {
+			if ((_tokenSet_1.member(LA(1)))) {
+				{
+				match(_tokenSet_1);
+				}
+			}
+			else {
+				break _loop2774;
+			}
+			
+		} while (true);
+		}
+		{
+		switch ( LA(1)) {
+		case '\n':
+		{
+			match('\n');
+			break;
+		}
+		case '\r':
+		{
+			match('\r');
+			{
+			if ((LA(1)=='\n')) {
+				match('\n');
+			}
+			else {
+			}
+			
+			}
+			break;
+		}
+		default:
+			{
+			}
+		}
+		}
+		if ( inputState.guessing==0 ) {
+			_ttype = Token.SKIP; newline();
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = ML_COMMENT;
+		int _saveIndex;
+		
+		match("/*");
+		{
+		_loop2780:
+		do {
+			if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0003' && LA(3) <= '\u00ff')) && ((LA(4) >= '\u0003' && LA(4) <= '\u00ff'))) {
+				match('\r');
+				match('\n');
+				if ( inputState.guessing==0 ) {
+					newline();
+				}
+			}
+			else if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0003' && LA(3) <= '\u00ff')))&&( LA(2)!='/' )) {
+				match('*');
+			}
+			else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0003' && LA(3) <= '\u00ff')) && (true)) {
+				match('\r');
+				if ( inputState.guessing==0 ) {
+					newline();
+				}
+			}
+			else if ((LA(1)=='\n')) {
+				match('\n');
+				if ( inputState.guessing==0 ) {
+					newline();
+				}
+			}
+			else if ((_tokenSet_2.member(LA(1)))) {
+				{
+				match(_tokenSet_2);
+				}
+			}
+			else {
+				break _loop2780;
+			}
+			
+		} while (true);
+		}
+		match("*/");
+		if ( inputState.guessing==0 ) {
+			_ttype = Token.SKIP;
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = CHAR_LITERAL;
+		int _saveIndex;
+		
+		match('\'');
+		{
+		if ((LA(1)=='\\')) {
+			mESC(false);
+		}
+		else if ((_tokenSet_3.member(LA(1)))) {
+			{
+			match(_tokenSet_3);
+			}
+		}
+		else {
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		
+		}
+		match('\'');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = ESC;
+		int _saveIndex;
+		
+		match('\\');
+		{
+		switch ( LA(1)) {
+		case 'n':
+		{
+			match('n');
+			break;
+		}
+		case 'r':
+		{
+			match('r');
+			break;
+		}
+		case 't':
+		{
+			match('t');
+			break;
+		}
+		case 'b':
+		{
+			match('b');
+			break;
+		}
+		case 'f':
+		{
+			match('f');
+			break;
+		}
+		case '"':
+		{
+			match('"');
+			break;
+		}
+		case '\'':
+		{
+			match('\'');
+			break;
+		}
+		case '\\':
+		{
+			match('\\');
+			break;
+		}
+		case 'u':
+		{
+			{
+			int _cnt2791=0;
+			_loop2791:
+			do {
+				if ((LA(1)=='u')) {
+					match('u');
+				}
+				else {
+					if ( _cnt2791>=1 ) { break _loop2791; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+				}
+				
+				_cnt2791++;
+			} while (true);
+			}
+			mHEX_DIGIT(false);
+			mHEX_DIGIT(false);
+			mHEX_DIGIT(false);
+			mHEX_DIGIT(false);
+			break;
+		}
+		case '0':  case '1':  case '2':  case '3':
+		{
+			matchRange('0','3');
+			{
+			if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_1.member(LA(2))) && (true) && (true)) {
+				matchRange('0','7');
+				{
+				if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_1.member(LA(2))) && (true) && (true)) {
+					matchRange('0','7');
+				}
+				else if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true)) {
+				}
+				else {
+					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+				}
+				
+				}
+			}
+			else if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true)) {
+			}
+			else {
+				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+			}
+			
+			}
+			break;
+		}
+		case '4':  case '5':  case '6':  case '7':
+		{
+			matchRange('4','7');
+			{
+			if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_1.member(LA(2))) && (true) && (true)) {
+				matchRange('0','7');
+			}
+			else if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true)) {
+			}
+			else {
+				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+			}
+			
+			}
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = STRING_LITERAL;
+		int _saveIndex;
+		
+		match('"');
+		{
+		_loop2787:
+		do {
+			if ((LA(1)=='\\')) {
+				mESC(false);
+			}
+			else if ((_tokenSet_4.member(LA(1)))) {
+				{
+				match(_tokenSet_4);
+				}
+			}
+			else {
+				break _loop2787;
+			}
+			
+		} while (true);
+		}
+		match('"');
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = HEX_DIGIT;
+		int _saveIndex;
+		
+		{
+		switch ( LA(1)) {
+		case '0':  case '1':  case '2':  case '3':
+		case '4':  case '5':  case '6':  case '7':
+		case '8':  case '9':
+		{
+			matchRange('0','9');
+			break;
+		}
+		case 'A':  case 'B':  case 'C':  case 'D':
+		case 'E':  case 'F':
+		{
+			matchRange('A','F');
+			break;
+		}
+		case 'a':  case 'b':  case 'c':  case 'd':
+		case 'e':  case 'f':
+		{
+			matchRange('a','f');
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = IDENT;
+		int _saveIndex;
+		
+		{
+		switch ( LA(1)) {
+		case 'a':  case 'b':  case 'c':  case 'd':
+		case 'e':  case 'f':  case 'g':  case 'h':
+		case 'i':  case 'j':  case 'k':  case 'l':
+		case 'm':  case 'n':  case 'o':  case 'p':
+		case 'q':  case 'r':  case 's':  case 't':
+		case 'u':  case 'v':  case 'w':  case 'x':
+		case 'y':  case 'z':
+		{
+			matchRange('a','z');
+			break;
+		}
+		case 'A':  case 'B':  case 'C':  case 'D':
+		case 'E':  case 'F':  case 'G':  case 'H':
+		case 'I':  case 'J':  case 'K':  case 'L':
+		case 'M':  case 'N':  case 'O':  case 'P':
+		case 'Q':  case 'R':  case 'S':  case 'T':
+		case 'U':  case 'V':  case 'W':  case 'X':
+		case 'Y':  case 'Z':
+		{
+			matchRange('A','Z');
+			break;
+		}
+		case '_':
+		{
+			match('_');
+			break;
+		}
+		case '$':
+		{
+			match('$');
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		}
+		{
+		_loop2800:
+		do {
+			switch ( LA(1)) {
+			case 'a':  case 'b':  case 'c':  case 'd':
+			case 'e':  case 'f':  case 'g':  case 'h':
+			case 'i':  case 'j':  case 'k':  case 'l':
+			case 'm':  case 'n':  case 'o':  case 'p':
+			case 'q':  case 'r':  case 's':  case 't':
+			case 'u':  case 'v':  case 'w':  case 'x':
+			case 'y':  case 'z':
+			{
+				matchRange('a','z');
+				break;
+			}
+			case 'A':  case 'B':  case 'C':  case 'D':
+			case 'E':  case 'F':  case 'G':  case 'H':
+			case 'I':  case 'J':  case 'K':  case 'L':
+			case 'M':  case 'N':  case 'O':  case 'P':
+			case 'Q':  case 'R':  case 'S':  case 'T':
+			case 'U':  case 'V':  case 'W':  case 'X':
+			case 'Y':  case 'Z':
+			{
+				matchRange('A','Z');
+				break;
+			}
+			case '_':
+			{
+				match('_');
+				break;
+			}
+			case '0':  case '1':  case '2':  case '3':
+			case '4':  case '5':  case '6':  case '7':
+			case '8':  case '9':
+			{
+				matchRange('0','9');
+				break;
+			}
+			case '$':
+			{
+				match('$');
+				break;
+			}
+			case '/':
+			{
+				match('/');
+				break;
+			}
+			default:
+			{
+				break _loop2800;
+			}
+			}
+		} while (true);
+		}
+		_ttype = testLiteralsTable(_ttype);
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = NUM_INT;
+		int _saveIndex;
+		Token f1=null;
+		Token f2=null;
+		Token f3=null;
+		Token f4=null;
+		boolean isDecimal=false; Token t=null;
+		
+		switch ( LA(1)) {
+		case '.':
+		{
+			match('.');
+			if ( inputState.guessing==0 ) {
+				_ttype = DOT;
+			}
+			{
+			if (((LA(1) >= '0' && LA(1) <= '9'))) {
+				{
+				int _cnt2804=0;
+				_loop2804:
+				do {
+					if (((LA(1) >= '0' && LA(1) <= '9'))) {
+						matchRange('0','9');
+					}
+					else {
+						if ( _cnt2804>=1 ) { break _loop2804; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+					}
+					
+					_cnt2804++;
+				} while (true);
+				}
+				{
+				if ((LA(1)=='E'||LA(1)=='e')) {
+					mEXPONENT(false);
+				}
+				else {
+				}
+				
+				}
+				{
+				if ((_tokenSet_5.member(LA(1)))) {
+					mFLOAT_SUFFIX(true);
+					f1=_returnToken;
+					if ( inputState.guessing==0 ) {
+						t=f1;
+					}
+				}
+				else {
+				}
+				
+				}
+				if ( inputState.guessing==0 ) {
+					
+									if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
+						_ttype = NUM_FLOAT;
+									}
+									else {
+						_ttype = NUM_DOUBLE; // assume double
+									}
+									
+				}
+			}
+			else {
+			}
+			
+			}
+			break;
+		}
+		case '0':  case '1':  case '2':  case '3':
+		case '4':  case '5':  case '6':  case '7':
+		case '8':  case '9':
+		{
+			{
+			switch ( LA(1)) {
+			case '0':
+			{
+				match('0');
+				if ( inputState.guessing==0 ) {
+					isDecimal = true;
+				}
+				{
+				if ((LA(1)=='X'||LA(1)=='x')) {
+					{
+					switch ( LA(1)) {
+					case 'x':
+					{
+						match('x');
+						break;
+					}
+					case 'X':
+					{
+						match('X');
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+					}
+					}
+					}
+					{
+					int _cnt2811=0;
+					_loop2811:
+					do {
+						if ((_tokenSet_6.member(LA(1))) && (true) && (true) && (true)) {
+							mHEX_DIGIT(false);
+						}
+						else {
+							if ( _cnt2811>=1 ) { break _loop2811; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+						}
+						
+						_cnt2811++;
+					} while (true);
+					}
+				}
+				else {
+					boolean synPredMatched2816 = false;
+					if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
+						int _m2816 = mark();
+						synPredMatched2816 = true;
+						inputState.guessing++;
+						try {
+							{
+							{
+							int _cnt2814=0;
+							_loop2814:
+							do {
+								if (((LA(1) >= '0' && LA(1) <= '9'))) {
+									matchRange('0','9');
+								}
+								else {
+									if ( _cnt2814>=1 ) { break _loop2814; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+								}
+								
+								_cnt2814++;
+							} while (true);
+							}
+							{
+							switch ( LA(1)) {
+							case '.':
+							{
+								match('.');
+								break;
+							}
+							case 'E':  case 'e':
+							{
+								mEXPONENT(false);
+								break;
+							}
+							case 'D':  case 'F':  case 'd':  case 'f':
+							{
+								mFLOAT_SUFFIX(false);
+								break;
+							}
+							default:
+							{
+								throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+							}
+							}
+							}
+							}
+						}
+						catch (RecognitionException pe) {
+							synPredMatched2816 = false;
+						}
+						rewind(_m2816);
+inputState.guessing--;
+					}
+					if ( synPredMatched2816 ) {
+						{
+						int _cnt2818=0;
+						_loop2818:
+						do {
+							if (((LA(1) >= '0' && LA(1) <= '9'))) {
+								matchRange('0','9');
+							}
+							else {
+								if ( _cnt2818>=1 ) { break _loop2818; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+							}
+							
+							_cnt2818++;
+						} while (true);
+						}
+					}
+					else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
+						{
+						int _cnt2820=0;
+						_loop2820:
+						do {
+							if (((LA(1) >= '0' && LA(1) <= '7'))) {
+								matchRange('0','7');
+							}
+							else {
+								if ( _cnt2820>=1 ) { break _loop2820; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+							}
+							
+							_cnt2820++;
+						} while (true);
+						}
+					}
+					else {
+					}
+					}
+					}
+					break;
+				}
+				case '1':  case '2':  case '3':  case '4':
+				case '5':  case '6':  case '7':  case '8':
+				case '9':
+				{
+					{
+					matchRange('1','9');
+					}
+					{
+					_loop2823:
+					do {
+						if (((LA(1) >= '0' && LA(1) <= '9'))) {
+							matchRange('0','9');
+						}
+						else {
+							break _loop2823;
+						}
+						
+					} while (true);
+					}
+					if ( inputState.guessing==0 ) {
+						isDecimal=true;
+					}
+					break;
+				}
+				default:
+				{
+					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+				}
+				}
+				}
+				{
+				if ((LA(1)=='L'||LA(1)=='l')) {
+					{
+					switch ( LA(1)) {
+					case 'l':
+					{
+						match('l');
+						break;
+					}
+					case 'L':
+					{
+						match('L');
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+					}
+					}
+					}
+					if ( inputState.guessing==0 ) {
+						_ttype = NUM_LONG;
+					}
+				}
+				else if (((_tokenSet_7.member(LA(1))))&&(isDecimal)) {
+					{
+					switch ( LA(1)) {
+					case '.':
+					{
+						match('.');
+						{
+						_loop2828:
+						do {
+							if (((LA(1) >= '0' && LA(1) <= '9'))) {
+								matchRange('0','9');
+							}
+							else {
+								break _loop2828;
+							}
+							
+						} while (true);
+						}
+						{
+						if ((LA(1)=='E'||LA(1)=='e')) {
+							mEXPONENT(false);
+						}
+						else {
+						}
+						
+						}
+						{
+						if ((_tokenSet_5.member(LA(1)))) {
+							mFLOAT_SUFFIX(true);
+							f2=_returnToken;
+							if ( inputState.guessing==0 ) {
+								t=f2;
+							}
+						}
+						else {
+						}
+						
+						}
+						break;
+					}
+					case 'E':  case 'e':
+					{
+						mEXPONENT(false);
+						{
+						if ((_tokenSet_5.member(LA(1)))) {
+							mFLOAT_SUFFIX(true);
+							f3=_returnToken;
+							if ( inputState.guessing==0 ) {
+								t=f3;
+							}
+						}
+						else {
+						}
+						
+						}
+						break;
+					}
+					case 'D':  case 'F':  case 'd':  case 'f':
+					{
+						mFLOAT_SUFFIX(true);
+						f4=_returnToken;
+						if ( inputState.guessing==0 ) {
+							t=f4;
+						}
+						break;
+					}
+					default:
+					{
+						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+					}
+					}
+					}
+					if ( inputState.guessing==0 ) {
+						
+									if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
+						_ttype = NUM_FLOAT;
+									}
+						else {
+							           	_ttype = NUM_DOUBLE; // assume double
+									}
+									
+					}
+				}
+				else {
+				}
+				
+				}
+				break;
+			}
+			default:
+			{
+				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+			}
+			}
+			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+				_token = makeToken(_ttype);
+				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+			}
+			_returnToken = _token;
+		}
+		
+	protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = EXPONENT;
+		int _saveIndex;
+		
+		{
+		switch ( LA(1)) {
+		case 'e':
+		{
+			match('e');
+			break;
+		}
+		case 'E':
+		{
+			match('E');
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		}
+		{
+		switch ( LA(1)) {
+		case '+':
+		{
+			match('+');
+			break;
+		}
+		case '-':
+		{
+			match('-');
+			break;
+		}
+		case '0':  case '1':  case '2':  case '3':
+		case '4':  case '5':  case '6':  case '7':
+		case '8':  case '9':
+		{
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		}
+		{
+		int _cnt2836=0;
+		_loop2836:
+		do {
+			if (((LA(1) >= '0' && LA(1) <= '9'))) {
+				matchRange('0','9');
+			}
+			else {
+				if ( _cnt2836>=1 ) { break _loop2836; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+			}
+			
+			_cnt2836++;
+		} while (true);
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+		int _ttype; Token _token=null; int _begin=text.length();
+		_ttype = FLOAT_SUFFIX;
+		int _saveIndex;
+		
+		switch ( LA(1)) {
+		case 'f':
+		{
+			match('f');
+			break;
+		}
+		case 'F':
+		{
+			match('F');
+			break;
+		}
+		case 'd':
+		{
+			match('d');
+			break;
+		}
+		case 'D':
+		{
+			match('D');
+			break;
+		}
+		default:
+		{
+			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+		}
+		}
+		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+			_token = makeToken(_ttype);
+			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+		}
+		_returnToken = _token;
+	}
+	
+	
+	private static final long[] mk_tokenSet_0() {
+		long[] data = { 288019269919178752L, 0L, 0L, 0L, 0L};
+		return data;
+	}
+	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
+	private static final long[] mk_tokenSet_1() {
+		long[] data = new long[8];
+		data[0]=-9224L;
+		for (int i = 1; i<=3; i++) { data[i]=-1L; }
+		return data;
+	}
+	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
+	private static final long[] mk_tokenSet_2() {
+		long[] data = new long[8];
+		data[0]=-4398046520328L;
+		for (int i = 1; i<=3; i++) { data[i]=-1L; }
+		return data;
+	}
+	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
+	private static final long[] mk_tokenSet_3() {
+		long[] data = new long[8];
+		data[0]=-549755823112L;
+		data[1]=-268435457L;
+		for (int i = 2; i<=3; i++) { data[i]=-1L; }
+		return data;
+	}
+	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
+	private static final long[] mk_tokenSet_4() {
+		long[] data = new long[8];
+		data[0]=-17179878408L;
+		data[1]=-268435457L;
+		for (int i = 2; i<=3; i++) { data[i]=-1L; }
+		return data;
+	}
+	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
+	private static final long[] mk_tokenSet_5() {
+		long[] data = { 0L, 343597383760L, 0L, 0L, 0L};
+		return data;
+	}
+	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
+	private static final long[] mk_tokenSet_6() {
+		long[] data = { 287948901175001088L, 541165879422L, 0L, 0L, 0L};
+		return data;
+	}
+	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
+	private static final long[] mk_tokenSet_7() {
+		long[] data = { 70368744177664L, 481036337264L, 0L, 0L, 0L};
+		return data;
+	}
+	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
+	
+	}

Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.smap
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.smap?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.smap (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/compiler/SPLLexer.smap Sat Dec 22 11:33:46 2007
@@ -0,0 +1,1086 @@
+/*
+ * 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.
+ */
+SMAP
+SPLLexer.java
+G
+*S G
+*F
++ 0 cimspl.g
+cimspl.g
+*L
+0:116
+0:122
+0:128
+0:134
+0:140
+0:146
+0:152
+0:158
+0:164
+0:170
+0:176
+0:182
+0:188
+0:195
+0:201
+0:207
+0:226
+0:232
+0:236
+0:240
+0:244
+0:248
+0:252
+0:256
+0:260
+0:264
+0:268
+0:272
+0:276
+0:280
+0:284
+0:288
+0:292
+0:296
+20:3
+20:4
+20:5
+20:6
+20:7
+20:8
+20:9
+20:10
+20:11
+20:12
+20:13
+20:14
+20:15
+20:16
+20:17
+20:19
+20:20
+20:21
+20:22
+20:23
+313:324
+313:325
+313:326
+313:327
+313:329
+313:330
+313:331
+313:332
+313:333
+313:334
+313:335
+314:337
+314:338
+314:339
+314:340
+314:342
+314:343
+314:344
+314:345
+314:346
+314:347
+314:348
+315:350
+315:351
+315:352
+315:353
+315:355
+315:356
+315:357
+315:358
+315:359
+315:360
+315:361
+316:363
+316:364
+316:365
+316:366
+316:368
+316:369
+316:370
+316:371
+316:372
+316:373
+316:374
+317:376
+317:377
+317:378
+317:379
+317:381
+317:382
+317:383
+317:384
+317:385
+317:386
+317:387
+318:389
+318:390
+318:391
+318:392
+318:394
+318:395
+318:396
+318:397
+318:398
+318:399
+318:400
+319:402
+319:403
+319:404
+319:405
+319:407
+319:408
+319:409
+319:410
+319:411
+319:412
+319:413
+320:415
+320:416
+320:417
+320:418
+320:420
+320:421
+320:422
+320:423
+320:424
+320:425
+320:426
+321:428
+321:429
+321:430
+321:431
+321:433
+321:434
+321:435
+321:436
+321:437
+321:438
+321:439
+322:441
+322:442
+322:443
+322:444
+322:446
+322:447
+322:448
+322:449
+322:450
+322:451
+322:452
+323:454
+323:455
+323:456
+323:457
+323:459
+323:460
+323:461
+323:462
+323:463
+323:464
+323:465
+324:467
+324:468
+324:469
+324:470
+324:472
+324:473
+324:474
+324:475
+324:476
+324:477
+324:478
+325:480
+325:481
+325:482
+325:483
+325:485
+325:486
+325:487
+325:488
+325:489
+325:490
+325:491
+326:493
+326:494
+326:495
+326:496
+326:498
+326:499
+326:500
+326:501
+326:502
+326:503
+326:504
+327:506
+327:507
+327:508
+327:509
+327:511
+327:512
+327:513
+327:514
+327:515
+327:516
+327:517
+328:519
+328:520
+328:521
+328:522
+328:524
+328:525
+328:526
+328:527
+328:528
+328:529
+328:530
+332:532
+332:533
+332:534
+332:535
+332:537
+332:538
+332:539
+332:540
+332:541
+332:542
+332:543
+333:545
+333:546
+333:547
+333:548
+333:550
+333:551
+333:552
+333:553
+333:554
+333:555
+333:556
+334:558
+334:559
+334:560
+334:561
+334:563
+334:564
+334:565
+334:566
+334:567
+334:568
+334:569
+335:571
+335:572
+335:573
+335:574
+335:576
+335:577
+335:578
+335:579
+335:580
+335:581
+335:582
+336:584
+336:585
+336:586
+336:587
+336:589
+336:590
+336:591
+336:592
+336:593
+336:594
+336:595
+337:597
+337:598
+337:599
+337:600
+337:602
+337:603
+337:604
+337:605
+337:606
+337:607
+337:608
+338:610
+338:611
+338:612
+338:613
+338:615
+338:616
+338:617
+338:618
+338:619
+338:620
+338:621
+340:623
+340:624
+340:625
+340:626
+340:628
+340:629
+340:630
+340:631
+340:632
+340:633
+340:634
+341:636
+341:637
+341:638
+341:639
+341:641
+341:642
+341:643
+341:644
+341:645
+341:646
+341:647
+342:649
+342:650
+342:651
+342:652
+342:654
+342:655
+342:656
+342:657
+342:658
+342:659
+342:660
+343:662
+343:663
+343:664
+343:665
+343:667
+343:668
+343:669
+343:670
+343:671
+343:672
+343:673
+345:675
+345:676
+345:677
+345:678
+345:681
+345:682
+345:683
+345:684
+345:685
+345:686
+345:687
+345:722
+345:723
+345:724
+345:725
+345:726
+345:727
+345:728
+345:729
+345:733
+345:734
+345:735
+345:736
+345:737
+345:738
+346:690
+346:691
+346:692
+347:695
+347:696
+347:697
+349:700
+349:701
+349:705
+349:708
+349:711
+349:712
+349:713
+349:714
+350:703
+350:704
+351:706
+351:707
+352:709
+352:710
+354:717
+354:718
+356:730
+356:731
+360:740
+360:741
+360:742
+360:743
+360:788
+360:789
+360:790
+360:791
+360:792
+360:793
+361:745
+362:746
+362:747
+362:748
+362:749
+362:751
+362:753
+362:754
+362:755
+362:756
+362:758
+362:759
+362:761
+362:762
+362:763
+362:764
+362:767
+362:768
+362:769
+362:771
+362:772
+362:773
+362:775
+362:780
+362:782
+362:783
+363:785
+363:786
+367:795
+367:796
+367:797
+367:798
+367:841
+367:842
+367:843
+367:844
+367:845
+367:846
+368:800
+369:801
+369:802
+369:803
+369:810
+369:813
+369:819
+369:825
+369:830
+369:831
+369:832
+369:833
+369:835
+369:836
+380:811
+380:812
+381:804
+381:805
+381:806
+381:807
+381:808
+382:814
+382:815
+382:816
+382:817
+383:820
+383:821
+383:822
+383:823
+384:826
+384:828
+386:837
+387:838
+387:839
+392:848
+392:849
+392:850
+392:851
+392:869
+392:870
+392:871
+392:872
+392:873
+392:874
+393:853
+393:855
+393:856
+393:857
+393:858
+393:860
+393:862
+393:863
+393:864
+393:865
+393:868
+397:1002
+397:1003
+397:1004
+397:1005
+397:1026
+397:1027
+397:1028
+397:1029
+397:1030
+397:1031
+398:1007
+398:1008
+398:1009
+398:1010
+398:1011
+398:1012
+398:1013
+398:1014
+398:1016
+398:1018
+398:1019
+398:1020
+398:1021
+398:1023
+398:1024
+398:1025
+412:876
+412:877
+412:878
+412:879
+412:995
+412:996
+412:997
+412:998
+412:999
+412:1000
+413:881
+414:883
+414:884
+414:885
+414:886
+414:989
+414:990
+414:991
+414:992
+414:993
+415:889
+415:890
+415:891
+416:894
+416:895
+416:896
+417:899
+417:900
+417:901
+418:904
+418:905
+418:906
+419:909
+419:910
+419:911
+420:914
+420:915
+420:916
+421:919
+421:920
+421:921
+422:924
+422:925
+422:927
+422:928
+422:929
+422:930
+422:931
+422:932
+422:933
+422:934
+422:935
+422:937
+422:938
+422:939
+422:940
+422:941
+422:942
+422:943
+423:946
+423:947
+423:948
+424:963
+424:965
+424:966
+424:967
+424:968
+428:950
+428:951
+429:955
+429:957
+429:958
+429:959
+429:960
+433:953
+433:954
+436:973
+436:974
+436:975
+437:979
+437:981
+437:982
+437:983
+437:984
+441:977
+441:978
+449:1033
+449:1034
+449:1035
+449:1036
+449:1065
+449:1066
+449:1067
+449:1068
+449:1069
+449:1070
+450:1039
+450:1040
+450:1041
+450:1042
+450:1043
+450:1044
+450:1047
+450:1048
+450:1049
+450:1050
+450:1053
+450:1054
+450:1055
+450:1056
+450:1059
+450:1060
+450:1061
+450:1062
+450:1063
+457:1072
+457:1073
+457:1074
+457:1075
+457:1172
+457:1173
+457:1174
+457:1175
+457:1176
+457:1177
+457:1178
+459:1078
+459:1079
+459:1080
+459:1081
+459:1082
+459:1083
+459:1084
+459:1085
+459:1086
+459:1087
+459:1090
+459:1091
+459:1092
+459:1093
+459:1094
+459:1095
+459:1096
+459:1097
+459:1098
+459:1101
+459:1102
+459:1103
+459:1106
+459:1107
+459:1108
+459:1111
+459:1112
+459:1113
+459:1114
+459:1115
+459:1117
+459:1118
+459:1119
+459:1120
+459:1121
+459:1122
+459:1123
+459:1124
+459:1125
+459:1126
+459:1127
+459:1128
+459:1129
+459:1132
+459:1133
+459:1134
+459:1135
+459:1136
+459:1137
+459:1138
+459:1139
+459:1140
+459:1143
+459:1144
+459:1145
+459:1148
+459:1149
+459:1150
+459:1151
+459:1152
+459:1155
+459:1156
+459:1157
+459:1160
+459:1161
+459:1162
+459:1165
+459:1166
+459:1167
+459:1168
+459:1169
+459:1170
+459:1171
+467:1180
+467:1181
+467:1182
+467:1183
+467:1188
+467:1190
+467:1531
+467:1532
+467:1533
+467:1534
+467:1535
+467:1536
+467:1537
+467:1538
+467:1539
+467:1540
+467:1541
+469:1191
+469:1192
+469:1193
+469:1194
+469:1195
+470:1184
+470:1198
+470:1200
+470:1201
+470:1202
+470:1203
+470:1204
+470:1205
+470:1206
+470:1207
+470:1208
+470:1210
+470:1211
+470:1212
+470:1214
+470:1215
+470:1216
+470:1218
+470:1222
+470:1223
+470:1224
+470:1225
+470:1226
+470:1228
+470:1230
+470:1243
+470:1245
+471:1233
+472:1235
+473:1236
+474:1237
+475:1238
+476:1239
+477:1240
+481:1250
+481:1251
+481:1252
+481:1253
+481:1255
+481:1256
+481:1257
+481:1258
+481:1259
+481:1260
+481:1412
+481:1413
+481:1414
+481:1415
+481:1416
+482:1263
+482:1265
+482:1266
+482:1267
+482:1268
+482:1271
+482:1272
+482:1273
+482:1276
+482:1277
+482:1278
+482:1279
+482:1280
+482:1296
+482:1365
+482:1381
+482:1383
+482:1384
+483:1283
+483:1284
+483:1285
+483:1288
+483:1289
+483:1290
+483:1291
+483:1293
+483:1294
+483:1295
+492:1286
+492:1287
+496:1297
+496:1298
+496:1299
+496:1300
+496:1301
+496:1302
+496:1303
+496:1306
+496:1307
+496:1308
+496:1309
+496:1310
+496:1311
+496:1312
+496:1313
+496:1314
+496:1316
+496:1317
+496:1318
+496:1320
+496:1321
+496:1322
+496:1323
+496:1326
+496:1327
+496:1328
+496:1331
+496:1332
+496:1333
+496:1336
+496:1337
+496:1338
+496:1339
+496:1340
+496:1343
+496:1344
+496:1345
+496:1346
+496:1347
+496:1348
+496:1349
+496:1350
+496:1352
+496:1353
+496:1354
+496:1355
+496:1356
+496:1357
+496:1358
+496:1359
+496:1360
+496:1362
+496:1363
+496:1364
+498:1366
+498:1368
+498:1369
+498:1370
+498:1371
+498:1372
+498:1373
+498:1374
+498:1375
+498:1376
+498:1378
+498:1379
+498:1380
+500:1388
+500:1389
+500:1390
+500:1391
+500:1393
+500:1395
+500:1396
+500:1397
+500:1398
+500:1399
+500:1400
+500:1401
+500:1402
+500:1403
+500:1405
+500:1406
+500:1407
+500:1408
+502:1419
+502:1421
+502:1422
+502:1423
+502:1424
+502:1427
+502:1428
+502:1429
+502:1432
+502:1433
+502:1434
+502:1435
+502:1436
+502:1438
+502:1439
+502:1441
+502:1524
+502:1526
+506:1185
+506:1442
+506:1444
+506:1445
+506:1446
+506:1447
+506:1448
+506:1449
+506:1450
+506:1451
+506:1452
+506:1453
+506:1454
+506:1455
+506:1456
+506:1458
+506:1459
+506:1461
+506:1462
+506:1463
+506:1465
+506:1469
+506:1470
+506:1471
+506:1472
+506:1473
+506:1475
+506:1477
+506:1508
+506:1509
+506:1510
+506:1511
+506:1512
+507:1186
+507:1482
+507:1483
+507:1484
+507:1486
+507:1487
+507:1488
+507:1489
+507:1490
+507:1492
+507:1494
+508:1187
+508:1499
+508:1500
+508:1501
+508:1502
+508:1503
+508:1504
+510:1514
+511:1516
+512:1517
+513:1518
+514:1519
+515:1520
+516:1521
+524:1543
+524:1544
+524:1545
+524:1546
+524:1604
+524:1605
+524:1606
+524:1607
+524:1608
+524:1609
+525:1549
+525:1550
+525:1551
+525:1552
+525:1555
+525:1556
+525:1557
+525:1560
+525:1561
+525:1562
+525:1563
+525:1564
+525:1567
+525:1568
+525:1569
+525:1570
+525:1573
+525:1574
+525:1575
+525:1584
+525:1585
+525:1586
+525:1587
+525:1588
+525:1591
+525:1592
+525:1593
+525:1594
+525:1595
+525:1596
+525:1597
+525:1598
+525:1599
+525:1601
+525:1602
+525:1603
+530:1611
+530:1612
+530:1613
+530:1614
+530:1616
+530:1637
+530:1638
+530:1639
+530:1640
+530:1641
+530:1642
+530:1643
+530:1644
+530:1645
+530:1646
+530:1647
+531:1617
+531:1618
+531:1619
+531:1622
+531:1623
+531:1624
+531:1627
+531:1628
+531:1629
+531:1632
+531:1633
+531:1634
+*E