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