Created
January 22, 2016 10:20
-
-
Save lzxz1234/3c5e8eacce9bab60bb06 to your computer and use it in GitHub Desktop.
Velocity 自动 escape 防 XSS 版
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package org.apache.velocity.runtime.parser.node; | |
import org.apache.commons.lang.StringEscapeUtils; | |
import org.apache.velocity.app.event.EventHandlerUtil; | |
import org.apache.velocity.context.Context; | |
import org.apache.velocity.context.InternalContextAdapter; | |
import org.apache.velocity.exception.MethodInvocationException; | |
import org.apache.velocity.exception.TemplateInitException; | |
import org.apache.velocity.exception.VelocityException; | |
import org.apache.velocity.runtime.Renderable; | |
import org.apache.velocity.runtime.RuntimeConstants; | |
import org.apache.velocity.runtime.directive.Block; | |
import org.apache.velocity.runtime.log.Log; | |
import org.apache.velocity.runtime.parser.Parser; | |
import org.apache.velocity.runtime.parser.Token; | |
import org.apache.velocity.util.ClassUtils; | |
import org.apache.velocity.util.introspection.Info; | |
import org.apache.velocity.util.introspection.VelMethod; | |
import org.apache.velocity.util.introspection.VelPropertySet; | |
import java.io.IOException; | |
import java.io.Writer; | |
import java.lang.reflect.InvocationTargetException; | |
/** | |
* @author lzxz1234 | |
* @version v1.0 | |
* @class ASTReference | |
*/ | |
public class ASTReference extends SimpleNode { | |
/* Reference types */ | |
private static final int NORMAL_REFERENCE = 1; | |
private static final int FORMAL_REFERENCE = 2; | |
private static final int QUIET_REFERENCE = 3; | |
private static final int RUNT = 4; | |
private int referenceType; | |
private String nullString; | |
private String rootString; | |
private boolean escaped = false; | |
private boolean computableReference = true; | |
private boolean logOnNull = true; | |
private String escPrefix = ""; | |
private String morePrefix = ""; | |
private String identifier = ""; | |
private String literal = null; | |
/** | |
* Indicates if we are running in strict reference mode. | |
*/ | |
public boolean strictRef = false; | |
/** | |
* non null Indicates if we are setting an index reference e.g, $foo[2], which basically | |
* means that the last syntax of the reference are brackets. | |
*/ | |
private ASTIndex astIndex = null; | |
/** | |
* Indicates if we are using modified escape behavior in strict mode. | |
* mainly we allow \$abc -> to render as $abc | |
*/ | |
public boolean strictEscape = false; | |
/** | |
* Indicates if toString() should be called during condition evaluation just | |
* to ensure it does not return null. Check is unnecessary if all toString() | |
* implementations are known to have non-null return values. Disabling the | |
* check will give a performance improval since toString() may be a complex | |
* operation on large objects. | |
*/ | |
public boolean toStringNullCheck = true; | |
private int numChildren = 0; | |
protected Info uberInfo; | |
/** | |
* @param id | |
*/ | |
public ASTReference(int id) { | |
super(id); | |
} | |
/** | |
* @param p | |
* @param id | |
*/ | |
public ASTReference(Parser p, int id) { | |
super(p, id); | |
} | |
/** | |
* @see org.apache.velocity.runtime.parser.node.SimpleNode#jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) | |
*/ | |
public Object jjtAccept(ParserVisitor visitor, Object data) { | |
return visitor.visit(this, data); | |
} | |
/** | |
* @see org.apache.velocity.runtime.parser.node.SimpleNode#init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object) | |
*/ | |
public Object init(InternalContextAdapter context, Object data) | |
throws TemplateInitException { | |
super.init(context, data); | |
strictEscape = rsvc.getBoolean(RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE, false); | |
strictRef = rsvc.getBoolean(RuntimeConstants.RUNTIME_REFERENCES_STRICT, false); | |
toStringNullCheck = rsvc.getBoolean(RuntimeConstants.DIRECTIVE_IF_TOSTRING_NULLCHECK, true); | |
/* | |
* the only thing we can do in init() is getRoot() | |
* as that is template based, not context based, | |
* so it's thread- and context-safe | |
*/ | |
rootString = getRoot().intern(); | |
numChildren = jjtGetNumChildren(); | |
// This is an expensive call, so get it now. | |
literal = literal(); | |
/* | |
* and if appropriate... | |
*/ | |
if (numChildren > 0) { | |
Node lastNode = jjtGetChild(numChildren - 1); | |
if (lastNode instanceof ASTIndex) | |
astIndex = (ASTIndex) lastNode; | |
else | |
identifier = lastNode.getFirstToken().image; | |
} | |
/* | |
* make an uberinfo - saves new's later on | |
*/ | |
uberInfo = new Info(getTemplateName(), getLine(), getColumn()); | |
/* | |
* track whether we log invalid references | |
*/ | |
logOnNull = | |
rsvc.getBoolean(RuntimeConstants.RUNTIME_LOG_REFERENCE_LOG_INVALID, true); | |
/** | |
* In the case we are referencing a variable with #if($foo) or | |
* #if( ! $foo) then we allow variables to be undefined and we | |
* set strictRef to false so that if the variable is undefined | |
* an exception is not thrown. | |
*/ | |
if (strictRef && numChildren == 0) { | |
logOnNull = false; // Strict mode allows nulls | |
Node node = this.jjtGetParent(); | |
if (node instanceof ASTNotNode // #if( ! $foo) | |
|| node instanceof ASTExpression // #if( $foo ) | |
|| node instanceof ASTOrNode // #if( $foo || ... | |
|| node instanceof ASTAndNode) // #if( $foo && ... | |
{ | |
// Now scan up tree to see if we are in an If statement | |
while (node != null) { | |
if (node instanceof ASTIfStatement) { | |
strictRef = false; | |
break; | |
} | |
node = node.jjtGetParent(); | |
} | |
} | |
} | |
return data; | |
} | |
/** | |
* Returns the 'root string', the reference key | |
* | |
* @return the root string. | |
*/ | |
public String getRootString() { | |
return rootString; | |
} | |
/** | |
* gets an Object that 'is' the value of the reference | |
* | |
* @param o unused Object parameter | |
* @param context context used to generate value | |
* @return The execution result. | |
* @throws MethodInvocationException | |
*/ | |
public Object execute(Object o, InternalContextAdapter context) | |
throws MethodInvocationException { | |
if (referenceType == RUNT) | |
return null; | |
/* | |
* get the root object from the context | |
*/ | |
Object result = getVariableValue(context, rootString); | |
if (result == null && !strictRef) { | |
return EventHandlerUtil.invalidGetMethod(rsvc, context, | |
getDollarBang() + rootString, null, null, uberInfo); | |
} | |
/* | |
* Iteratively work 'down' (it's flat...) the reference | |
* to get the value, but check to make sure that | |
* every result along the path is valid. For example: | |
* | |
* $hashtable.Customer.Name | |
* | |
* The $hashtable may be valid, but there is no key | |
* 'Customer' in the hashtable so we want to stop | |
* when we find a null value and return the null | |
* so the error gets logged. | |
*/ | |
try { | |
Object previousResult = result; | |
int failedChild = -1; | |
for (int i = 0; i < numChildren; i++) { | |
if (strictRef && result == null) { | |
/** | |
* At this point we know that an attempt is about to be made | |
* to call a method or property on a null value. | |
*/ | |
String name = jjtGetChild(i).getFirstToken().image; | |
throw new VelocityException("Attempted to access '" | |
+ name + "' on a null value at " | |
+ Log.formatFileString(uberInfo.getTemplateName(), | |
+jjtGetChild(i).getLine(), jjtGetChild(i).getColumn())); | |
} | |
previousResult = result; | |
result = jjtGetChild(i).execute(result, context); | |
if (result == null && !strictRef) // If strict and null then well catch this | |
// next time through the loop | |
{ | |
failedChild = i; | |
break; | |
} | |
} | |
if (result == null) { | |
if (failedChild == -1) { | |
result = EventHandlerUtil.invalidGetMethod(rsvc, context, | |
getDollarBang() + rootString, previousResult, null, uberInfo); | |
} else { | |
StringBuffer name = new StringBuffer(getDollarBang()).append(rootString); | |
for (int i = 0; i <= failedChild; i++) { | |
Node node = jjtGetChild(i); | |
if (node instanceof ASTMethod) { | |
name.append(".").append(((ASTMethod) node).getMethodName()).append("()"); | |
} else { | |
name.append(".").append(node.getFirstToken().image); | |
} | |
} | |
if (jjtGetChild(failedChild) instanceof ASTMethod) { | |
String methodName = ((ASTMethod) jjtGetChild(failedChild)).getMethodName(); | |
result = EventHandlerUtil.invalidMethod(rsvc, context, | |
name.toString(), previousResult, methodName, uberInfo); | |
} else { | |
String property = jjtGetChild(failedChild).getFirstToken().image; | |
result = EventHandlerUtil.invalidGetMethod(rsvc, context, | |
name.toString(), previousResult, property, uberInfo); | |
} | |
} | |
} | |
return result; | |
} catch (MethodInvocationException mie) { | |
mie.setReferenceName(rootString); | |
throw mie; | |
} | |
} | |
/** | |
* gets the value of the reference and outputs it to the | |
* writer. | |
* | |
* @param context context of data to use in getting value | |
* @param writer writer to render to | |
* @return True if rendering was successful. | |
* @throws IOException | |
* @throws MethodInvocationException | |
*/ | |
public boolean render(InternalContextAdapter context, Writer writer) throws IOException, | |
MethodInvocationException { | |
if (referenceType == RUNT) { | |
writer.write(rootString); | |
return true; | |
} | |
Object value = null; | |
if (escaped && strictEscape) { | |
/** | |
* If we are in strict mode and the variable is escaped, then don't bother to | |
* retreive the value since we won't use it. And if the var is not defined | |
* it will throw an exception. Set value to TRUE to fall through below with | |
* simply printing $foo, and not \$foo | |
*/ | |
value = Boolean.TRUE; | |
} else { | |
value = execute(null, context); | |
} | |
String localNullString = null; | |
/* | |
* if this reference is escaped (\$foo) then we want to do one of two things : 1) if this is | |
* a reference in the context, then we want to print $foo 2) if not, then \$foo (its | |
* considered schmoo, not VTL) | |
*/ | |
if (escaped) { | |
localNullString = getNullString(context); | |
if (value == null) { | |
writer.write(escPrefix); | |
writer.write("\\"); | |
writer.write(localNullString); | |
} else { | |
writer.write(escPrefix); | |
writer.write(localNullString); | |
} | |
return true; | |
} | |
/* | |
* the normal processing | |
* | |
* if we have an event cartridge, get a new value object | |
*/ | |
value = EventHandlerUtil.referenceInsert(rsvc, context, literal, value); | |
String toString = null; | |
if (value != null) { | |
if (value instanceof Renderable) { | |
Renderable renderable = (Renderable) value; | |
try { | |
if (renderable.render(context, writer)) | |
return true; | |
} catch (RuntimeException e) { | |
// We commonly get here when an error occurs within a block reference. | |
// We want to log where the reference is at so that a developer can easily | |
// know where the offending call is located. This can be seen | |
// as another element of the error stack we report to log. | |
log.error("Exception rendering " | |
+ ((renderable instanceof Block.Reference) ? "block " : "Renderable ") | |
+ rootString + " at " + Log.formatFileString(this)); | |
throw e; | |
} | |
} | |
toString = value.toString(); | |
} | |
if (value == null || toString == null) { | |
if (strictRef) { | |
if (referenceType != QUIET_REFERENCE) { | |
log.error("Prepend the reference with '$!' e.g., $!" + literal().substring(1) | |
+ " if you want Velocity to ignore the reference when it evaluates to null"); | |
if (value == null) { | |
throw new VelocityException("Reference " + literal() | |
+ " evaluated to null when attempting to render at " | |
+ Log.formatFileString(this)); | |
} else // toString == null | |
{ | |
// This will probably rarely happen, but when it does we want to | |
// inform the user that toString == null so they don't pull there | |
// hair out wondering why Velocity thinks the value is null. | |
throw new VelocityException("Reference " + literal() | |
+ " evaluated to object " + value.getClass().getName() | |
+ " whose toString() method returned null at " | |
+ Log.formatFileString(this)); | |
} | |
} | |
return true; | |
} | |
/* | |
* write prefix twice, because it's schmoo, so the \ don't escape each | |
* other... | |
*/ | |
localNullString = getNullString(context); | |
if (!strictEscape) { | |
// If in strict escape mode then we only print escape once. | |
// Yea, I know.. brittle stuff | |
writer.write(escPrefix); | |
} | |
writer.write(escPrefix); | |
writer.write(morePrefix); | |
writer.write(localNullString); | |
if (logOnNull && referenceType != QUIET_REFERENCE && log.isDebugEnabled()) { | |
log.debug("Null reference [template '" + getTemplateName() | |
+ "', line " + this.getLine() + ", column " + this.getColumn() + "] : " | |
+ this.literal() + " cannot be resolved."); | |
} | |
return true; | |
} else { | |
/* | |
* non-null processing | |
*/ | |
writer.write(escPrefix); | |
writer.write(morePrefix); | |
if(first.image.startsWith("$#")) | |
writer.write(toString); | |
else | |
writer.write(StringEscapeUtils.escapeHtml(toString)); | |
return true; | |
} | |
} | |
/** | |
* This method helps to implement the "render literal if null" functionality. | |
* <p/> | |
* VelocimacroProxy saves references to macro arguments (AST nodes) so that if we have a macro | |
* #foobar($a $b) then there is key "$a.literal" which points to the literal presentation of the | |
* argument provided to variable $a. If the value of $a is null, we render the string that was | |
* provided as the argument. | |
* | |
* @param context | |
* @return | |
*/ | |
private String getNullString(InternalContextAdapter context) { | |
Object callingArgument = context.get(".literal." + nullString); | |
if (callingArgument != null) | |
return ((Node) callingArgument).literal(); | |
else | |
return nullString; | |
} | |
/** | |
* Computes boolean value of this reference | |
* Returns the actual value of reference return type | |
* boolean, and 'true' if value is not null | |
* | |
* @param context context to compute value with | |
* @return True if evaluation was ok. | |
* @throws MethodInvocationException | |
*/ | |
public boolean evaluate(InternalContextAdapter context) | |
throws MethodInvocationException { | |
Object value = execute(null, context); | |
if (value == null) { | |
return false; | |
} else if (value instanceof Boolean) { | |
if (((Boolean) value).booleanValue()) | |
return true; | |
else | |
return false; | |
} else if (toStringNullCheck) { | |
try { | |
return value.toString() != null; | |
} catch (Exception e) { | |
throw new VelocityException("Reference evaluation threw an exception at " | |
+ Log.formatFileString(this), e); | |
} | |
} else { | |
return true; | |
} | |
} | |
/** | |
* @see org.apache.velocity.runtime.parser.node.SimpleNode#value(org.apache.velocity.context.InternalContextAdapter) | |
*/ | |
public Object value(InternalContextAdapter context) | |
throws MethodInvocationException { | |
return (computableReference ? execute(null, context) : null); | |
} | |
/** | |
* Utility class to handle nulls when printing a class type | |
*/ | |
public static String printClass(Class clazz) { | |
return clazz == null ? "null" : clazz.getName(); | |
} | |
/** | |
* Sets the value of a complex reference (something like $foo.bar) | |
* Currently used by ASTSetReference() | |
* | |
* @param context context object containing this reference | |
* @param value Object to set as value | |
* @return true if successful, false otherwise | |
* @throws MethodInvocationException | |
* @see ASTSetDirective | |
*/ | |
public boolean setValue(InternalContextAdapter context, Object value) | |
throws MethodInvocationException { | |
if (jjtGetNumChildren() == 0) { | |
context.put(rootString, value); | |
return true; | |
} | |
/* | |
* The rootOfIntrospection is the object we will | |
* retrieve from the Context. This is the base | |
* object we will apply reflection to. | |
*/ | |
Object result = getVariableValue(context, rootString); | |
if (result == null) { | |
String msg = "reference set is not a valid reference at " | |
+ Log.formatFileString(uberInfo); | |
log.error(msg); | |
return false; | |
} | |
/* | |
* How many child nodes do we have? | |
*/ | |
for (int i = 0; i < numChildren - 1; i++) { | |
result = jjtGetChild(i).execute(result, context); | |
if (result == null) { | |
if (strictRef) { | |
String name = jjtGetChild(i + 1).getFirstToken().image; | |
throw new MethodInvocationException("Attempted to access '" | |
+ name + "' on a null value", null, name, uberInfo.getTemplateName(), | |
jjtGetChild(i + 1).getLine(), jjtGetChild(i + 1).getColumn()); | |
} | |
String msg = "reference set is not a valid reference at " | |
+ Log.formatFileString(uberInfo); | |
log.error(msg); | |
return false; | |
} | |
} | |
if (astIndex != null) { | |
// If astIndex is not null then we are actually setting an index reference, | |
// something of the form $foo[1] =, or in general any reference that ends with | |
// the brackets. This means that we need to call a more general method | |
// of the form set(Integer, <something>), or put(Object, <something), where | |
// the first parameter is the index value and the second is the LHS of the set. | |
Object argument = astIndex.jjtGetChild(0).value(context); | |
// If negative, turn -1 into (size - 1) | |
argument = ASTIndex.adjMinusIndexArg(argument, result, context, astIndex); | |
Object[] params = {argument, value}; | |
Class[] paramClasses = {params[0] == null ? null : params[0].getClass(), | |
params[1] == null ? null : params[1].getClass()}; | |
String methodName = "set"; | |
VelMethod method = ClassUtils.getMethod(methodName, params, paramClasses, | |
result, context, astIndex, false); | |
if (method == null) { | |
// If we can't find a 'set' method, lets try 'put', This warrents a little | |
// investigation performance wise... if the user is using the hash | |
// form $foo["blaa"], then it may be expensive to first try and fail on 'set' | |
// then go to 'put'? The problem is that getMethod will try the cache, then | |
// perform introspection on 'result' for 'set' | |
methodName = "put"; | |
method = ClassUtils.getMethod(methodName, params, paramClasses, | |
result, context, astIndex, false); | |
} | |
if (method == null) { | |
// couldn't find set or put method, so bail | |
if (strictRef) { | |
throw new VelocityException( | |
"Found neither a 'set' or 'put' method with param types '(" | |
+ printClass(paramClasses[0]) + "," + printClass(paramClasses[1]) | |
+ ")' on class '" + result.getClass().getName() | |
+ "' at " + Log.formatFileString(astIndex)); | |
} | |
return false; | |
} | |
try { | |
method.invoke(result, params); | |
} catch (RuntimeException e) { | |
// Kludge since invoke throws Exception, pass up Runtimes | |
throw e; | |
} catch (Exception e) { | |
throw new MethodInvocationException( | |
"Exception calling method '" | |
+ methodName + "(" | |
+ printClass(paramClasses[0]) + "," + printClass(paramClasses[1]) | |
+ ")' in " + result.getClass(), | |
e.getCause(), identifier, astIndex.getTemplateName(), astIndex.getLine(), | |
astIndex.getColumn()); | |
} | |
return true; | |
} | |
/* | |
* We support two ways of setting the value in a #set($ref.foo = $value ) : | |
* 1) ref.setFoo( value ) | |
* 2) ref,put("foo", value ) to parallel the get() map introspection | |
*/ | |
try { | |
VelPropertySet vs = | |
rsvc.getUberspect().getPropertySet(result, identifier, | |
value, uberInfo); | |
if (vs == null) { | |
if (strictRef) { | |
throw new MethodInvocationException("Object '" + result.getClass().getName() + | |
"' does not contain property '" + identifier + "'", null, identifier, | |
uberInfo.getTemplateName(), uberInfo.getLine(), uberInfo.getColumn()); | |
} else { | |
return false; | |
} | |
} | |
vs.invoke(result, value); | |
} catch (InvocationTargetException ite) { | |
/* | |
* this is possible | |
*/ | |
throw new MethodInvocationException( | |
"ASTReference : Invocation of method '" | |
+ identifier + "' in " + result.getClass() | |
+ " threw exception " | |
+ ite.getTargetException().toString(), | |
ite.getTargetException(), identifier, getTemplateName(), this.getLine(), this.getColumn()); | |
} | |
/** | |
* pass through application level runtime exceptions | |
*/ catch (RuntimeException e) { | |
throw e; | |
} catch (Exception e) { | |
/* | |
* maybe a security exception? | |
*/ | |
String msg = "ASTReference setValue() : exception : " + e | |
+ " template at " + Log.formatFileString(uberInfo); | |
log.error(msg, e); | |
throw new VelocityException(msg, e); | |
} | |
return true; | |
} | |
private String getRoot() { | |
Token t = getFirstToken(); | |
/* | |
* we have a special case where something like | |
* $(\\)*!, where the user want's to see something | |
* like $!blargh in the output, but the ! prevents it from showing. | |
* I think that at this point, this isn't a reference. | |
*/ | |
/* so, see if we have "\\!" */ | |
int slashbang = t.image.indexOf("\\!"); | |
if (slashbang != -1) { | |
if (strictEscape) { | |
// If we are in strict escape mode, then we consider this type of | |
// pattern a non-reference, and we print it out as schmoo... | |
nullString = literal(); | |
escaped = true; | |
return literal(); | |
} | |
/* | |
* lets do all the work here. I would argue that if this occurrs, | |
* it's not a reference at all, so preceeding \ characters in front | |
* of the $ are just schmoo. So we just do the escape processing | |
* trick (even | odd) and move on. This kind of breaks the rule | |
* pattern of $ and # but '!' really tosses a wrench into things. | |
*/ | |
/* | |
* count the escapes : even # -> not escaped, odd -> escaped | |
*/ | |
int i = 0; | |
int len = t.image.length(); | |
i = t.image.indexOf('$'); | |
if (i == -1) { | |
/* yikes! */ | |
log.error("ASTReference.getRoot() : internal error : " | |
+ "no $ found for slashbang."); | |
computableReference = false; | |
nullString = t.image; | |
return nullString; | |
} | |
while (i < len && t.image.charAt(i) != '\\') { | |
i++; | |
} | |
/* ok, i is the first \ char */ | |
int start = i; | |
int count = 0; | |
while (i < len && t.image.charAt(i++) == '\\') { | |
count++; | |
} | |
/* | |
* now construct the output string. We really don't care about | |
* leading slashes as this is not a reference. It's quasi-schmoo | |
*/ | |
nullString = t.image.substring(0, start); // prefix up to the first | |
nullString += t.image.substring(start, start + count - 1); // get the slashes | |
nullString += t.image.substring(start + count); // and the rest, including the | |
/* | |
* this isn't a valid reference, so lets short circuit the value | |
* and set calcs | |
*/ | |
computableReference = false; | |
return nullString; | |
} | |
/* | |
* we need to see if this reference is escaped. if so | |
* we will clean off the leading \'s and let the | |
* regular behavior determine if we should output this | |
* as \$foo or $foo later on in render(). Lazyness.. | |
*/ | |
escaped = false; | |
if (t.image.startsWith("\\")) { | |
/* | |
* count the escapes : even # -> not escaped, odd -> escaped | |
*/ | |
int i = 0; | |
int len = t.image.length(); | |
while (i < len && t.image.charAt(i) == '\\') { | |
i++; | |
} | |
if ((i % 2) != 0) | |
escaped = true; | |
if (i > 0) | |
escPrefix = t.image.substring(0, i / 2); | |
t.image = t.image.substring(i); | |
} | |
/* | |
* Look for preceeding stuff like '#' and '$' | |
* and snip it off, except for the | |
* last $ | |
*/ | |
int loc1 = t.image.lastIndexOf('$'); | |
/* | |
* if we have extra stuff, loc > 0 | |
* ex. '#$foo' so attach that to | |
* the prefix. | |
*/ | |
if (loc1 > 0) { | |
morePrefix = morePrefix + t.image.substring(0, loc1); | |
t.image = t.image.substring(loc1); | |
} | |
/* | |
* Now it should be clean. Get the literal in case this reference | |
* isn't backed by the context at runtime, and then figure out what | |
* we are working with. | |
*/ | |
nullString = literal(); | |
if (t.image.startsWith("$!") || t.image.startsWith("$#")) { | |
referenceType = QUIET_REFERENCE; | |
/* | |
* only if we aren't escaped do we want to null the output | |
*/ | |
if (!escaped) | |
nullString = ""; | |
if (t.image.startsWith("$!{") || t.image.startsWith("$#{")) { | |
/* | |
* ex : $!{provider.Title} | |
*/ | |
return t.next.image; | |
} else { | |
/* | |
* ex : $!provider.Title | |
*/ | |
return t.image.substring(2); | |
} | |
} else if (t.image.equals("${")) { | |
/* | |
* ex : ${provider.Title} | |
*/ | |
referenceType = FORMAL_REFERENCE; | |
return t.next.image; | |
} else if (t.image.startsWith("$")) { | |
/* | |
* just nip off the '$' so we have | |
* the root | |
*/ | |
referenceType = NORMAL_REFERENCE; | |
return t.image.substring(1); | |
} else { | |
/* | |
* this is a 'RUNT', which can happen in certain circumstances where | |
* the parser is fooled into believeing that an IDENTIFIER is a real | |
* reference. Another 'dreaded' MORE hack :). | |
*/ | |
referenceType = RUNT; | |
return t.image; | |
} | |
} | |
/** | |
* @param context | |
* @param variable | |
* @return The evaluated value of the variable. | |
* @throws MethodInvocationException | |
*/ | |
public Object getVariableValue(Context context, String variable) throws MethodInvocationException { | |
Object obj = null; | |
try { | |
obj = context.get(variable); | |
} catch (RuntimeException e) { | |
log.error("Exception calling reference $" + variable + " at " | |
+ Log.formatFileString(uberInfo)); | |
throw e; | |
} | |
if (strictRef && obj == null) { | |
if (!context.containsKey(variable)) { | |
log.error("Variable $" + variable + " has not been set at " | |
+ Log.formatFileString(uberInfo)); | |
throw new MethodInvocationException("Variable $" + variable + | |
" has not been set", null, identifier, | |
uberInfo.getTemplateName(), uberInfo.getLine(), uberInfo.getColumn()); | |
} | |
} | |
return obj; | |
} | |
public String getDollarBang() { | |
return (referenceType == QUIET_REFERENCE) ? "$!" : "$"; | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */ | |
package org.apache.velocity.runtime.parser; | |
import java.io.*; | |
import java.util.*; | |
import org.apache.velocity.exception.VelocityException; | |
import org.apache.velocity.runtime.RuntimeServices; | |
import org.apache.velocity.runtime.parser.node.*; | |
import org.apache.velocity.runtime.directive.Directive; | |
import org.apache.velocity.runtime.directive.Macro; | |
import org.apache.velocity.runtime.directive.MacroParseException; | |
import org.apache.velocity.util.StringUtils; | |
import org.apache.commons.lang.text.StrBuilder; | |
import org.apache.velocity.runtime.RuntimeConstants; | |
/** Token Manager. */ | |
public class ParserTokenManager implements ParserConstants | |
{ | |
private int fileDepth = 0; | |
private int lparen = 0; | |
private int rparen = 0; | |
List stateStack = new ArrayList(50); | |
public boolean debugPrint = false; | |
private boolean inReference; | |
public boolean inDirective; | |
private boolean inComment; | |
public boolean inSet; | |
/** | |
* pushes the current state onto the 'state stack', | |
* and maintains the parens counts | |
* public because we need it in PD & VM handling | |
* | |
* @return boolean : success. It can fail if the state machine | |
* gets messed up (do don't mess it up :) | |
*/ | |
public boolean stateStackPop() | |
{ | |
ParserState s; | |
try | |
{ | |
s = (ParserState) stateStack.remove(stateStack.size() - 1); // stack.pop | |
} | |
catch(IndexOutOfBoundsException e) | |
{ | |
// empty stack | |
lparen=0; | |
SwitchTo(DEFAULT); | |
return false; | |
} | |
if( debugPrint ) | |
System.out.println( | |
" stack pop (" + stateStack.size() + ") : lparen=" + | |
s.lparen + | |
" newstate=" + s.lexstate ); | |
lparen = s.lparen; | |
rparen = s.rparen; | |
SwitchTo(s.lexstate); | |
return true; | |
} | |
/** | |
* pops a state off the stack, and restores paren counts | |
* | |
* @return boolean : success of operation | |
*/ | |
public boolean stateStackPush() | |
{ | |
if( debugPrint ) | |
System.out.println(" (" + stateStack.size() + ") pushing cur state : " + | |
curLexState ); | |
ParserState s = new ParserState(); | |
s.lparen = lparen; | |
s.rparen = rparen; | |
s.lexstate = curLexState; | |
lparen = 0; | |
stateStack.add(s); // stack.push | |
return true; | |
} | |
/** | |
* Clears all state variables, resets to | |
* start values, clears stateStack. Call | |
* before parsing. | |
*/ | |
public void clearStateVars() | |
{ | |
stateStack.clear(); | |
lparen = 0; | |
rparen = 0; | |
inReference = false; | |
inDirective = false; | |
inComment = false; | |
inSet = false; | |
return; | |
} | |
/** | |
* Holds the state of the parsing process. | |
*/ | |
private static class ParserState | |
{ | |
int lparen; | |
int rparen; | |
int lexstate; | |
} | |
/** | |
* handles the dropdown logic when encountering a RPAREN | |
*/ | |
private void RPARENHandler() | |
{ | |
/* | |
* Ultimately, we want to drop down to the state below | |
* the one that has an open (if we hit bottom (DEFAULT), | |
* that's fine. It's just text schmoo. | |
*/ | |
boolean closed = false; | |
if (inComment) | |
closed = true; | |
while( !closed ) | |
{ | |
/* | |
* look at current state. If we haven't seen a lparen | |
* in this state then we drop a state, because this | |
* lparen clearly closes our state | |
*/ | |
if( lparen > 0) | |
{ | |
/* | |
* if rparen + 1 == lparen, then this state is closed. | |
* Otherwise, increment and keep parsing | |
*/ | |
if( lparen == rparen + 1) | |
{ | |
stateStackPop(); | |
} | |
else | |
{ | |
rparen++; | |
} | |
closed = true; | |
} | |
else | |
{ | |
/* | |
* now, drop a state | |
*/ | |
if(!stateStackPop()) | |
break; | |
} | |
} | |
} | |
/** Debug output. */ | |
public java.io.PrintStream debugStream = System.out; | |
/** Set debug output. */ | |
public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } | |
private final int jjStopStringLiteralDfa_3(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1000000000L) != 0L) | |
return 105; | |
if ((active0 & 0x100L) != 0L) | |
return 69; | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 61; | |
return 67; | |
} | |
if ((active0 & 0x40L) != 0L) | |
return 62; | |
if ((active0 & 0x4000000000000L) != 0L) | |
return 54; | |
if ((active0 & 0x3a0000L) != 0L) | |
return 7; | |
return -1; | |
case 1: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 61; | |
jjmatchedPos = 1; | |
return 67; | |
} | |
if ((active0 & 0x80000L) != 0L) | |
return 5; | |
return -1; | |
case 2: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 61; | |
jjmatchedPos = 2; | |
return 67; | |
} | |
return -1; | |
case 3: | |
if ((active0 & 0x200000000L) != 0L) | |
return 67; | |
if ((active0 & 0x400000000L) != 0L) | |
{ | |
jjmatchedKind = 61; | |
jjmatchedPos = 3; | |
return 67; | |
} | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_3(int pos, long active0) | |
{ | |
return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1); | |
} | |
private int jjStopAtPos(int pos, int kind) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
return pos + 1; | |
} | |
private int jjMoveStringLiteralDfa0_3() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_3(0x2a0000L); | |
case 37: | |
return jjStopAtPos(0, 40); | |
case 40: | |
return jjStopAtPos(0, 10); | |
case 42: | |
return jjStopAtPos(0, 38); | |
case 43: | |
return jjStopAtPos(0, 37); | |
case 44: | |
return jjStopAtPos(0, 5); | |
case 45: | |
return jjStartNfaWithStates_3(0, 36, 105); | |
case 46: | |
return jjMoveStringLiteralDfa1_3(0x40L); | |
case 47: | |
return jjStopAtPos(0, 39); | |
case 58: | |
return jjStopAtPos(0, 7); | |
case 61: | |
return jjStartNfaWithStates_3(0, 50, 54); | |
case 91: | |
return jjStopAtPos(0, 3); | |
case 93: | |
return jjStopAtPos(0, 4); | |
case 102: | |
return jjMoveStringLiteralDfa1_3(0x400000000L); | |
case 116: | |
return jjMoveStringLiteralDfa1_3(0x200000000L); | |
case 123: | |
return jjStartNfaWithStates_3(0, 8, 69); | |
case 125: | |
return jjStopAtPos(0, 9); | |
default : | |
return jjMoveNfa_3(0, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_3(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_3(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x200000L) != 0L) | |
return jjStopAtPos(1, 21); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_3(1, 19, 5); | |
break; | |
case 46: | |
if ((active0 & 0x40L) != 0L) | |
return jjStopAtPos(1, 6); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_3(active0, 0x20000L); | |
case 97: | |
return jjMoveStringLiteralDfa2_3(active0, 0x400000000L); | |
case 114: | |
return jjMoveStringLiteralDfa2_3(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_3(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_3(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_3(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_3(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
case 108: | |
return jjMoveStringLiteralDfa3_3(active0, 0x400000000L); | |
case 117: | |
return jjMoveStringLiteralDfa3_3(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_3(1, active0); | |
} | |
private int jjMoveStringLiteralDfa3_3(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_3(1, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_3(2, active0); | |
return 3; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x200000000L) != 0L) | |
return jjStartNfaWithStates_3(3, 33, 67); | |
break; | |
case 115: | |
return jjMoveStringLiteralDfa4_3(active0, 0x400000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_3(2, active0); | |
} | |
private int jjMoveStringLiteralDfa4_3(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_3(2, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_3(3, active0); | |
return 4; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x400000000L) != 0L) | |
return jjStartNfaWithStates_3(4, 34, 67); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_3(3, active0); | |
} | |
private int jjStartNfaWithStates_3(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_3(state, pos + 1); | |
} | |
static final long[] jjbitVec0 = { | |
0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL | |
}; | |
static final long[] jjbitVec2 = { | |
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL | |
}; | |
private int jjMoveNfa_3(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 105; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 105: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(100, 101); | |
else if (curChar == 46) | |
jjCheckNAdd(62); | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(94, 95); | |
if ((0x3ff000000000000L & l) != 0L) | |
{ | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddTwoStates(91, 93); | |
} | |
break; | |
case 0: | |
if ((0x3ff000000000000L & l) != 0L) | |
{ | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(0, 5); | |
} | |
else if ((0x100002600L & l) != 0L) | |
{ | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(9); | |
} | |
else if (curChar == 45) | |
jjCheckNAddStates(6, 9); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(77, 78); | |
} | |
else if (curChar == 46) | |
jjCheckNAdd(62); | |
else if (curChar == 33) | |
{ | |
if (kind > 49) | |
kind = 49; | |
} | |
else if (curChar == 61) | |
jjstateSet[jjnewStateCnt++] = 54; | |
else if (curChar == 62) | |
jjstateSet[jjnewStateCnt++] = 52; | |
else if (curChar == 60) | |
jjstateSet[jjnewStateCnt++] = 49; | |
else if (curChar == 38) | |
jjstateSet[jjnewStateCnt++] = 39; | |
else if (curChar == 39) | |
jjCheckNAddStates(10, 13); | |
else if (curChar == 34) | |
jjCheckNAddStates(14, 17); | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 7; | |
else if (curChar == 41) | |
{ | |
if (kind > 11) | |
kind = 11; | |
jjCheckNAddStates(18, 20); | |
} | |
if ((0x2400L & l) != 0L) | |
{ | |
if (kind > 35) | |
kind = 35; | |
} | |
else if (curChar == 33) | |
jjstateSet[jjnewStateCnt++] = 58; | |
else if (curChar == 62) | |
{ | |
if (kind > 45) | |
kind = 45; | |
} | |
else if (curChar == 60) | |
{ | |
if (kind > 43) | |
kind = 43; | |
} | |
if (curChar == 13) | |
jjstateSet[jjnewStateCnt++] = 37; | |
break; | |
case 1: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddStates(18, 20); | |
break; | |
case 2: | |
if ((0x2400L & l) != 0L && kind > 11) | |
kind = 11; | |
break; | |
case 3: | |
if (curChar == 10 && kind > 11) | |
kind = 11; | |
break; | |
case 4: | |
if (curChar == 13) | |
jjstateSet[jjnewStateCnt++] = 3; | |
break; | |
case 5: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 6; | |
break; | |
case 6: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 7: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 8: | |
if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if ((0x100002600L & l) == 0L) | |
break; | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(9); | |
break; | |
case 10: | |
case 12: | |
if (curChar == 34) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 11: | |
if ((0xfffffffbffffffffL & l) != 0L) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 13: | |
if (curChar == 34) | |
jjstateSet[jjnewStateCnt++] = 12; | |
break; | |
case 14: | |
if (curChar == 34 && kind > 32) | |
kind = 32; | |
break; | |
case 17: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(21, 25); | |
break; | |
case 18: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 19: | |
if ((0xf000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 20; | |
break; | |
case 20: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAdd(18); | |
break; | |
case 22: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 23; | |
break; | |
case 23: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 24; | |
break; | |
case 24: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 25: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 26: | |
if (curChar == 32) | |
jjAddStates(26, 27); | |
break; | |
case 27: | |
if (curChar == 10) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 28: | |
case 30: | |
if (curChar == 39) | |
jjCheckNAddStates(10, 13); | |
break; | |
case 29: | |
if ((0xffffff7fffffffffL & l) != 0L) | |
jjCheckNAddStates(10, 13); | |
break; | |
case 31: | |
if (curChar == 39) | |
jjstateSet[jjnewStateCnt++] = 30; | |
break; | |
case 33: | |
if (curChar == 32) | |
jjAddStates(28, 29); | |
break; | |
case 34: | |
if (curChar == 10) | |
jjCheckNAddStates(10, 13); | |
break; | |
case 35: | |
if (curChar == 39 && kind > 32) | |
kind = 32; | |
break; | |
case 36: | |
if ((0x2400L & l) != 0L && kind > 35) | |
kind = 35; | |
break; | |
case 37: | |
if (curChar == 10 && kind > 35) | |
kind = 35; | |
break; | |
case 38: | |
if (curChar == 13) | |
jjstateSet[jjnewStateCnt++] = 37; | |
break; | |
case 39: | |
if (curChar == 38 && kind > 41) | |
kind = 41; | |
break; | |
case 40: | |
if (curChar == 38) | |
jjstateSet[jjnewStateCnt++] = 39; | |
break; | |
case 48: | |
if (curChar == 60 && kind > 43) | |
kind = 43; | |
break; | |
case 49: | |
if (curChar == 61 && kind > 44) | |
kind = 44; | |
break; | |
case 50: | |
if (curChar == 60) | |
jjstateSet[jjnewStateCnt++] = 49; | |
break; | |
case 51: | |
if (curChar == 62 && kind > 45) | |
kind = 45; | |
break; | |
case 52: | |
if (curChar == 61 && kind > 46) | |
kind = 46; | |
break; | |
case 53: | |
if (curChar == 62) | |
jjstateSet[jjnewStateCnt++] = 52; | |
break; | |
case 54: | |
if (curChar == 61 && kind > 47) | |
kind = 47; | |
break; | |
case 55: | |
if (curChar == 61) | |
jjstateSet[jjnewStateCnt++] = 54; | |
break; | |
case 58: | |
if (curChar == 61 && kind > 48) | |
kind = 48; | |
break; | |
case 59: | |
if (curChar == 33) | |
jjstateSet[jjnewStateCnt++] = 58; | |
break; | |
case 60: | |
if (curChar == 33 && kind > 49) | |
kind = 49; | |
break; | |
case 61: | |
if (curChar == 46) | |
jjCheckNAdd(62); | |
break; | |
case 62: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(62, 63); | |
break; | |
case 64: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(65); | |
break; | |
case 65: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(65); | |
break; | |
case 67: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 61) | |
kind = 61; | |
jjstateSet[jjnewStateCnt++] = 67; | |
break; | |
case 70: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjAddStates(30, 31); | |
break; | |
case 74: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 76: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(77, 78); | |
break; | |
case 78: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 79: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(77, 78); | |
break; | |
case 90: | |
if (curChar == 45) | |
jjCheckNAddStates(6, 9); | |
break; | |
case 91: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddTwoStates(91, 93); | |
break; | |
case 92: | |
if (curChar == 46 && kind > 56) | |
kind = 56; | |
break; | |
case 93: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 92; | |
break; | |
case 94: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(94, 95); | |
break; | |
case 95: | |
if (curChar != 46) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(96, 97); | |
break; | |
case 96: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(96, 97); | |
break; | |
case 98: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(99); | |
break; | |
case 99: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(99); | |
break; | |
case 100: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(100, 101); | |
break; | |
case 102: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(103); | |
break; | |
case 103: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(103); | |
break; | |
case 104: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(0, 5); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 0: | |
if ((0x7fffffe87ffffffL & l) != 0L) | |
{ | |
if (kind > 61) | |
kind = 61; | |
jjCheckNAdd(67); | |
} | |
else if (curChar == 92) | |
jjCheckNAddStates(32, 35); | |
else if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 69; | |
else if (curChar == 124) | |
jjstateSet[jjnewStateCnt++] = 44; | |
if (curChar == 110) | |
jjAddStates(36, 37); | |
else if (curChar == 103) | |
jjAddStates(38, 39); | |
else if (curChar == 108) | |
jjAddStates(40, 41); | |
else if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 56; | |
else if (curChar == 111) | |
jjstateSet[jjnewStateCnt++] = 46; | |
else if (curChar == 97) | |
jjstateSet[jjnewStateCnt++] = 42; | |
break; | |
case 6: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 11: | |
jjCheckNAddStates(14, 17); | |
break; | |
case 15: | |
if (curChar == 92) | |
jjAddStates(42, 47); | |
break; | |
case 16: | |
if ((0x14404400000000L & l) != 0L) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 21: | |
if (curChar == 117) | |
jjstateSet[jjnewStateCnt++] = 22; | |
break; | |
case 22: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 23; | |
break; | |
case 23: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 24; | |
break; | |
case 24: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 25: | |
if ((0x7e0000007eL & l) != 0L) | |
jjCheckNAddStates(14, 17); | |
break; | |
case 29: | |
jjAddStates(10, 13); | |
break; | |
case 32: | |
if (curChar == 92) | |
jjAddStates(28, 29); | |
break; | |
case 41: | |
if (curChar == 100 && kind > 41) | |
kind = 41; | |
break; | |
case 42: | |
if (curChar == 110) | |
jjstateSet[jjnewStateCnt++] = 41; | |
break; | |
case 43: | |
if (curChar == 97) | |
jjstateSet[jjnewStateCnt++] = 42; | |
break; | |
case 44: | |
if (curChar == 124 && kind > 42) | |
kind = 42; | |
break; | |
case 45: | |
if (curChar == 124) | |
jjstateSet[jjnewStateCnt++] = 44; | |
break; | |
case 46: | |
if (curChar == 114 && kind > 42) | |
kind = 42; | |
break; | |
case 47: | |
if (curChar == 111) | |
jjstateSet[jjnewStateCnt++] = 46; | |
break; | |
case 56: | |
if (curChar == 113 && kind > 47) | |
kind = 47; | |
break; | |
case 57: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 56; | |
break; | |
case 63: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(48, 49); | |
break; | |
case 66: | |
case 67: | |
if ((0x7fffffe87ffffffL & l) == 0L) | |
break; | |
if (kind > 61) | |
kind = 61; | |
jjCheckNAdd(67); | |
break; | |
case 68: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 69; | |
break; | |
case 69: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
jjCheckNAddTwoStates(70, 71); | |
break; | |
case 70: | |
if ((0x7fffffe87ffffffL & l) != 0L) | |
jjCheckNAddTwoStates(70, 71); | |
break; | |
case 71: | |
if (curChar == 125 && kind > 62) | |
kind = 62; | |
break; | |
case 72: | |
if (curChar == 92) | |
jjCheckNAddStates(32, 35); | |
break; | |
case 73: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(73, 74); | |
break; | |
case 75: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(75, 76); | |
break; | |
case 77: | |
if (curChar == 92) | |
jjAddStates(50, 51); | |
break; | |
case 80: | |
if (curChar == 108) | |
jjAddStates(40, 41); | |
break; | |
case 81: | |
if (curChar == 116 && kind > 43) | |
kind = 43; | |
break; | |
case 82: | |
if (curChar == 101 && kind > 44) | |
kind = 44; | |
break; | |
case 83: | |
if (curChar == 103) | |
jjAddStates(38, 39); | |
break; | |
case 84: | |
if (curChar == 116 && kind > 45) | |
kind = 45; | |
break; | |
case 85: | |
if (curChar == 101 && kind > 46) | |
kind = 46; | |
break; | |
case 86: | |
if (curChar == 110) | |
jjAddStates(36, 37); | |
break; | |
case 87: | |
if (curChar == 101 && kind > 48) | |
kind = 48; | |
break; | |
case 88: | |
if (curChar == 116 && kind > 49) | |
kind = 49; | |
break; | |
case 89: | |
if (curChar == 111) | |
jjstateSet[jjnewStateCnt++] = 88; | |
break; | |
case 97: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(52, 53); | |
break; | |
case 101: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(54, 55); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 6: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
case 11: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(14, 17); | |
break; | |
case 29: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(10, 13); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 105 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_11(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x3a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_11(int pos, long active0) | |
{ | |
return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_11() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_11(0x2a0000L); | |
default : | |
return jjMoveNfa_11(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_11(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_11(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x200000L) != 0L) | |
return jjStopAtPos(1, 21); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_11(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_11(active0, 0x20000L); | |
default : | |
break; | |
} | |
return jjStartNfa_11(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_11(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_11(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_11(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_11(1, active0); | |
} | |
private int jjStartNfaWithStates_11(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_11(state, pos + 1); | |
} | |
private int jjMoveNfa_11(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 83; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if ((0x3ff000000000000L & l) != 0L) | |
{ | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(56, 61); | |
} | |
else if (curChar == 45) | |
jjCheckNAddStates(62, 65); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(22, 23); | |
} | |
else if (curChar == 46) | |
jjCheckNAdd(7); | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 6: | |
if (curChar == 46) | |
jjCheckNAdd(7); | |
break; | |
case 7: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(7, 8); | |
break; | |
case 9: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(10); | |
break; | |
case 10: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(10); | |
break; | |
case 12: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 61) | |
kind = 61; | |
jjstateSet[jjnewStateCnt++] = 12; | |
break; | |
case 15: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjAddStates(66, 67); | |
break; | |
case 19: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 21: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(22, 23); | |
break; | |
case 23: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 24: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(22, 23); | |
break; | |
case 27: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddStates(68, 70); | |
break; | |
case 28: | |
if ((0x2400L & l) != 0L && kind > 51) | |
kind = 51; | |
break; | |
case 29: | |
if (curChar == 10 && kind > 51) | |
kind = 51; | |
break; | |
case 30: | |
case 47: | |
if (curChar == 13) | |
jjCheckNAdd(29); | |
break; | |
case 38: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddStates(71, 73); | |
break; | |
case 39: | |
if ((0x2400L & l) != 0L && kind > 54) | |
kind = 54; | |
break; | |
case 40: | |
if (curChar == 10 && kind > 54) | |
kind = 54; | |
break; | |
case 41: | |
case 63: | |
if (curChar == 13) | |
jjCheckNAdd(40); | |
break; | |
case 46: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddStates(74, 76); | |
break; | |
case 62: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddStates(77, 79); | |
break; | |
case 68: | |
if (curChar == 45) | |
jjCheckNAddStates(62, 65); | |
break; | |
case 69: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddTwoStates(69, 71); | |
break; | |
case 70: | |
if (curChar == 46 && kind > 56) | |
kind = 56; | |
break; | |
case 71: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 70; | |
break; | |
case 72: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(72, 73); | |
break; | |
case 73: | |
if (curChar != 46) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(74, 75); | |
break; | |
case 74: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(74, 75); | |
break; | |
case 76: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(77); | |
break; | |
case 77: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(77); | |
break; | |
case 78: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(78, 79); | |
break; | |
case 80: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(81); | |
break; | |
case 81: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(81); | |
break; | |
case 82: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(56, 61); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if ((0x7fffffe87ffffffL & l) != 0L) | |
{ | |
if (kind > 61) | |
kind = 61; | |
jjCheckNAdd(12); | |
} | |
else if (curChar == 123) | |
jjAddStates(80, 83); | |
else if (curChar == 92) | |
jjCheckNAddStates(84, 87); | |
if (curChar == 101) | |
jjAddStates(88, 90); | |
else if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 14; | |
else if (curChar == 105) | |
jjstateSet[jjnewStateCnt++] = 4; | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 4: | |
if (curChar == 102 && kind > 52) | |
kind = 52; | |
break; | |
case 5: | |
if (curChar == 105) | |
jjstateSet[jjnewStateCnt++] = 4; | |
break; | |
case 8: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(91, 92); | |
break; | |
case 11: | |
case 12: | |
if ((0x7fffffe87ffffffL & l) == 0L) | |
break; | |
if (kind > 61) | |
kind = 61; | |
jjCheckNAdd(12); | |
break; | |
case 13: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 14; | |
break; | |
case 14: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
jjCheckNAddTwoStates(15, 16); | |
break; | |
case 15: | |
if ((0x7fffffe87ffffffL & l) != 0L) | |
jjCheckNAddTwoStates(15, 16); | |
break; | |
case 16: | |
if (curChar == 125 && kind > 62) | |
kind = 62; | |
break; | |
case 17: | |
if (curChar == 92) | |
jjCheckNAddStates(84, 87); | |
break; | |
case 18: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(18, 19); | |
break; | |
case 20: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(20, 21); | |
break; | |
case 22: | |
if (curChar == 92) | |
jjAddStates(93, 94); | |
break; | |
case 25: | |
if (curChar == 101) | |
jjAddStates(88, 90); | |
break; | |
case 26: | |
if (curChar != 100) | |
break; | |
if (kind > 51) | |
kind = 51; | |
jjCheckNAddStates(68, 70); | |
break; | |
case 31: | |
if (curChar == 110) | |
jjstateSet[jjnewStateCnt++] = 26; | |
break; | |
case 32: | |
if (curChar == 102 && kind > 53) | |
kind = 53; | |
break; | |
case 33: | |
if (curChar == 105) | |
jjstateSet[jjnewStateCnt++] = 32; | |
break; | |
case 34: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 33; | |
break; | |
case 35: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 34; | |
break; | |
case 36: | |
if (curChar == 108) | |
jjstateSet[jjnewStateCnt++] = 35; | |
break; | |
case 37: | |
if (curChar != 101) | |
break; | |
if (kind > 54) | |
kind = 54; | |
jjCheckNAddStates(71, 73); | |
break; | |
case 42: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 37; | |
break; | |
case 43: | |
if (curChar == 108) | |
jjstateSet[jjnewStateCnt++] = 42; | |
break; | |
case 44: | |
if (curChar == 123) | |
jjAddStates(80, 83); | |
break; | |
case 45: | |
if (curChar != 125) | |
break; | |
if (kind > 51) | |
kind = 51; | |
jjCheckNAddStates(74, 76); | |
break; | |
case 48: | |
if (curChar == 100) | |
jjstateSet[jjnewStateCnt++] = 45; | |
break; | |
case 49: | |
if (curChar == 110) | |
jjstateSet[jjnewStateCnt++] = 48; | |
break; | |
case 50: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 49; | |
break; | |
case 51: | |
if (curChar == 125 && kind > 52) | |
kind = 52; | |
break; | |
case 52: | |
if (curChar == 102) | |
jjstateSet[jjnewStateCnt++] = 51; | |
break; | |
case 53: | |
if (curChar == 105) | |
jjstateSet[jjnewStateCnt++] = 52; | |
break; | |
case 54: | |
if (curChar == 125 && kind > 53) | |
kind = 53; | |
break; | |
case 55: | |
if (curChar == 102) | |
jjstateSet[jjnewStateCnt++] = 54; | |
break; | |
case 56: | |
if (curChar == 105) | |
jjstateSet[jjnewStateCnt++] = 55; | |
break; | |
case 57: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 56; | |
break; | |
case 58: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 57; | |
break; | |
case 59: | |
if (curChar == 108) | |
jjstateSet[jjnewStateCnt++] = 58; | |
break; | |
case 60: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 59; | |
break; | |
case 61: | |
if (curChar != 125) | |
break; | |
if (kind > 54) | |
kind = 54; | |
jjCheckNAddStates(77, 79); | |
break; | |
case 64: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 61; | |
break; | |
case 65: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 64; | |
break; | |
case 66: | |
if (curChar == 108) | |
jjstateSet[jjnewStateCnt++] = 65; | |
break; | |
case 67: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 66; | |
break; | |
case 75: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(95, 96); | |
break; | |
case 79: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(97, 98); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 83 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_8(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_8(int pos, long active0) | |
{ | |
return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_8() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_8(0xa0000L); | |
case 42: | |
return jjMoveStringLiteralDfa1_8(0x8000000L); | |
default : | |
return jjMoveNfa_8(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_8(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_8(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x8000000L) != 0L) | |
return jjStopAtPos(1, 27); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_8(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_8(active0, 0x20000L); | |
default : | |
break; | |
} | |
return jjStartNfa_8(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_8(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_8(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_8(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_8(1, active0); | |
} | |
private int jjStartNfaWithStates_8(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_8(state, pos + 1); | |
} | |
private int jjMoveNfa_8(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 12; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
} | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 6: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 8: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
case 10: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 11: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(99, 102); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 5: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(5, 6); | |
break; | |
case 7: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(7, 8); | |
break; | |
case 9: | |
if (curChar == 92) | |
jjAddStates(91, 92); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_6(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_6(int pos, long active0) | |
{ | |
return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_6() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_6(0xa0000L); | |
default : | |
return jjMoveNfa_6(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_6(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_6(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_6(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_6(active0, 0x20000L); | |
default : | |
break; | |
} | |
return jjStartNfa_6(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_6(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_6(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_6(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_6(1, active0); | |
} | |
private int jjStartNfaWithStates_6(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_6(state, pos + 1); | |
} | |
private int jjMoveNfa_6(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 12; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
} | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 6: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 8: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
case 10: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 11: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(99, 102); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 5: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(5, 6); | |
break; | |
case 7: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(7, 8); | |
break; | |
case 9: | |
if (curChar == 92) | |
jjAddStates(91, 92); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_5(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0xc00000L) != 0L) | |
return 20; | |
if ((active0 & 0x3a0000L) != 0L) | |
return 39; | |
return -1; | |
case 1: | |
if ((active0 & 0x400000L) != 0L) | |
return 40; | |
if ((active0 & 0x80000L) != 0L) | |
return 37; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_5(int pos, long active0) | |
{ | |
return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_5() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_5(0x2a0000L); | |
case 92: | |
jjmatchedKind = 23; | |
return jjMoveStringLiteralDfa1_5(0x400000L); | |
default : | |
return jjMoveNfa_5(13, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_5(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_5(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x200000L) != 0L) | |
return jjStopAtPos(1, 21); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_5(1, 19, 37); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_5(active0, 0x20000L); | |
case 92: | |
if ((active0 & 0x400000L) != 0L) | |
return jjStartNfaWithStates_5(1, 22, 40); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_5(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_5(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_5(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_5(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_5(1, active0); | |
} | |
private int jjStartNfaWithStates_5(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_5(state, pos + 1); | |
} | |
private int jjMoveNfa_5(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 40; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 39: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 37; | |
break; | |
case 40: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(33, 34); | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
} | |
break; | |
case 13: | |
if ((0xffffffe7ffffffffL & l) != 0L) | |
{ | |
if (kind > 24) | |
kind = 24; | |
jjCheckNAdd(12); | |
} | |
else if (curChar == 35) | |
jjCheckNAddStates(103, 105); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(33, 34); | |
} | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
else if (curChar == 36) | |
jjCheckNAddStates(106, 109); | |
break; | |
case 20: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(33, 34); | |
else if (curChar == 35) | |
jjAddStates(110, 111); | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
} | |
break; | |
case 0: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
break; | |
case 1: | |
if (curChar == 35) | |
jjCheckNAddTwoStates(6, 11); | |
break; | |
case 3: | |
if (curChar == 32) | |
jjAddStates(112, 113); | |
break; | |
case 4: | |
if (curChar == 40 && kind > 14) | |
kind = 14; | |
break; | |
case 12: | |
if ((0xffffffe7ffffffffL & l) == 0L) | |
break; | |
if (kind > 24) | |
kind = 24; | |
jjCheckNAdd(12); | |
break; | |
case 15: | |
case 16: | |
if (curChar == 33) | |
jjCheckNAdd(14); | |
break; | |
case 18: | |
if (curChar == 46 && kind > 72) | |
kind = 72; | |
break; | |
case 21: | |
if (curChar == 35) | |
jjAddStates(110, 111); | |
break; | |
case 23: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 13) | |
kind = 13; | |
jjstateSet[jjnewStateCnt++] = 23; | |
break; | |
case 26: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjAddStates(26, 27); | |
break; | |
case 30: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 32: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(33, 34); | |
break; | |
case 34: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 35: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(33, 34); | |
break; | |
case 36: | |
if (curChar == 35) | |
jjCheckNAddStates(103, 105); | |
break; | |
case 37: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 38; | |
break; | |
case 38: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 39: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
else if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 40: | |
if (curChar == 92) | |
jjAddStates(114, 115); | |
if (curChar == 92) | |
jjCheckNAddTwoStates(31, 32); | |
if (curChar == 92) | |
jjCheckNAddTwoStates(29, 30); | |
break; | |
case 13: | |
if ((0xffffffffefffffffL & l) != 0L) | |
{ | |
if (kind > 24) | |
kind = 24; | |
jjCheckNAdd(12); | |
} | |
else if (curChar == 92) | |
jjCheckNAddStates(116, 119); | |
if (curChar == 92) | |
jjAddStates(114, 115); | |
break; | |
case 20: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(31, 32); | |
if (curChar == 92) | |
jjCheckNAddTwoStates(29, 30); | |
if (curChar == 92) | |
jjstateSet[jjnewStateCnt++] = 19; | |
break; | |
case 2: | |
if (curChar == 116) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 5: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 6: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 7: | |
if (curChar == 125) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 8: | |
if (curChar == 116) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 8; | |
break; | |
case 10: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 9; | |
break; | |
case 11: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
break; | |
case 12: | |
if ((0xffffffffefffffffL & l) == 0L) | |
break; | |
if (kind > 24) | |
kind = 24; | |
jjCheckNAdd(12); | |
break; | |
case 14: | |
if (curChar == 91 && kind > 72) | |
kind = 72; | |
break; | |
case 17: | |
if (curChar == 92) | |
jjstateSet[jjnewStateCnt++] = 16; | |
break; | |
case 19: | |
if (curChar == 92) | |
jjAddStates(114, 115); | |
break; | |
case 22: | |
case 23: | |
if ((0x7fffffe87ffffffL & l) == 0L) | |
break; | |
if (kind > 13) | |
kind = 13; | |
jjCheckNAdd(23); | |
break; | |
case 24: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 25: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
jjCheckNAddTwoStates(26, 27); | |
break; | |
case 26: | |
if ((0x7fffffe87ffffffL & l) != 0L) | |
jjCheckNAddTwoStates(26, 27); | |
break; | |
case 27: | |
if (curChar == 125 && kind > 13) | |
kind = 13; | |
break; | |
case 28: | |
if (curChar == 92) | |
jjCheckNAddStates(116, 119); | |
break; | |
case 29: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(29, 30); | |
break; | |
case 31: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(31, 32); | |
break; | |
case 33: | |
if (curChar == 92) | |
jjAddStates(28, 29); | |
break; | |
case 38: | |
if (kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 13: | |
case 12: | |
if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
break; | |
if (kind > 24) | |
kind = 24; | |
jjCheckNAdd(12); | |
break; | |
case 38: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 40 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_9(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_9(int pos, long active0) | |
{ | |
return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_9() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_9(0xa0000L); | |
case 42: | |
return jjMoveStringLiteralDfa1_9(0x4000000L); | |
default : | |
return jjMoveNfa_9(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_9(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_9(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x4000000L) != 0L) | |
return jjStopAtPos(1, 26); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_9(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_9(active0, 0x20000L); | |
default : | |
break; | |
} | |
return jjStartNfa_9(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_9(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_9(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_9(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_9(1, active0); | |
} | |
private int jjStartNfaWithStates_9(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_9(state, pos + 1); | |
} | |
private int jjMoveNfa_9(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 12; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
} | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 6: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 8: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
case 10: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 11: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(99, 102); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 5: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(5, 6); | |
break; | |
case 7: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(7, 8); | |
break; | |
case 9: | |
if (curChar == 92) | |
jjAddStates(91, 92); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_2(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_2(int pos, long active0) | |
{ | |
return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_2() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_2(0xa0000L); | |
case 93: | |
return jjStopAtPos(0, 2); | |
case 102: | |
return jjMoveStringLiteralDfa1_2(0x400000000L); | |
case 116: | |
return jjMoveStringLiteralDfa1_2(0x200000000L); | |
default : | |
return jjMoveNfa_2(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_2(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_2(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_2(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_2(active0, 0x20000L); | |
case 97: | |
return jjMoveStringLiteralDfa2_2(active0, 0x400000000L); | |
case 114: | |
return jjMoveStringLiteralDfa2_2(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_2(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_2(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_2(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_2(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
case 108: | |
return jjMoveStringLiteralDfa3_2(active0, 0x400000000L); | |
case 117: | |
return jjMoveStringLiteralDfa3_2(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_2(1, active0); | |
} | |
private int jjMoveStringLiteralDfa3_2(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_2(1, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_2(2, active0); | |
return 3; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x200000000L) != 0L) | |
return jjStopAtPos(3, 33); | |
break; | |
case 115: | |
return jjMoveStringLiteralDfa4_2(active0, 0x400000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_2(2, active0); | |
} | |
private int jjMoveStringLiteralDfa4_2(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_2(2, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_2(3, active0); | |
return 4; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x400000000L) != 0L) | |
return jjStopAtPos(4, 34); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_2(3, active0); | |
} | |
private int jjStartNfaWithStates_2(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_2(state, pos + 1); | |
} | |
private int jjMoveNfa_2(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 59; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if ((0x3ff000000000000L & l) != 0L) | |
{ | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(120, 125); | |
} | |
else if ((0x100002600L & l) != 0L) | |
{ | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(4); | |
} | |
else if (curChar == 45) | |
jjCheckNAddStates(126, 129); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(41, 42); | |
} | |
else if (curChar == 46) | |
jjCheckNAdd(32); | |
else if (curChar == 39) | |
jjCheckNAddStates(130, 133); | |
else if (curChar == 34) | |
jjCheckNAddStates(134, 137); | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 4: | |
if ((0x100002600L & l) == 0L) | |
break; | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(4); | |
break; | |
case 5: | |
case 7: | |
if (curChar == 34) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 6: | |
if ((0xfffffffbffffffffL & l) != 0L) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 8: | |
if (curChar == 34) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if (curChar == 34 && kind > 32) | |
kind = 32; | |
break; | |
case 12: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(138, 142); | |
break; | |
case 13: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 14: | |
if ((0xf000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 15; | |
break; | |
case 15: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAdd(13); | |
break; | |
case 17: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 18; | |
break; | |
case 18: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 19; | |
break; | |
case 19: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 20; | |
break; | |
case 20: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 21: | |
if (curChar == 32) | |
jjAddStates(143, 144); | |
break; | |
case 22: | |
if (curChar == 10) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 23: | |
case 25: | |
if (curChar == 39) | |
jjCheckNAddStates(130, 133); | |
break; | |
case 24: | |
if ((0xffffff7fffffffffL & l) != 0L) | |
jjCheckNAddStates(130, 133); | |
break; | |
case 26: | |
if (curChar == 39) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 28: | |
if (curChar == 32) | |
jjAddStates(145, 146); | |
break; | |
case 29: | |
if (curChar == 10) | |
jjCheckNAddStates(130, 133); | |
break; | |
case 30: | |
if (curChar == 39 && kind > 32) | |
kind = 32; | |
break; | |
case 31: | |
if (curChar == 46) | |
jjCheckNAdd(32); | |
break; | |
case 32: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(32, 33); | |
break; | |
case 34: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(35); | |
break; | |
case 35: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(35); | |
break; | |
case 38: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 40: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(41, 42); | |
break; | |
case 42: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 43: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(41, 42); | |
break; | |
case 44: | |
if (curChar == 45) | |
jjCheckNAddStates(126, 129); | |
break; | |
case 45: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddTwoStates(45, 47); | |
break; | |
case 46: | |
if (curChar == 46 && kind > 56) | |
kind = 56; | |
break; | |
case 47: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 46; | |
break; | |
case 48: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(48, 49); | |
break; | |
case 49: | |
if (curChar != 46) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(50, 51); | |
break; | |
case 50: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(50, 51); | |
break; | |
case 52: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(53); | |
break; | |
case 53: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(53); | |
break; | |
case 54: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(54, 55); | |
break; | |
case 56: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(57); | |
break; | |
case 57: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(57); | |
break; | |
case 58: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(120, 125); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(147, 150); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 6: | |
jjCheckNAddStates(134, 137); | |
break; | |
case 10: | |
if (curChar == 92) | |
jjAddStates(151, 156); | |
break; | |
case 11: | |
if ((0x14404400000000L & l) != 0L) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 16: | |
if (curChar == 117) | |
jjstateSet[jjnewStateCnt++] = 17; | |
break; | |
case 17: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 18; | |
break; | |
case 18: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 19; | |
break; | |
case 19: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 20; | |
break; | |
case 20: | |
if ((0x7e0000007eL & l) != 0L) | |
jjCheckNAddStates(134, 137); | |
break; | |
case 24: | |
jjAddStates(130, 133); | |
break; | |
case 27: | |
if (curChar == 92) | |
jjAddStates(145, 146); | |
break; | |
case 33: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(157, 158); | |
break; | |
case 37: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(37, 38); | |
break; | |
case 39: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(39, 40); | |
break; | |
case 41: | |
if (curChar == 92) | |
jjAddStates(159, 160); | |
break; | |
case 51: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(161, 162); | |
break; | |
case 55: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(163, 164); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
case 6: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(134, 137); | |
break; | |
case 24: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(130, 133); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_10(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_10(int pos, long active0) | |
{ | |
return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_10() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_10(0xa0000L); | |
default : | |
return jjMoveNfa_10(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_10(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_10(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_10(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_10(active0, 0x20000L); | |
default : | |
break; | |
} | |
return jjStartNfa_10(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_10(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_10(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_10(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_10(1, active0); | |
} | |
private int jjStartNfaWithStates_10(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_10(state, pos + 1); | |
} | |
private int jjMoveNfa_10(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 15; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if ((0x2400L & l) != 0L) | |
{ | |
if (kind > 25) | |
kind = 25; | |
} | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(12, 13); | |
} | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
if (curChar == 13) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 4: | |
if ((0x2400L & l) != 0L && kind > 25) | |
kind = 25; | |
break; | |
case 5: | |
if (curChar == 10 && kind > 25) | |
kind = 25; | |
break; | |
case 6: | |
if (curChar == 13) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 9: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 11: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(12, 13); | |
break; | |
case 13: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 14: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(12, 13); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(165, 168); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 8: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(8, 9); | |
break; | |
case 10: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(10, 11); | |
break; | |
case 12: | |
if (curChar == 92) | |
jjAddStates(169, 170); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x3a0000L) != 0L) | |
return 33; | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
return 13; | |
} | |
return -1; | |
case 1: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 1; | |
return 13; | |
} | |
if ((active0 & 0x80000L) != 0L) | |
return 31; | |
return -1; | |
case 2: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 2; | |
return 13; | |
} | |
return -1; | |
case 3: | |
if ((active0 & 0x200000000L) != 0L) | |
return 13; | |
if ((active0 & 0x400000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 3; | |
return 13; | |
} | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_0(int pos, long active0, long active1) | |
{ | |
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_0() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_0(0x2a0000L); | |
case 91: | |
return jjStopAtPos(0, 1); | |
case 102: | |
return jjMoveStringLiteralDfa1_0(0x400000000L); | |
case 116: | |
return jjMoveStringLiteralDfa1_0(0x200000000L); | |
case 123: | |
return jjStopAtPos(0, 68); | |
case 125: | |
return jjStopAtPos(0, 69); | |
default : | |
return jjMoveNfa_0(12, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_0(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_0(0, active0, 0L); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x200000L) != 0L) | |
return jjStopAtPos(1, 21); | |
break; | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_0(1, 19, 31); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_0(active0, 0x20000L); | |
case 97: | |
return jjMoveStringLiteralDfa2_0(active0, 0x400000000L); | |
case 114: | |
return jjMoveStringLiteralDfa2_0(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_0(0, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa2_0(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_0(0, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_0(1, active0, 0L); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
case 108: | |
return jjMoveStringLiteralDfa3_0(active0, 0x400000000L); | |
case 117: | |
return jjMoveStringLiteralDfa3_0(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_0(1, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa3_0(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_0(1, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_0(2, active0, 0L); | |
return 3; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x200000000L) != 0L) | |
return jjStartNfaWithStates_0(3, 33, 13); | |
break; | |
case 115: | |
return jjMoveStringLiteralDfa4_0(active0, 0x400000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_0(2, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa4_0(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_0(2, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_0(3, active0, 0L); | |
return 4; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x400000000L) != 0L) | |
return jjStartNfaWithStates_0(4, 34, 13); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_0(3, active0, 0L); | |
} | |
private int jjStartNfaWithStates_0(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_0(state, pos + 1); | |
} | |
private int jjMoveNfa_0(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 34; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 12: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
else if (curChar == 35) | |
jjCheckNAddStates(171, 173); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(27, 28); | |
} | |
else if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 15; | |
if (curChar == 36) | |
jjCheckNAddStates(174, 177); | |
break; | |
case 33: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 31; | |
break; | |
case 0: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
break; | |
case 1: | |
if (curChar == 35) | |
jjCheckNAddTwoStates(6, 11); | |
break; | |
case 3: | |
if (curChar == 32) | |
jjAddStates(112, 113); | |
break; | |
case 4: | |
if (curChar == 40 && kind > 14) | |
kind = 14; | |
break; | |
case 13: | |
if ((0x3ff200000000000L & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjstateSet[jjnewStateCnt++] = 13; | |
break; | |
case 14: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 15; | |
break; | |
case 16: | |
if (curChar == 36) | |
jjCheckNAddStates(174, 177); | |
break; | |
case 18: | |
case 19: | |
if (curChar == 33) | |
jjCheckNAdd(17); | |
break; | |
case 21: | |
if (curChar == 46 && kind > 72) | |
kind = 72; | |
break; | |
case 24: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 26: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(27, 28); | |
break; | |
case 28: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 29: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(27, 28); | |
break; | |
case 30: | |
if (curChar == 35) | |
jjCheckNAddStates(171, 173); | |
break; | |
case 31: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 32; | |
break; | |
case 32: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 12: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
{ | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(13); | |
} | |
else if (curChar == 92) | |
jjCheckNAddStates(178, 181); | |
break; | |
case 33: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
else if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 2: | |
if (curChar == 116) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 5: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 6: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 7: | |
if (curChar == 125) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 8: | |
if (curChar == 116) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 8; | |
break; | |
case 10: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 9; | |
break; | |
case 11: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
break; | |
case 13: | |
if ((0x7fffffe87fffffeL & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(13); | |
break; | |
case 15: | |
if ((0x7fffffe07fffffeL & l) != 0L && kind > 67) | |
kind = 67; | |
break; | |
case 17: | |
if (curChar == 91 && kind > 72) | |
kind = 72; | |
break; | |
case 20: | |
if (curChar == 92) | |
jjstateSet[jjnewStateCnt++] = 19; | |
break; | |
case 22: | |
if (curChar == 92) | |
jjCheckNAddStates(178, 181); | |
break; | |
case 23: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(23, 24); | |
break; | |
case 25: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(25, 26); | |
break; | |
case 27: | |
if (curChar == 92) | |
jjAddStates(182, 183); | |
break; | |
case 32: | |
if (kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 32: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_4(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 52; | |
if ((active0 & 0x40L) != 0L) | |
return 74; | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
return 40; | |
} | |
return -1; | |
case 1: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 1; | |
return 40; | |
} | |
if ((active0 & 0x80000L) != 0L) | |
return 50; | |
return -1; | |
case 2: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 2; | |
return 40; | |
} | |
return -1; | |
case 3: | |
if ((active0 & 0x200000000L) != 0L) | |
return 40; | |
if ((active0 & 0x400000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 3; | |
return 40; | |
} | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_4(int pos, long active0) | |
{ | |
return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_4() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_4(0xa0000L); | |
case 41: | |
return jjStopAtPos(0, 12); | |
case 44: | |
return jjStopAtPos(0, 5); | |
case 46: | |
return jjMoveStringLiteralDfa1_4(0x40L); | |
case 58: | |
return jjStopAtPos(0, 7); | |
case 91: | |
return jjStopAtPos(0, 3); | |
case 93: | |
return jjStopAtPos(0, 4); | |
case 102: | |
return jjMoveStringLiteralDfa1_4(0x400000000L); | |
case 116: | |
return jjMoveStringLiteralDfa1_4(0x200000000L); | |
case 123: | |
return jjStopAtPos(0, 8); | |
case 125: | |
return jjStopAtPos(0, 9); | |
default : | |
return jjMoveNfa_4(13, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_4(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_4(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_4(1, 19, 50); | |
break; | |
case 46: | |
if ((active0 & 0x40L) != 0L) | |
return jjStopAtPos(1, 6); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_4(active0, 0x20000L); | |
case 97: | |
return jjMoveStringLiteralDfa2_4(active0, 0x400000000L); | |
case 114: | |
return jjMoveStringLiteralDfa2_4(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_4(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_4(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_4(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_4(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
case 108: | |
return jjMoveStringLiteralDfa3_4(active0, 0x400000000L); | |
case 117: | |
return jjMoveStringLiteralDfa3_4(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_4(1, active0); | |
} | |
private int jjMoveStringLiteralDfa3_4(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_4(1, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_4(2, active0); | |
return 3; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x200000000L) != 0L) | |
return jjStartNfaWithStates_4(3, 33, 40); | |
break; | |
case 115: | |
return jjMoveStringLiteralDfa4_4(active0, 0x400000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_4(2, active0); | |
} | |
private int jjMoveStringLiteralDfa4_4(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_4(2, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_4(3, active0); | |
return 4; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x400000000L) != 0L) | |
return jjStartNfaWithStates_4(4, 34, 40); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_4(3, active0); | |
} | |
private int jjStartNfaWithStates_4(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_4(state, pos + 1); | |
} | |
private int jjMoveNfa_4(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 75; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 52: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 50; | |
break; | |
case 74: | |
case 64: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(64, 65); | |
break; | |
case 13: | |
if ((0x3ff000000000000L & l) != 0L) | |
{ | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(184, 189); | |
} | |
else if ((0x100002600L & l) != 0L) | |
{ | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(12); | |
} | |
else if (curChar == 46) | |
jjCheckNAddTwoStates(64, 74); | |
else if (curChar == 45) | |
jjCheckNAddStates(190, 193); | |
else if (curChar == 35) | |
jjCheckNAddStates(194, 196); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(46, 47); | |
} | |
else if (curChar == 39) | |
jjCheckNAddStates(197, 200); | |
else if (curChar == 34) | |
jjCheckNAddStates(201, 204); | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
break; | |
case 0: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
break; | |
case 1: | |
if (curChar == 35) | |
jjCheckNAddTwoStates(6, 11); | |
break; | |
case 3: | |
if (curChar == 32) | |
jjAddStates(112, 113); | |
break; | |
case 4: | |
if (curChar == 40 && kind > 14) | |
kind = 14; | |
break; | |
case 12: | |
if ((0x100002600L & l) == 0L) | |
break; | |
if (kind > 31) | |
kind = 31; | |
jjCheckNAdd(12); | |
break; | |
case 14: | |
if ((0xfffffffbffffffffL & l) != 0L) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 15: | |
if (curChar == 34) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 16: | |
if (curChar == 34) | |
jjstateSet[jjnewStateCnt++] = 15; | |
break; | |
case 17: | |
if (curChar == 34 && kind > 32) | |
kind = 32; | |
break; | |
case 20: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(205, 209); | |
break; | |
case 21: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 22: | |
if ((0xf000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 23; | |
break; | |
case 23: | |
if ((0xff000000000000L & l) != 0L) | |
jjCheckNAdd(21); | |
break; | |
case 25: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 26; | |
break; | |
case 26: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 27; | |
break; | |
case 27: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 28; | |
break; | |
case 28: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 29: | |
if (curChar == 32) | |
jjAddStates(210, 211); | |
break; | |
case 30: | |
if (curChar == 10) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 31: | |
case 33: | |
if (curChar == 39) | |
jjCheckNAddStates(197, 200); | |
break; | |
case 32: | |
if ((0xffffff7fffffffffL & l) != 0L) | |
jjCheckNAddStates(197, 200); | |
break; | |
case 34: | |
if (curChar == 39) | |
jjstateSet[jjnewStateCnt++] = 33; | |
break; | |
case 36: | |
if (curChar == 32) | |
jjAddStates(212, 213); | |
break; | |
case 37: | |
if (curChar == 10) | |
jjCheckNAddStates(197, 200); | |
break; | |
case 38: | |
if (curChar == 39 && kind > 32) | |
kind = 32; | |
break; | |
case 40: | |
if ((0x3ff200000000000L & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjstateSet[jjnewStateCnt++] = 40; | |
break; | |
case 43: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 45: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(46, 47); | |
break; | |
case 47: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 48: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(46, 47); | |
break; | |
case 49: | |
if (curChar == 35) | |
jjCheckNAddStates(194, 196); | |
break; | |
case 50: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 51; | |
break; | |
case 51: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 53: | |
if (curChar == 45) | |
jjCheckNAddStates(190, 193); | |
break; | |
case 54: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddTwoStates(54, 56); | |
break; | |
case 55: | |
if (curChar == 46 && kind > 56) | |
kind = 56; | |
break; | |
case 56: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 55; | |
break; | |
case 57: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(57, 58); | |
break; | |
case 58: | |
if (curChar != 46) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(59, 60); | |
break; | |
case 59: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAddTwoStates(59, 60); | |
break; | |
case 61: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(62); | |
break; | |
case 62: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(62); | |
break; | |
case 63: | |
if (curChar == 46) | |
jjCheckNAdd(64); | |
break; | |
case 66: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(67); | |
break; | |
case 67: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(67); | |
break; | |
case 68: | |
if ((0x3ff000000000000L & l) != 0L) | |
jjCheckNAddTwoStates(68, 69); | |
break; | |
case 70: | |
if ((0x280000000000L & l) != 0L) | |
jjCheckNAdd(71); | |
break; | |
case 71: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 57) | |
kind = 57; | |
jjCheckNAdd(71); | |
break; | |
case 72: | |
if ((0x3ff000000000000L & l) == 0L) | |
break; | |
if (kind > 56) | |
kind = 56; | |
jjCheckNAddStates(184, 189); | |
break; | |
case 73: | |
if (curChar == 46) | |
jjCheckNAddTwoStates(64, 74); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 52: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
else if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 74: | |
if ((0x7fffffe07fffffeL & l) != 0L && kind > 67) | |
kind = 67; | |
break; | |
case 13: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
{ | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(40); | |
} | |
else if (curChar == 92) | |
jjCheckNAddStates(214, 217); | |
break; | |
case 2: | |
if (curChar == 116) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 5: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 6: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 7: | |
if (curChar == 125) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 8: | |
if (curChar == 116) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 8; | |
break; | |
case 10: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 9; | |
break; | |
case 11: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
break; | |
case 14: | |
jjCheckNAddStates(201, 204); | |
break; | |
case 18: | |
if (curChar == 92) | |
jjAddStates(218, 223); | |
break; | |
case 19: | |
if ((0x14404400000000L & l) != 0L) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 24: | |
if (curChar == 117) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 25: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 26; | |
break; | |
case 26: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 27; | |
break; | |
case 27: | |
if ((0x7e0000007eL & l) != 0L) | |
jjstateSet[jjnewStateCnt++] = 28; | |
break; | |
case 28: | |
if ((0x7e0000007eL & l) != 0L) | |
jjCheckNAddStates(201, 204); | |
break; | |
case 32: | |
jjAddStates(197, 200); | |
break; | |
case 35: | |
if (curChar == 92) | |
jjAddStates(212, 213); | |
break; | |
case 39: | |
case 40: | |
if ((0x7fffffe87fffffeL & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(40); | |
break; | |
case 41: | |
if (curChar == 92) | |
jjCheckNAddStates(214, 217); | |
break; | |
case 42: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(42, 43); | |
break; | |
case 44: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(44, 45); | |
break; | |
case 46: | |
if (curChar == 92) | |
jjAddStates(224, 225); | |
break; | |
case 51: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 60: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(226, 227); | |
break; | |
case 65: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(228, 229); | |
break; | |
case 69: | |
if ((0x2000000020L & l) != 0L) | |
jjAddStates(30, 31); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 14: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(201, 204); | |
break; | |
case 32: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2)) | |
jjAddStates(197, 200); | |
break; | |
case 51: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
return 13; | |
} | |
if ((active0 & 0x1a0000L) != 0L) | |
return 27; | |
return -1; | |
case 1: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 1; | |
return 13; | |
} | |
if ((active0 & 0x80000L) != 0L) | |
return 25; | |
return -1; | |
case 2: | |
if ((active0 & 0x600000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 2; | |
return 13; | |
} | |
return -1; | |
case 3: | |
if ((active0 & 0x200000000L) != 0L) | |
return 13; | |
if ((active0 & 0x400000000L) != 0L) | |
{ | |
jjmatchedKind = 66; | |
jjmatchedPos = 3; | |
return 13; | |
} | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_1(int pos, long active0, long active1) | |
{ | |
return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_1() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_1(0xa0000L); | |
case 40: | |
return jjStopAtPos(0, 10); | |
case 91: | |
return jjStopAtPos(0, 1); | |
case 102: | |
return jjMoveStringLiteralDfa1_1(0x400000000L); | |
case 116: | |
return jjMoveStringLiteralDfa1_1(0x200000000L); | |
case 123: | |
return jjStopAtPos(0, 68); | |
case 125: | |
return jjStopAtPos(0, 69); | |
default : | |
return jjMoveNfa_1(12, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_1(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_1(0, active0, 0L); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_1(1, 19, 25); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_1(active0, 0x20000L); | |
case 97: | |
return jjMoveStringLiteralDfa2_1(active0, 0x400000000L); | |
case 114: | |
return jjMoveStringLiteralDfa2_1(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_1(0, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa2_1(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_1(0, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_1(1, active0, 0L); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
case 108: | |
return jjMoveStringLiteralDfa3_1(active0, 0x400000000L); | |
case 117: | |
return jjMoveStringLiteralDfa3_1(active0, 0x200000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_1(1, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa3_1(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_1(1, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_1(2, active0, 0L); | |
return 3; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x200000000L) != 0L) | |
return jjStartNfaWithStates_1(3, 33, 13); | |
break; | |
case 115: | |
return jjMoveStringLiteralDfa4_1(active0, 0x400000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_1(2, active0, 0L); | |
} | |
private int jjMoveStringLiteralDfa4_1(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_1(2, old0, 0L); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_1(3, active0, 0L); | |
return 4; | |
} | |
switch(curChar) | |
{ | |
case 101: | |
if ((active0 & 0x400000000L) != 0L) | |
return jjStartNfaWithStates_1(4, 34, 13); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_1(3, active0, 0L); | |
} | |
private int jjStartNfaWithStates_1(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_1(state, pos + 1); | |
} | |
private int jjMoveNfa_1(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 28; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 12: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
else if (curChar == 35) | |
jjCheckNAddStates(230, 232); | |
else if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(21, 22); | |
} | |
else if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 15; | |
break; | |
case 27: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 25; | |
break; | |
case 0: | |
if ((0x100000200L & l) != 0L) | |
jjCheckNAddTwoStates(0, 1); | |
break; | |
case 1: | |
if (curChar == 35) | |
jjCheckNAddTwoStates(6, 11); | |
break; | |
case 3: | |
if (curChar == 32) | |
jjAddStates(112, 113); | |
break; | |
case 4: | |
if (curChar == 40 && kind > 14) | |
kind = 14; | |
break; | |
case 13: | |
if ((0x3ff200000000000L & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjstateSet[jjnewStateCnt++] = 13; | |
break; | |
case 14: | |
if (curChar == 46) | |
jjstateSet[jjnewStateCnt++] = 15; | |
break; | |
case 18: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 20: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(21, 22); | |
break; | |
case 22: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 23: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(21, 22); | |
break; | |
case 24: | |
if (curChar == 35) | |
jjCheckNAddStates(230, 232); | |
break; | |
case 25: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 26; | |
break; | |
case 26: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 12: | |
if ((0x7fffffe87fffffeL & l) != 0L) | |
{ | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(13); | |
} | |
else if (curChar == 92) | |
jjCheckNAddStates(233, 236); | |
break; | |
case 27: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
else if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 2: | |
if (curChar == 116) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 5: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 6: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 5; | |
break; | |
case 7: | |
if (curChar == 125) | |
jjCheckNAddTwoStates(3, 4); | |
break; | |
case 8: | |
if (curChar == 116) | |
jjstateSet[jjnewStateCnt++] = 7; | |
break; | |
case 9: | |
if (curChar == 101) | |
jjstateSet[jjnewStateCnt++] = 8; | |
break; | |
case 10: | |
if (curChar == 115) | |
jjstateSet[jjnewStateCnt++] = 9; | |
break; | |
case 11: | |
if (curChar == 123) | |
jjstateSet[jjnewStateCnt++] = 10; | |
break; | |
case 13: | |
if ((0x7fffffe87fffffeL & l) == 0L) | |
break; | |
if (kind > 66) | |
kind = 66; | |
jjCheckNAdd(13); | |
break; | |
case 15: | |
if ((0x7fffffe07fffffeL & l) != 0L && kind > 67) | |
kind = 67; | |
break; | |
case 16: | |
if (curChar == 92) | |
jjCheckNAddStates(233, 236); | |
break; | |
case 17: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(17, 18); | |
break; | |
case 19: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(19, 20); | |
break; | |
case 21: | |
if (curChar == 92) | |
jjAddStates(143, 144); | |
break; | |
case 26: | |
if (kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 26: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
private final int jjStopStringLiteralDfa_7(int pos, long active0) | |
{ | |
switch (pos) | |
{ | |
case 0: | |
if ((active0 & 0x1a0000L) != 0L) | |
return 2; | |
return -1; | |
case 1: | |
if ((active0 & 0x80000L) != 0L) | |
return 0; | |
return -1; | |
default : | |
return -1; | |
} | |
} | |
private final int jjStartNfa_7(int pos, long active0) | |
{ | |
return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1); | |
} | |
private int jjMoveStringLiteralDfa0_7() | |
{ | |
switch(curChar) | |
{ | |
case 35: | |
jjmatchedKind = 20; | |
return jjMoveStringLiteralDfa1_7(0xa0000L); | |
case 93: | |
return jjMoveStringLiteralDfa1_7(0x10000000L); | |
default : | |
return jjMoveNfa_7(3, 0); | |
} | |
} | |
private int jjMoveStringLiteralDfa1_7(long active0) | |
{ | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_7(0, active0); | |
return 1; | |
} | |
switch(curChar) | |
{ | |
case 42: | |
if ((active0 & 0x80000L) != 0L) | |
return jjStartNfaWithStates_7(1, 19, 0); | |
break; | |
case 91: | |
return jjMoveStringLiteralDfa2_7(active0, 0x20000L); | |
case 93: | |
return jjMoveStringLiteralDfa2_7(active0, 0x10000000L); | |
default : | |
break; | |
} | |
return jjStartNfa_7(0, active0); | |
} | |
private int jjMoveStringLiteralDfa2_7(long old0, long active0) | |
{ | |
if (((active0 &= old0)) == 0L) | |
return jjStartNfa_7(0, old0); | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { | |
jjStopStringLiteralDfa_7(1, active0); | |
return 2; | |
} | |
switch(curChar) | |
{ | |
case 35: | |
if ((active0 & 0x10000000L) != 0L) | |
return jjStopAtPos(2, 28); | |
break; | |
case 91: | |
if ((active0 & 0x20000L) != 0L) | |
return jjStopAtPos(2, 17); | |
break; | |
default : | |
break; | |
} | |
return jjStartNfa_7(1, active0); | |
} | |
private int jjStartNfaWithStates_7(int pos, int kind, int state) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = pos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return pos + 1; } | |
return jjMoveNfa_7(state, pos + 1); | |
} | |
private int jjMoveNfa_7(int startState, int curPos) | |
{ | |
int startsAt = 0; | |
jjnewStateCnt = 12; | |
int i = 1; | |
jjstateSet[0] = startState; | |
int kind = 0x7fffffff; | |
for (;;) | |
{ | |
if (++jjround == 0x7fffffff) | |
ReInitRounds(); | |
if (curChar < 64) | |
{ | |
long l = 1L << curChar; | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 36) | |
{ | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
} | |
else if (curChar == 35) | |
jjstateSet[jjnewStateCnt++] = 2; | |
break; | |
case 0: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 1; | |
break; | |
case 1: | |
if ((0xfffffff7ffffffffL & l) != 0L && kind > 18) | |
kind = 18; | |
break; | |
case 2: | |
if (curChar == 42) | |
jjstateSet[jjnewStateCnt++] = 0; | |
break; | |
case 6: | |
if (curChar == 36 && kind > 15) | |
kind = 15; | |
break; | |
case 8: | |
if (curChar == 36) | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
case 10: | |
if ((0xa00000000L & l) != 0L && kind > 16) | |
kind = 16; | |
break; | |
case 11: | |
if (curChar != 36) | |
break; | |
if (kind > 15) | |
kind = 15; | |
jjCheckNAddTwoStates(9, 10); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else if (curChar < 128) | |
{ | |
long l = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 3: | |
if (curChar == 92) | |
jjCheckNAddStates(99, 102); | |
break; | |
case 1: | |
if (kind > 18) | |
kind = 18; | |
break; | |
case 5: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(5, 6); | |
break; | |
case 7: | |
if (curChar == 92) | |
jjCheckNAddTwoStates(7, 8); | |
break; | |
case 9: | |
if (curChar == 92) | |
jjAddStates(91, 92); | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
else | |
{ | |
int hiByte = (int)(curChar >> 8); | |
int i1 = hiByte >> 6; | |
long l1 = 1L << (hiByte & 077); | |
int i2 = (curChar & 0xff) >> 6; | |
long l2 = 1L << (curChar & 077); | |
do | |
{ | |
switch(jjstateSet[--i]) | |
{ | |
case 1: | |
if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18) | |
kind = 18; | |
break; | |
default : break; | |
} | |
} while(i != startsAt); | |
} | |
if (kind != 0x7fffffff) | |
{ | |
jjmatchedKind = kind; | |
jjmatchedPos = curPos; | |
kind = 0x7fffffff; | |
} | |
++curPos; | |
if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt))) | |
return curPos; | |
try { curChar = input_stream.readChar(); } | |
catch(java.io.IOException e) { return curPos; } | |
} | |
} | |
static final int[] jjnextStates = { | |
91, 93, 94, 95, 100, 101, 91, 94, 61, 100, 29, 31, 32, 35, 11, 13, | |
14, 15, 1, 2, 4, 11, 18, 13, 14, 15, 26, 27, 33, 34, 70, 71, | |
73, 74, 75, 76, 87, 89, 84, 85, 81, 82, 16, 17, 19, 21, 26, 27, | |
64, 65, 77, 78, 98, 99, 102, 103, 69, 71, 72, 73, 78, 79, 69, 72, | |
6, 78, 15, 16, 27, 28, 30, 38, 39, 41, 46, 28, 47, 62, 39, 63, | |
50, 53, 60, 67, 18, 19, 20, 21, 31, 36, 43, 9, 10, 22, 23, 76, | |
77, 80, 81, 5, 6, 7, 8, 6, 11, 39, 14, 15, 17, 18, 22, 24, | |
3, 4, 20, 21, 29, 30, 31, 32, 45, 47, 48, 49, 54, 55, 45, 48, | |
31, 54, 24, 26, 27, 30, 6, 8, 9, 10, 6, 13, 8, 9, 10, 21, | |
22, 28, 29, 37, 38, 39, 40, 11, 12, 14, 16, 21, 22, 34, 35, 41, | |
42, 52, 53, 56, 57, 8, 9, 10, 11, 12, 13, 6, 11, 33, 17, 18, | |
20, 21, 23, 24, 25, 26, 27, 28, 54, 56, 57, 58, 68, 69, 54, 57, | |
63, 68, 6, 11, 52, 32, 34, 35, 38, 14, 16, 17, 18, 14, 21, 16, | |
17, 18, 29, 30, 36, 37, 42, 43, 44, 45, 19, 20, 22, 24, 29, 30, | |
46, 47, 61, 62, 66, 67, 6, 11, 27, 17, 18, 19, 20, | |
}; | |
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) | |
{ | |
switch(hiByte) | |
{ | |
case 0: | |
return ((jjbitVec2[i2] & l2) != 0L); | |
default : | |
if ((jjbitVec0[i1] & l1) != 0L) | |
return true; | |
return false; | |
} | |
} | |
/** Token literal values. */ | |
public static final String[] jjstrLiteralImages = { | |
null, null, null, null, null, null, null, null, null, null, null, null, null, | |
null, null, null, null, null, null, null, null, null, null, null, null, null, null, | |
null, null, null, null, null, null, null, null, null, null, null, null, null, null, | |
null, null, null, null, null, null, null, null, null, null, null, null, null, null, | |
null, null, null, null, null, null, null, null, null, null, null, null, null, null, | |
null, null, null, null, }; | |
/** Lexer state names. */ | |
public static final String[] lexStateNames = { | |
"REFERENCE", | |
"REFMODIFIER", | |
"REFINDEX", | |
"DIRECTIVE", | |
"REFMOD2", | |
"DEFAULT", | |
"REFMOD", | |
"IN_TEXTBLOCK", | |
"IN_MULTI_LINE_COMMENT", | |
"IN_FORMAL_COMMENT", | |
"IN_SINGLE_LINE_COMMENT", | |
"PRE_DIRECTIVE", | |
}; | |
/** Lex State array. */ | |
public static final int[] jjnewLexState = { | |
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
}; | |
static final long[] jjtoToken = { | |
0x637fffff9fe07fffL, 0x13cL, | |
}; | |
static final long[] jjtoSkip = { | |
0x20000000L, 0xc0L, | |
}; | |
static final long[] jjtoSpecial = { | |
0x0L, 0xc0L, | |
}; | |
static final long[] jjtoMore = { | |
0x401f8000L, 0x0L, | |
}; | |
protected CharStream input_stream; | |
private final int[] jjrounds = new int[105]; | |
private final int[] jjstateSet = new int[210]; | |
private final StringBuilder jjimage = new StringBuilder(); | |
private StringBuilder image = jjimage; | |
private int jjimageLen; | |
private int lengthOfMatch; | |
protected char curChar; | |
/** Constructor. */ | |
public ParserTokenManager(CharStream stream){ | |
input_stream = stream; | |
} | |
/** Constructor. */ | |
public ParserTokenManager(CharStream stream, int lexState){ | |
this(stream); | |
SwitchTo(lexState); | |
} | |
/** Reinitialise parser. */ | |
public void ReInit(CharStream stream) | |
{ | |
jjmatchedPos = jjnewStateCnt = 0; | |
curLexState = defaultLexState; | |
input_stream = stream; | |
ReInitRounds(); | |
} | |
private void ReInitRounds() | |
{ | |
int i; | |
jjround = 0x80000001; | |
for (i = 105; i-- > 0;) | |
jjrounds[i] = 0x80000000; | |
} | |
/** Reinitialise parser. */ | |
public void ReInit(CharStream stream, int lexState) | |
{ | |
ReInit(stream); | |
SwitchTo(lexState); | |
} | |
/** Switch to specified lex state. */ | |
public void SwitchTo(int lexState) | |
{ | |
if (lexState >= 12 || lexState < 0) | |
throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); | |
else | |
curLexState = lexState; | |
} | |
protected Token jjFillToken() | |
{ | |
final Token t; | |
final String curTokenImage; | |
final int beginLine; | |
final int endLine; | |
final int beginColumn; | |
final int endColumn; | |
String im = jjstrLiteralImages[jjmatchedKind]; | |
curTokenImage = (im == null) ? input_stream.GetImage() : im; | |
beginLine = input_stream.getBeginLine(); | |
beginColumn = input_stream.getBeginColumn(); | |
endLine = input_stream.getEndLine(); | |
endColumn = input_stream.getEndColumn(); | |
t = Token.newToken(jjmatchedKind); | |
t.kind = jjmatchedKind; | |
t.image = curTokenImage; | |
t.beginLine = beginLine; | |
t.endLine = endLine; | |
t.beginColumn = beginColumn; | |
t.endColumn = endColumn; | |
return t; | |
} | |
int curLexState = 5; | |
int defaultLexState = 5; | |
int jjnewStateCnt; | |
int jjround; | |
int jjmatchedPos; | |
int jjmatchedKind; | |
/** Get the next Token. */ | |
public Token getNextToken() | |
{ | |
Token specialToken = null; | |
Token matchedToken; | |
int curPos = 0; | |
EOFLoop : | |
for (;;) | |
{ | |
try | |
{ | |
curChar = input_stream.BeginToken(); | |
} | |
catch(java.io.IOException e) | |
{ | |
jjmatchedKind = 0; | |
matchedToken = jjFillToken(); | |
matchedToken.specialToken = specialToken; | |
return matchedToken; | |
} | |
image = jjimage; | |
image.setLength(0); | |
jjimageLen = 0; | |
for (;;) | |
{ | |
switch(curLexState) | |
{ | |
case 0: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_0(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 70) | |
{ | |
jjmatchedKind = 70; | |
} | |
break; | |
case 1: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_1(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 70) | |
{ | |
jjmatchedKind = 70; | |
} | |
break; | |
case 2: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_2(); | |
break; | |
case 3: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_3(); | |
break; | |
case 4: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_4(); | |
break; | |
case 5: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_5(); | |
break; | |
case 6: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_6(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 70) | |
{ | |
jjmatchedKind = 70; | |
} | |
break; | |
case 7: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_7(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 30) | |
{ | |
jjmatchedKind = 30; | |
} | |
break; | |
case 8: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_8(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 29) | |
{ | |
jjmatchedKind = 29; | |
} | |
break; | |
case 9: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_9(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 29) | |
{ | |
jjmatchedKind = 29; | |
} | |
break; | |
case 10: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_10(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 29) | |
{ | |
jjmatchedKind = 29; | |
} | |
break; | |
case 11: | |
jjmatchedKind = 0x7fffffff; | |
jjmatchedPos = 0; | |
curPos = jjMoveStringLiteralDfa0_11(); | |
if (jjmatchedPos == 0 && jjmatchedKind > 71) | |
{ | |
jjmatchedKind = 71; | |
} | |
break; | |
} | |
if (jjmatchedKind != 0x7fffffff) | |
{ | |
if (jjmatchedPos + 1 < curPos) | |
input_stream.backup(curPos - jjmatchedPos - 1); | |
if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) | |
{ | |
matchedToken = jjFillToken(); | |
matchedToken.specialToken = specialToken; | |
TokenLexicalActions(matchedToken); | |
if (jjnewLexState[jjmatchedKind] != -1) | |
curLexState = jjnewLexState[jjmatchedKind]; | |
return matchedToken; | |
} | |
else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) | |
{ | |
if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) | |
{ | |
matchedToken = jjFillToken(); | |
if (specialToken == null) | |
specialToken = matchedToken; | |
else | |
{ | |
matchedToken.specialToken = specialToken; | |
specialToken = (specialToken.next = matchedToken); | |
} | |
SkipLexicalActions(matchedToken); | |
} | |
else | |
SkipLexicalActions(null); | |
if (jjnewLexState[jjmatchedKind] != -1) | |
curLexState = jjnewLexState[jjmatchedKind]; | |
continue EOFLoop; | |
} | |
MoreLexicalActions(); | |
if (jjnewLexState[jjmatchedKind] != -1) | |
curLexState = jjnewLexState[jjmatchedKind]; | |
curPos = 0; | |
jjmatchedKind = 0x7fffffff; | |
try { | |
curChar = input_stream.readChar(); | |
continue; | |
} | |
catch (java.io.IOException e1) { } | |
} | |
int error_line = input_stream.getEndLine(); | |
int error_column = input_stream.getEndColumn(); | |
String error_after = null; | |
boolean EOFSeen = false; | |
try { input_stream.readChar(); input_stream.backup(1); } | |
catch (java.io.IOException e1) { | |
EOFSeen = true; | |
error_after = curPos <= 1 ? "" : input_stream.GetImage(); | |
if (curChar == '\n' || curChar == '\r') { | |
error_line++; | |
error_column = 0; | |
} | |
else | |
error_column++; | |
} | |
if (!EOFSeen) { | |
input_stream.backup(1); | |
error_after = curPos <= 1 ? "" : input_stream.GetImage(); | |
} | |
throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); | |
} | |
} | |
} | |
void SkipLexicalActions(Token matchedToken) | |
{ | |
switch(jjmatchedKind) | |
{ | |
case 70 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* push every terminator character back into the stream | |
*/ | |
input_stream.backup(1); | |
inReference = false; | |
if ( debugPrint ) | |
System.out.print("REF_TERM :"); | |
stateStackPop(); | |
break; | |
case 71 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
if ( debugPrint ) | |
System.out.print("DIRECTIVE_TERM :"); | |
input_stream.backup(1); | |
inDirective = false; | |
stateStackPop(); | |
break; | |
default : | |
break; | |
} | |
} | |
void MoreLexicalActions() | |
{ | |
jjimageLen += (lengthOfMatch = jjmatchedPos + 1); | |
switch(jjmatchedKind) | |
{ | |
case 15 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (! inComment) | |
{ | |
/* | |
* if we find ourselves in REFERENCE, we need to pop down | |
* to end the previous ref | |
*/ | |
if (curLexState == REFERENCE) | |
{ | |
inReference = false; | |
stateStackPop(); | |
} | |
inReference = true; | |
if ( debugPrint ) | |
System.out.print( "$ : going to " + REFERENCE ); | |
stateStackPush(); | |
SwitchTo(REFERENCE); | |
} | |
break; | |
case 16 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (! inComment) | |
{ | |
/* | |
* if we find ourselves in REFERENCE, we need to pop down | |
* to end the previous ref | |
*/ | |
if (curLexState == REFERENCE) | |
{ | |
inReference = false; | |
stateStackPop(); | |
} | |
inReference = true; | |
if ( debugPrint ) | |
System.out.print( "$! : going to " + REFERENCE ); | |
stateStackPush(); | |
SwitchTo(REFERENCE); | |
} | |
break; | |
case 17 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (!inComment) | |
{ | |
inComment = true; | |
stateStackPush(); | |
SwitchTo( IN_TEXTBLOCK ); | |
} | |
break; | |
case 18 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (!inComment) | |
{ | |
input_stream.backup(1); | |
inComment = true; | |
stateStackPush(); | |
SwitchTo( IN_FORMAL_COMMENT); | |
} | |
break; | |
case 19 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (!inComment) | |
{ | |
inComment=true; | |
stateStackPush(); | |
SwitchTo( IN_MULTI_LINE_COMMENT ); | |
} | |
break; | |
case 20 : | |
image.append(input_stream.GetSuffix(jjimageLen)); | |
jjimageLen = 0; | |
if (! inComment) | |
{ | |
/* | |
* We can have the situation where #if($foo)$foo#end. | |
* We need to transition out of REFERENCE before going to DIRECTIVE. | |
* I don't really like this, but I can't think of a legal way | |
* you are going into DIRECTIVE while in REFERENCE. -gmj | |
*/ | |
if (curLexState == REFERENCE || curLexState == REFMODIFIER ) | |
{ | |
inReference = false; | |
stateStackPop(); | |
} | |
inDirective = true; | |
if ( debugPrint ) | |
System.out.print("# : going to " + DIRECTIVE ); | |
stateStackPush(); | |
SwitchTo(PRE_DIRECTIVE); | |
} | |
break; | |
default : | |
break; | |
} | |
} | |
void TokenLexicalActions(Token matchedToken) | |
{ | |
switch(jjmatchedKind) | |
{ | |
case 1 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
stateStackPush(); | |
SwitchTo(REFINDEX); | |
break; | |
case 2 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
stateStackPop(); | |
break; | |
case 10 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
if (!inComment) | |
lparen++; | |
/* | |
* If in REFERENCE and we have seen the dot, then move | |
* to REFMOD2 -> Modifier() | |
*/ | |
if (curLexState == REFMODIFIER ) | |
SwitchTo( REFMOD2 ); | |
break; | |
case 11 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
RPARENHandler(); | |
break; | |
case 12 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* need to simply switch back to REFERENCE, not drop down the stack | |
* because we can (infinitely) chain, ala | |
* $foo.bar().blargh().woogie().doogie() | |
*/ | |
SwitchTo( REFERENCE ); | |
break; | |
case 14 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
if (! inComment) | |
{ | |
inDirective = true; | |
if ( debugPrint ) | |
System.out.print("#set : going to " + DIRECTIVE ); | |
stateStackPush(); | |
inSet = true; | |
SwitchTo(DIRECTIVE); | |
} | |
/* | |
* need the LPAREN action | |
*/ | |
if (!inComment) | |
{ | |
lparen++; | |
/* | |
* If in REFERENCE and we have seen the dot, then move | |
* to REFMOD2 -> Modifier() | |
*/ | |
if (curLexState == REFMODIFIER ) | |
SwitchTo( REFMOD2 ); | |
} | |
break; | |
case 21 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
if (!inComment) | |
{ | |
if (curLexState == REFERENCE) | |
{ | |
inReference = false; | |
stateStackPop(); | |
} | |
inComment = true; | |
stateStackPush(); | |
SwitchTo(IN_SINGLE_LINE_COMMENT); | |
} | |
break; | |
case 25 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inComment = false; | |
stateStackPop(); | |
break; | |
case 26 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inComment = false; | |
stateStackPop(); | |
break; | |
case 27 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inComment = false; | |
stateStackPop(); | |
break; | |
case 28 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inComment = false; | |
stateStackPop(); | |
break; | |
case 32 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* - if we are in DIRECTIVE and haven't seen ( yet, then also drop out. | |
* don't forget to account for the beloved yet wierd #set | |
* - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok! | |
*/ | |
if( curLexState == DIRECTIVE && !inSet && lparen == 0) | |
stateStackPop(); | |
break; | |
case 35 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
if ( debugPrint ) | |
System.out.println(" NEWLINE :"); | |
stateStackPop(); | |
if (inSet) | |
inSet = false; | |
if (inDirective) | |
inDirective = false; | |
break; | |
case 51 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inDirective = false; | |
stateStackPop(); | |
break; | |
case 52 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
SwitchTo(DIRECTIVE); | |
break; | |
case 53 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
SwitchTo(DIRECTIVE); | |
break; | |
case 54 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
inDirective = false; | |
stateStackPop(); | |
break; | |
case 56 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* Remove the double period if it is there | |
*/ | |
if (matchedToken.image.endsWith("..")) { | |
input_stream.backup(2); | |
matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2); | |
} | |
/* | |
* check to see if we are in set | |
* ex. #set $foo = $foo + 3 | |
* because we want to handle the \n after | |
*/ | |
if ( lparen == 0 && !inSet && curLexState != REFMOD2 && curLexState != REFINDEX) | |
{ | |
stateStackPop(); | |
} | |
break; | |
case 57 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* check to see if we are in set | |
* ex. #set $foo = $foo + 3 | |
* because we want to handle the \n after | |
*/ | |
if ( lparen == 0 && !inSet && curLexState != REFMOD2) | |
{ | |
stateStackPop(); | |
} | |
break; | |
case 67 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
/* | |
* push the alpha char back into the stream so the following identifier | |
* is complete | |
*/ | |
input_stream.backup(1); | |
/* | |
* and munge the <DOT> so we just get a . when we have normal text that | |
* looks like a ref.ident | |
*/ | |
matchedToken.image = "."; | |
if ( debugPrint ) | |
System.out.print("DOT : switching to " + REFMODIFIER); | |
SwitchTo(REFMODIFIER); | |
break; | |
case 69 : | |
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); | |
stateStackPop(); | |
break; | |
default : | |
break; | |
} | |
} | |
private void jjCheckNAdd(int state) | |
{ | |
if (jjrounds[state] != jjround) | |
{ | |
jjstateSet[jjnewStateCnt++] = state; | |
jjrounds[state] = jjround; | |
} | |
} | |
private void jjAddStates(int start, int end) | |
{ | |
do { | |
jjstateSet[jjnewStateCnt++] = jjnextStates[start]; | |
} while (start++ != end); | |
} | |
private void jjCheckNAddTwoStates(int state1, int state2) | |
{ | |
jjCheckNAdd(state1); | |
jjCheckNAdd(state2); | |
} | |
private void jjCheckNAddStates(int start, int end) | |
{ | |
do { | |
jjCheckNAdd(jjnextStates[start]); | |
} while (start++ != end); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment