[e-cvs] cvs commit: e/src/jsrc/org/quasiliteral/astro AstroSchema.java AstroToken.java BaseSchema.java
markm@eros.cs.jhu.edu
markm@eros.cs.jhu.edu
Sun, 2 Dec 2001 01:01:53 -0500
markm 01/12/02 01:01:50
Modified: src/jsrc/antlr ANTLRError.java ANTLRException.java
ANTLRGrammarParseBehavior.java ANTLRHashString.java
ANTLRLexer.java ANTLRParser.java
ANTLRStringBuffer.java ANTLRTokdefLexer.java
ANTLRTokdefParser.java
ANTLRTokdefParserTokenTypes.java
ANTLRTokenTypes.java ASTFactory.java
ASTIterator.java ASTNULLType.java ASTPair.java
ASTVisitor.java ActionElement.java
ActionTransInfo.java Alternative.java
AlternativeBlock.java AlternativeElement.java
BaseAST.java BlockContext.java BlockEndElement.java
BlockWithImpliedExitPath.java ByteBuffer.java
CharBuffer.java CharFormatter.java
CharLiteralElement.java CharQueue.java
CharRangeElement.java CharScanner.java
CharStreamException.java CharStreamIOException.java
CodeGenerator.java CommonAST.java
CommonASTWithHiddenTokens.java
CommonHiddenStreamToken.java CommonToken.java
CppBlockFinishingInfo.java CppCharFormatter.java
CppCodeGenerator.java DefaultFileLineFormatter.java
DefaultToolErrorHandler.java
DefineGrammarSymbols.java
DiagnosticCodeGenerator.java DumpASTVisitor.java
ExceptionHandler.java ExceptionSpec.java
FileCopyException.java FileLineFormatter.java
Grammar.java GrammarAnalyzer.java GrammarAtom.java
GrammarElement.java GrammarSymbol.java
HTMLCodeGenerator.java ImportVocabTokenManager.java
InputBuffer.java JavaBlockFinishingInfo.java
JavaCharFormatter.java JavaCodeGenerator.java
LLkAnalyzer.java LLkGrammarAnalyzer.java
LLkParser.java LexerGrammar.java
LexerSharedInputState.java Lookahead.java
MakeGrammar.java MismatchedCharException.java
MismatchedTokenException.java NameSpace.java
NoViableAltException.java
NoViableAltForCharException.java
OneOrMoreBlock.java Parser.java ParserGrammar.java
ParserSharedInputState.java
RecognitionException.java RuleBlock.java
RuleEndElement.java RuleRefElement.java
RuleSymbol.java SatherBlockFinishingInfo.java
SatherCharFormatter.java SatherCodeGenerator.java
SemanticException.java SimpleTokenManager.java
StringLiteralElement.java StringLiteralSymbol.java
SynPredBlock.java Token.java TokenBuffer.java
TokenManager.java TokenQueue.java
TokenRangeElement.java TokenRefElement.java
TokenStream.java TokenStreamBasicFilter.java
TokenStreamException.java
TokenStreamHiddenTokenFilter.java
TokenStreamIOException.java
TokenStreamRecognitionException.java
TokenStreamRetryException.java
TokenStreamSelector.java TokenSymbol.java Tool.java
ToolErrorHandler.java TreeBlockContext.java
TreeElement.java TreeParser.java
TreeParserSharedInputState.java
TreeSpecifierNode.java TreeWalkerGrammar.java
WildcardElement.java ZeroOrMoreBlock.java
src/jsrc/antlr/actions/cpp ActionLexer.java
ActionLexerTokenTypes.java
src/jsrc/antlr/actions/java ActionLexer.java
ActionLexerTokenTypes.java
src/jsrc/antlr/actions/sather ActionLexer.java
ActionLexerTokenTypes.java
src/jsrc/antlr/collections AST.java ASTEnumeration.java
Enumerator.java List.java Stack.java
src/jsrc/antlr/collections/impl ASTArray.java
ASTEnumerator.java BitSet.java IndexedVector.java
IntRange.java LLCell.java LLEnumeration.java
LList.java Vector.java VectorEnumeration.java
VectorEnumerator.java
src/jsrc/antlr/debug DebuggingCharScanner.java
DebuggingInputBuffer.java DebuggingParser.java
Event.java GuessingEvent.java
InputBufferAdapter.java InputBufferEvent.java
InputBufferEventSupport.java
InputBufferListener.java InputBufferReporter.java
LLkDebuggingParser.java ListenerBase.java
MessageAdapter.java MessageEvent.java
MessageListener.java NewLineEvent.java
NewLineListener.java ParserAdapter.java
ParserController.java ParserEventSupport.java
ParserListener.java ParserMatchAdapter.java
ParserMatchEvent.java ParserMatchListener.java
ParserReporter.java ParserTokenAdapter.java
ParserTokenEvent.java ParserTokenListener.java
SemanticPredicateAdapter.java
SemanticPredicateEvent.java
SemanticPredicateListener.java
SyntacticPredicateAdapter.java
SyntacticPredicateEvent.java
SyntacticPredicateListener.java TraceAdapter.java
TraceEvent.java TraceListener.java Tracer.java
src/jsrc/antlr/debug/misc ASTFrame.java JTreeASTModel.java
JTreeASTPanel.java
src/jsrc/antlr/preprocessor Grammar.java GrammarFile.java
Hierarchy.java Option.java Preprocessor.java
PreprocessorLexer.java PreprocessorTokenTypes.java
Rule.java Tool.java
src/jsrc/net/captp/jcomm CapTPConnection.java CapTPMgr.java
CapTPReplacer.java CapTPResolver.java
DelayedRedirector.java Far3Desc.java
FarHandler.java ImportDesc.java IncomingDesc.java
Introducer.java LocatorUnum.java LookupHandler.java
NewFarDesc.java NewRemotePromiseDesc.java
NonceLocator.java ObjectID.java ObjectRefDesc.java
Promise3Desc.java Redirector.java
RemoteHandler.java RemotePromiseHandler.java
Sturdifier.java SturdyRef.java
src/jsrc/net/captp/tables AnswersTable.java CommTable.java
ExportsTable.java ImportsTable.java
NearGiftTable.java PromiseGiftTable.java
QuestionsTable.java SwissTable.java Vine.java
src/jsrc/net/vattp/data AuthSecrets.java
ConnectionAttemptFailed.java DES.java
DataCommThunk.java DataPath.java Decrypt3DES.java
Encrypt3DES.java ListenThread.java
MsgTransformer.java RecvThread.java SendThread.java
StartUpProtocol.java StreamMessage.java
Suspend.java UserThread.java VatTPConnection.java
VatTPMgr.java
src/jsrc/net/vattp/security ESecureRandom.java
MicroTime.java Native.java
SecureRandomCrewSeedIt.java TimerJitterEntropy.java
src/jsrc/net/vattp/tunnel HTTPClient.java
HTTPConnectionHandler.java HTTPInputStream.java
HTTPMsgID.java HTTPServeMain.java
HTTPSocketCtl.java TCPConnectionListener.java
src/jsrc/net/vattp/vls VatLocationServer.java
src/jsrc/org/apache/oro/text/regex CharStringPointer.java
MalformedPatternException.java MatchResult.java
OpCode.java Pattern.java PatternCompiler.java
PatternMatcher.java PatternMatcherInput.java
Perl5Compiler.java Perl5Debug.java
Perl5MatchResult.java Perl5Matcher.java
Perl5Pattern.java Perl5Repetition.java
Perl5Substitution.java StringSubstitution.java
Substitution.java Util.java
src/jsrc/org/capml/dom Element.java Node.java Text.java
src/jsrc/org/capml/quasi QuasiContent.java
QuasiContentExprHole.java QuasiContentList.java
QuasiContentPattHole.java QuasiElement.java
QuasiText.java XMLQuasiParser.java
src/jsrc/org/erights/e/develop/assertion
AssertionFailed.java
src/jsrc/org/erights/e/develop/exception
ExceptionNoticer.java
src/jsrc/org/erights/e/develop/trace Trace.java
TraceBuffer.java TraceDateToString.java
TraceLog.java TraceLogDescriptor.java
TraceMessageStringifier.java
TraceSubsystemMediator.java
TraceTxtVersionNamer.java TraceVersionNamer.java
src/jsrc/org/erights/e/elang/evm AssignExpr.java
CallExpr.java CatchExpr.java CdrPattern.java
DefineExpr.java EExpr.java EImpl.java EMeta.java
ENode.java EScript.java EscapeExpr.java
FinalPattern.java FinallyExpr.java
FrameFinalNounExpr.java HideExpr.java IfExpr.java
IgnorePattern.java ListPattern.java
LiteralExpr.java LiteralNounExpr.java
LiteralSlotNounExpr.java LocalFinalNounExpr.java
MatchBindExpr.java MetaExpr.java NounExpr.java
NounPattern.java ObjectExpr.java OuterNounExpr.java
Pattern.java QuasiLiteralExpr.java
QuasiLiteralPatt.java QuasiPatternExpr.java
QuasiPatternPatt.java ScopeExpr.java SendExpr.java
SeqExpr.java SlotExpr.java SuchThatPattern.java
VarPattern.java
src/jsrc/org/erights/e/elang/interp InteractiveInterp.java
Loader.java LoaderScope.java PackageScope.java
ScopeSetup.java URLGetter.java
UnsafeLoaderScope.java
src/jsrc/org/erights/e/elang/scope ContourBoundary.java
EvalContext.java ForwardingSlot.java
OuterScope.java ScopeMap.java ScopeMapBase.java
ScopeMapLink.java UndefinedVariableException.java
src/jsrc/org/erights/e/elang/syntax Assoc.java EBuilder.java
ELexer.java EParser.java MsgPatt.java URIKit.java
src/jsrc/org/erights/e/elang/visitors BindFramesVisitor.java
CopyVisitor.java
src/jsrc/org/erights/e/elib/base ClassDesc.java
src/jsrc/org/erights/e/elib/deflect Deflector.java
src/jsrc/org/erights/e/elib/eio TextReader.java
src/jsrc/org/erights/e/elib/prim BERunner.java
CallThunk.java ConstructorNode.java E.java
FERunner.java FERunnerEvent.java
InstanceMethodNode.java JavaMemberNode.java
MirandaMethods.java NowRunnable.java Runner.java
RunnerThread.java SacrificialComponent.java
ScriptMaker.java ShutDownVatException.java
StaticMaker.java StaticMethodNode.java VTable.java
VarGetterNode.java VarSetterNode.java WeakPtr.java
WeakPtrThread.java
src/jsrc/org/erights/e/elib/quasi Identifiers.java
Substituter.java
src/jsrc/org/erights/e/elib/ref BufferingRef.java
DisconnectedRef.java ExternalRef.java FarRef.java
LocalResolver.java NearRef.java Proxy.java Ref.java
RemotePromise.java SlotRef.java StemCell.java
SwitchableRef.java Switcher.java
UnconnectedRef.java WhenBrokenReactor.java
WhenResolvedReactor.java
src/jsrc/org/erights/e/elib/sealing Brand.java
SealedBox.java Sealer.java Unsealer.java
src/jsrc/org/erights/e/elib/slot FinalSlot.java
SettableSlot.java SimpleSlot.java
src/jsrc/org/erights/e/elib/tables ArrayedList.java
AssocFunc.java AtomicTwine.java Column.java
CompositeTwine.java ConstList.java
ConstListImpl.java ConstMap.java ConstMapImpl.java
ConstSet.java ConstSubclassSet.java EList.java
EMap.java ESet.java EmptyTwine.java
EqualityKeyColumn.java FlexList.java
FlexListImpl.java FlexMap.java FlexMapImpl.java
FlexSet.java IdentityKeyColumn.java
IdentityMap.java IndirectCompFunc.java
IntColumn.java IntTable.java KeyColumn.java
LocatedTwine.java ROList.java ROMap.java ROSet.java
RefColumn.java SamenessKeyColumn.java
ScalarColumn.java ShareCount.java
SimpleCompFunc.java SimpleTwine.java Twine.java
VoidColumn.java WeakKey.java WeakValue.java
src/jsrc/org/erights/e/elib/util
AlreadyDefinedException.java
ArityMismatchException.java DynamicCollection.java
src/jsrc/org/erights/e/extern/timer Clock.java Timeout.java
TimerQEntry.java TimerThread.java TimerWatcher.java
src/jsrc/org/erights/e/meta/java/io ReadOnlyFile.java
src/jsrc/org/erights/e/meta/java/lang BooleanSugar.java
Bufferer.java ByteGuardSugar.java
ClassGuardSugar.java DoubleGuardSugar.java
FloatGuardSugar.java IntegerGuardSugar.java
InterfaceGuardSugar.java LongGuardSugar.java
ShortGuardSugar.java StringGuardSugar.java
ThrowableGuardSugar.java VoidGuardSugar.java
src/jsrc/org/erights/e/meta/java/math
BigIntegerGuardSugar.java
src/jsrc/org/erights/e/meta/org/erights/e/elib/base
TypeDescGuardSugar.java
src/jsrc/org/erights/e/meta/org/erights/e/elib/ref
RefGuardSugar.java
src/jsrc/org/erights/e/meta/org/erights/e/elib/slot
SlotGuardGuardSugar.java ValueGuardGuardSugar.java
src/jsrc/org/erights/e/meta/org/erights/e/elib/tables
EListGuardSugar.java
src/jsrc/org/erights/e/ui/elmer EInterpAdapter.java
src/jsrc/org/erights/e/ui/jed EditGroup.java JedMain.java
src/jsrc/org/quasiliteral/astro AstroSchema.java
AstroToken.java BaseSchema.java
Log:
Just formatting
Revision Changes Path
1.5 +3 -3 e/src/jsrc/antlr/ANTLRError.java
Index: ANTLRError.java
===================================================================
RCS file: /cvs/e/src/jsrc/antlr/ANTLRError.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ANTLRError.java 2001/11/29 20:33:25 1.4
+++ ANTLRError.java 2001/12/02 06:01:28 1.5
@@ -4,7 +4,7 @@
* Project led by Terence Parr at http://www.jGuru.com
* Software rights: http://www.antlr.org/RIGHTS.html
*
- * $Id: ANTLRError.java,v 1.4 2001/11/29 20:33:25 markm Exp $
+ * $Id: ANTLRError.java,v 1.5 2001/12/02 06:01:28 markm Exp $
*/
public class ANTLRError extends Error {
@@ -13,7 +13,7 @@
* ANTLRError constructor comment.
*/
public ANTLRError() {
- super();
+ super();
}
/**
@@ -21,6 +21,6 @@
* @param s java.lang.String
*/
public ANTLRError(String s) {
- super(s);
+ super(s);
}
}
1.4 +8 -7 e/src/jsrc/antlr/ANTLRException.java
Index: ANTLRException.java
===================================================================
RCS file: /cvs/e/src/jsrc/antlr/ANTLRException.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- ANTLRException.java 2001/10/26 03:08:50 1.3
+++ ANTLRException.java 2001/12/02 06:01:28 1.4
@@ -4,15 +4,16 @@
* Project led by Terence Parr at http://www.jGuru.com
* Software rights: http://www.antlr.org/RIGHTS.html
*
- * $Id: ANTLRException.java,v 1.3 2001/10/26 03:08:50 markm Exp $
+ * $Id: ANTLRException.java,v 1.4 2001/12/02 06:01:28 markm Exp $
*/
public class ANTLRException extends Exception {
- public ANTLRException() {
- super();
- }
- public ANTLRException(String s) {
- super(s);
- }
+ public ANTLRException() {
+ super();
+ }
+
+ public ANTLRException(String s) {
+ super(s);
+ }
}
1.4 +113 -60 e/src/jsrc/antlr/ANTLRGrammarParseBehavior.java
Index: ANTLRGrammarParseBehavior.java
===================================================================
RCS file: /cvs/e/src/jsrc/antlr/ANTLRGrammarParseBehavior.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- ANTLRGrammarParseBehavior.java 2001/10/26 03:08:50 1.3
+++ ANTLRGrammarParseBehavior.java 2001/12/02 06:01:28 1.4
@@ -4,69 +4,122 @@
* Project led by Terence Parr at http://www.jGuru.com
* Software rights: http://www.antlr.org/RIGHTS.html
*
- * $Id: ANTLRGrammarParseBehavior.java,v 1.3 2001/10/26 03:08:50 markm Exp $
+ * $Id: ANTLRGrammarParseBehavior.java,v 1.4 2001/12/02 06:01:28 markm Exp $
*/
import antlr.collections.impl.BitSet;
public interface ANTLRGrammarParseBehavior {
- public void abortGrammar();
- public void beginAlt(boolean doAST_);
- public void beginChildList();
- // Exception handling
- public void beginExceptionGroup();
- public void beginExceptionSpec(Token label);
- public void beginSubRule(Token label, int line, boolean not);
- // Trees
- public void beginTree(int line) throws SemanticException ;
- public void defineRuleName(Token r, String access, boolean ruleAST, String docComment) throws SemanticException;
- public void defineToken(Token tokname, Token tokliteral);
- public void endAlt();
- public void endChildList();
- public void endExceptionGroup();
- public void endExceptionSpec();
- public void endGrammar();
- public void endOptions();
- public void endRule(String r);
- public void endSubRule();
- public void endTree();
- public void hasError();
- public void noASTSubRule();
- public void oneOrMoreSubRule();
- public void optionalSubRule();
- public void refAction(Token action);
- public void refArgAction(Token action);
- public void setUserExceptions(String thr);
- public void refCharLiteral(Token lit, Token label, boolean inverted, int autoGenType, boolean lastInRule);
- public void refCharRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule);
- public void refElementOption(Token option, Token value);
- public void refTokensSpecElementOption(Token tok, Token option, Token value);
- public void refExceptionHandler(Token exTypeAndName, Token action);
- public void refHeaderAction(Token name,Token act);
- public void refInitAction(Token action);
- public void refMemberAction(Token act);
- public void refPreambleAction(Token act);
- public void refReturnAction(Token returnAction);
- public void refRule(Token idAssign, Token r, Token label, Token arg, int autoGenType);
- public void refSemPred(Token pred);
- public void refStringLiteral(Token lit, Token label, int autoGenType, boolean lastInRule);
- public void refToken(Token assignId, Token t, Token label, Token args,
- boolean inverted, int autoGenType, boolean lastInRule);
- public void refTokenRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule);
- // Tree specifiers
- public void refTreeSpecifier(Token treeSpec);
- public void refWildcard(Token t, Token label, int autoGenType);
- public void setArgOfRuleRef(Token argaction);
- public void setCharVocabulary(BitSet b);
- // Options
- public void setFileOption(Token key, Token value, String filename);
- public void setGrammarOption(Token key, Token value);
- public void setRuleOption(Token key, Token value);
- public void setSubruleOption(Token key, Token value);
- public void startLexer(String file, Token name, String superClass, String doc);
- // Flow control for grammars
- public void startParser(String file, Token name, String superClass, String doc);
- public void startTreeWalker(String file, Token name, String superClass, String doc);
- public void synPred();
- public void zeroOrMoreSubRule();
+
+ public void abortGrammar();
+
+ public void beginAlt(boolean doAST_);
+
+ public void beginChildList();
+
+ // Exception handling
+ public void beginExceptionGroup();
+
+ public void beginExceptionSpec(Token label);
+
+ public void beginSubRule(Token label, int line, boolean not);
+
+ // Trees
+ public void beginTree(int line) throws SemanticException;
+
+ public void defineRuleName(Token r, String access, boolean ruleAST, String docComment) throws SemanticException;
+
+ public void defineToken(Token tokname, Token tokliteral);
+
+ public void endAlt();
+
+ public void endChildList();
+
+ public void endExceptionGroup();
+
+ public void endExceptionSpec();
+
+ public void endGrammar();
+
+ public void endOptions();
+
+ public void endRule(String r);
+
+ public void endSubRule();
+
+ public void endTree();
+
+ public void hasError();
+
+ public void noASTSubRule();
+
+ public void oneOrMoreSubRule();
+
+ public void optionalSubRule();
+
+ public void refAction(Token action);
+
+ public void refArgAction(Token action);
+
+ public void setUserExceptions(String thr);
+
+ public void refCharLiteral(Token lit, Token label, boolean inverted, int autoGenType, boolean lastInRule);
+
+ public void refCharRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule);
+
+ public void refElementOption(Token option, Token value);
+
+ public void refTokensSpecElementOption(Token tok, Token option, Token value);
+
+ public void refExceptionHandler(Token exTypeAndName, Token action);
+
+ public void refHeaderAction(Token name, Token act);
+
+ public void refInitAction(Token action);
+
+ public void refMemberAction(Token act);
+
+ public void refPreambleAction(Token act);
+
+ public void refReturnAction(Token returnAction);
+
+ public void refRule(Token idAssign, Token r, Token label, Token arg, int autoGenType);
+
+ public void refSemPred(Token pred);
+
+ public void refStringLiteral(Token lit, Token label, int autoGenType, boolean lastInRule);
+
+ public void refToken(Token assignId, Token t, Token label, Token args,
+ boolean inverted, int autoGenType, boolean lastInRule);
+
+ public void refTokenRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule);
+
+ // Tree specifiers
+ public void refTreeSpecifier(Token treeSpec);
+
+ public void refWildcard(Token t, Token label, int autoGenType);
+
+ public void setArgOfRuleRef(Token argaction);
+
+ public void setCharVocabulary(BitSet b);
+
+ // Options
+ public void setFileOption(Token key, Token value, String filename);
+
+ public void setGrammarOption(Token key, Token value);
+
+ public void setRuleOption(Token key, Token value);
+
+ public void setSubruleOption(Token key, Token value);
+
+ public void startLexer(String file, Token name, String superClass, String doc);
+
+ // Flow control for grammars
+ public void startParser(String file, Token name, String superClass, String doc);
+
+ public void startTreeWalker(String file, Token name, String superClass, String doc);
+
+ public void synPred();
+
+ public void zeroOrMoreSubRule();
}
1.5 +95 -83 e/src/jsrc/antlr/ANTLRHashString.java
Index: ANTLRHashString.java
===================================================================
RCS file: /cvs/e/src/jsrc/antlr/ANTLRHashString.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ANTLRHashString.java 2001/11/29 20:33:25 1.4
+++ ANTLRHashString.java 2001/12/02 06:01:28 1.5
@@ -4,7 +4,7 @@
* Project led by Terence Parr at http://www.jGuru.com
* Software rights: http://www.antlr.org/RIGHTS.html
*
- * $Id: ANTLRHashString.java,v 1.4 2001/11/29 20:33:25 markm Exp $
+ * $Id: ANTLRHashString.java,v 1.5 2001/12/02 06:01:28 markm Exp $
*/
// class implements a String-like object whose sole purpose is to be
@@ -12,86 +12,98 @@
// information about case sensitivity.
public class ANTLRHashString {
- // only one of s or buf is non-null
- private String s;
- private char[] buf;
- private int len;
- private CharScanner lexer;
- private static final int prime = 151;
-
-
- public ANTLRHashString(char[] buf, int length, CharScanner lexer) {
- this.lexer = lexer;
- setBuffer(buf, length);
- }
- // Hash strings constructed this way are unusable until setBuffer or setString are called.
- public ANTLRHashString(CharScanner lexer) {
- this.lexer = lexer;
- }
- public ANTLRHashString(String s, CharScanner lexer) {
- this.lexer = lexer;
- setString(s);
- }
- private final char charAt(int index) {
- return (s!=null) ? s.charAt(index) : buf[index];
- }
- // Return true if o is an ANTLRHashString equal to this.
- public boolean equals(Object o) {
- if (!(o instanceof ANTLRHashString) && !(o instanceof String)) {
- return false;
- }
-
- ANTLRHashString s;
- if ( o instanceof String ) {
- s = new ANTLRHashString((String)o,lexer);
- }
- else {
- s = (ANTLRHashString)o;
- }
- int l = length();
- if (s.length() != l) {
- return false;
- }
- if (lexer.getCaseSensitiveLiterals()) {
- for (int i = 0; i < l; i++) {
- if (charAt(i) != s.charAt(i)) {
- return false;
- }
- }
- } else {
- for (int i = 0; i < l; i++) {
- if (lexer.toLower(charAt(i)) != lexer.toLower(s.charAt(i))) {
- return false;
- }
- }
- }
- return true;
- }
- public int hashCode() {
- int hashval = 0;
- int l = length();
-
- if (lexer.getCaseSensitiveLiterals()) {
- for (int i = 0; i < l; i++) {
- hashval = hashval * prime + charAt(i);
- }
- } else {
- for (int i = 0; i < l; i++) {
- hashval = hashval * prime + lexer.toLower(charAt(i));
- }
- }
- return hashval;
- }
- private final int length() {
- return (s!=null) ? s.length() : len;
- }
- public void setBuffer(char[] buf, int length) {
- this.buf = buf;
- this.len = length;
- s = null;
- }
- public void setString(String s) {
- this.s = s;
- buf = null;
- }
+
+ // only one of s or buf is non-null
+ private String s;
+
+ private char[] buf;
+
+ private int len;
+
+ private CharScanner lexer;
+
+ private static final int prime = 151;
+
+
+ public ANTLRHashString(char[] buf, int length, CharScanner lexer) {
+ this.lexer = lexer;
+ setBuffer(buf, length);
+ }
+
+ // Hash strings constructed this way are unusable until setBuffer or setString are called.
+ public ANTLRHashString(CharScanner lexer) {
+ this.lexer = lexer;
+ }
+
+ public ANTLRHashString(String s, CharScanner lexer) {
+ this.lexer = lexer;
+ setString(s);
+ }
+
+ private final char charAt(int index) {
+ return (s != null) ? s.charAt(index) : buf[index];
+ }
+
+ // Return true if o is an ANTLRHashString equal to this.
+ public boolean equals(Object o) {
+ if (!(o instanceof ANTLRHashString) && !(o instanceof String)) {
+ return false;
+ }
+
+ ANTLRHashString s;
+ if (o instanceof String) {
+ s = new ANTLRHashString((String)o, lexer);
+ } else {
+ s = (ANTLRHashString)o;
+ }
+ int l = length();
+ if (s.length() != l) {
+ return false;
+ }
+ if (lexer.getCaseSensitiveLiterals()) {
+ for (int i = 0; i < l; i++) {
+ if (charAt(i) != s.charAt(i)) {
+ return false;
+ }
+ }
+ } else {
+ for (int i = 0; i < l; i++) {
+ if (lexer.toLower(charAt(i)) != lexer.toLower(s.charAt(i))) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ public int hashCode() {
+ int hashval = 0;
+ int l = length();
+
+ if (lexer.getCaseSensitiveLiterals()) {
+ for (int i = 0; i < l; i++) {
+ hashval = hashval * prime + charAt(i);
+ }
+ } else {
+ for (int i = 0; i < l; i++) {
+ hashval = hashval * prime + lexer.toLower(charAt(i));
+ }
+ }
+ return hashval;
+ }
+
+ private final int length() {
+ return (s != null) ? s.length() : len;
+ }
+
+ public void setBuffer(char[] buf, int length) {
+ this.buf = buf;
+ this.len = length;
+ s = null;
+ }
+
+ public void setString(String s) {
+ this.s = s;
+ buf = null;
+ }
}
1.5 +2091 -1604e/src/jsrc/antlr/ANTLRLexer.java
Index: ANTLRLexer.java
===================================================================
RCS file: /cvs/e/src/jsrc/antlr/ANTLRLexer.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ANTLRLexer.java 2001/11/29 20:33:25 1.4
+++ ANTLRLexer.java 2001/12/02 06:01:28 1.5
@@ -8,1611 +8,2098 @@
import java.io.Reader;
import java.util.Hashtable;
-public class ANTLRLexer extends antlr.CharScanner implements ANTLRTokenTypes, TokenStream
- {
+public class ANTLRLexer extends antlr.CharScanner implements ANTLRTokenTypes, TokenStream {
- /**Convert 'c' to an integer char value. */
- public static int escapeCharValue(String cs) {
- //System.out.println("escapeCharValue("+cs+")");
- if ( cs.charAt(1)!='\\' ) return 0;
- switch ( cs.charAt(2) ) {
- case 'b' : return '\b';
- case 'r' : return '\r';
- case 't' : return '\t';
- case 'n' : return '\n';
- case 'f' : return '\f';
- case '"' : return '\"';
- case '\'' :return '\'';
- case '\\' :return '\\';
-
- case 'u' :
- // Unicode char
- if (cs.length() != 8) {
- return 0;
- }
- else {
- return
- Character.digit(cs.charAt(3), 16) * 16 * 16 * 16 +
- Character.digit(cs.charAt(4), 16) * 16 * 16 +
- Character.digit(cs.charAt(5), 16) * 16 +
- Character.digit(cs.charAt(6), 16);
- }
-
- case '0' :
- case '1' :
- case '2' :
- case '3' :
- if ( cs.length()>5 && Character.isDigit(cs.charAt(4)) ) {
- return (cs.charAt(2)-'0')*8*8 + (cs.charAt(3)-'0')*8 + (cs.charAt(4)-'0');
- }
- if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) {
- return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0');
- }
- return cs.charAt(2)-'0';
-
- case '4' :
- case '5' :
- case '6' :
- case '7' :
- if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) {
- return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0');
- }
- return cs.charAt(2)-'0';
-
- default :
- return 0;
- }
- }
-
- public static int tokenTypeForCharLiteral(String lit) {
- if ( lit.length()>3 ) { // does char contain escape?
- return escapeCharValue(lit);
- }
- else {
- return lit.charAt(1);
- }
- }
-public ANTLRLexer(InputStream in) {
- this(new ByteBuffer(in));
-}
-public ANTLRLexer(Reader in) {
- this(new CharBuffer(in));
-}
-public ANTLRLexer(InputBuffer ib) {
- this(new LexerSharedInputState(ib));
-}
-public ANTLRLexer(LexerSharedInputState state) {
- super(state);
- literals = new Hashtable();
- literals.put(new ANTLRHashString("Parser", this), new Integer(30));
- literals.put(new ANTLRHashString("catch", this), new Integer(41));
- literals.put(new ANTLRHashString("Lexer", this), new Integer(12));
- literals.put(new ANTLRHashString("exception", this), new Integer(40));
- literals.put(new ANTLRHashString("class", this), new Integer(10));
- literals.put(new ANTLRHashString("lexclass", this), new Integer(9));
- literals.put(new ANTLRHashString("public", this), new Integer(32));
- literals.put(new ANTLRHashString("header", this), new Integer(5));
- literals.put(new ANTLRHashString("options", this), new Integer(51));
- literals.put(new ANTLRHashString("charVocabulary", this), new Integer(18));
- literals.put(new ANTLRHashString("tokens", this), new Integer(4));
- literals.put(new ANTLRHashString("returns", this), new Integer(36));
- literals.put(new ANTLRHashString("TreeParser", this), new Integer(13));
- literals.put(new ANTLRHashString("private", this), new Integer(33));
- literals.put(new ANTLRHashString("protected", this), new Integer(31));
- literals.put(new ANTLRHashString("throws", this), new Integer(38));
- literals.put(new ANTLRHashString("extends", this), new Integer(11));
-caseSensitiveLiterals = true;
-setCaseSensitive(true);
-}
+ /**Convert 'c' to an integer char value. */
+ public static int escapeCharValue(String cs) {
+ //System.out.println("escapeCharValue("+cs+")");
+ if (cs.charAt(1) != '\\') return 0;
+ switch (cs.charAt(2)) {
+ case 'b':
+ return '\b';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ case 'n':
+ return '\n';
+ case 'f':
+ return '\f';
+ case '"':
+ return '\"';
+ case '\'':
+ return '\'';
+ case '\\':
+ return '\\';
+
+ case 'u':
+ // Unicode char
+ if (cs.length() != 8) {
+ return 0;
+ } else {
+ return
+ Character.digit(cs.charAt(3), 16) * 16 * 16 * 16 +
+ Character.digit(cs.charAt(4), 16) * 16 * 16 +
+ Character.digit(cs.charAt(5), 16) * 16 +
+ Character.digit(cs.charAt(6), 16);
+ }
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ if (cs.length() > 5 && Character.isDigit(cs.charAt(4))) {
+ return (cs.charAt(2) - '0') * 8 * 8 + (cs.charAt(3) - '0') * 8 + (cs.charAt(4) - '0');
+ }
+ if (cs.length() > 4 && Character.isDigit(cs.charAt(3))) {
+ return (cs.charAt(2) - '0') * 8 + (cs.charAt(3) - '0');
+ }
+ return cs.charAt(2) - '0';
+
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ if (cs.length() > 4 && Character.isDigit(cs.charAt(3))) {
+ return (cs.charAt(2) - '0') * 8 + (cs.charAt(3) - '0');
+ }
+ return cs.charAt(2) - '0';
+
+ default :
+ return 0;
+ }
+ }
+
+ public static int tokenTypeForCharLiteral(String lit) {
+ if (lit.length() > 3) { // does char contain escape?
+ return escapeCharValue(lit);
+ } else {
+ return lit.charAt(1);
+ }
+ }
+
+ public ANTLRLexer(InputStream in) {
+ this(new ByteBuffer(in));
+ }
+
+ public ANTLRLexer(Reader in) {
+ this(new CharBuffer(in));
+ }
+
+ public ANTLRLexer(InputBuffer ib) {
+ this(new LexerSharedInputState(ib));
+ }
+
+ public ANTLRLexer(LexerSharedInputState state) {
+ super(state);
+ literals = new Hashtable();
+ literals.put(new ANTLRHashString("Parser", this), new Integer(30));
+ literals.put(new ANTLRHashString("catch", this), new Integer(41));
+ literals.put(new ANTLRHashString("Lexer", this), new Integer(12));
+ literals.put(new ANTLRHashString("exception", this), new Integer(40));
+ literals.put(new ANTLRHashString("class", this), new Integer(10));
+ literals.put(new ANTLRHashString("lexclass", this), new Integer(9));
+ literals.put(new ANTLRHashString("public", this), new Integer(32));
+ literals.put(new ANTLRHashString("header", this), new Integer(5));
+ literals.put(new ANTLRHashString("options", this), new Integer(51));
+ literals.put(new ANTLRHashString("charVocabulary", this), new Integer(18));
+ literals.put(new ANTLRHashString("tokens", this), new Integer(4));
+ literals.put(new ANTLRHashString("returns", this), new Integer(36));
+ literals.put(new ANTLRHashString("TreeParser", this), new Integer(13));
+ literals.put(new ANTLRHashString("private", this), new Integer(33));
+ literals.put(new ANTLRHashString("protected", this), new Integer(31));
+ literals.put(new ANTLRHashString("throws", this), new Integer(38));
+ literals.put(new ANTLRHashString("extends", this), new Integer(11));
+ caseSensitiveLiterals = true;
+ setCaseSensitive(true);
+ }
+
+ public Token nextToken() throws TokenStreamException {
+ Token theRetToken = null;
+ tryAgain:
+ for (; ;) {
+ Token _token = null;
+ int _ttype = Token.INVALID_TYPE;
+ resetText();
+ try { // for char stream error handling
+ try { // for lexical error handling
+ switch (LA(1)) {
+ case '\t':
+ case '\n':
+ case '\r':
+ case ' ':
+ {
+ mWS(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '/':
+ {
+ mCOMMENT(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '<':
+ {
+ mOPEN_ELEMENT_OPTION(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '>':
+ {
+ mCLOSE_ELEMENT_OPTION(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case ',':
+ {
+ mCOMMA(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '?':
+ {
+ mQUESTION(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '#':
+ {
+ mTREE_BEGIN(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '(':
+ {
+ mLPAREN(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case ')':
+ {
+ mRPAREN(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case ':':
+ {
+ mCOLON(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '*':
+ {
+ mSTAR(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '+':
+ {
+ mPLUS(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case ';':
+ {
+ mSEMI(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '^':
+ {
+ mCARET(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '!':
+ {
+ mBANG(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '|':
+ {
+ mOR(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '~':
+ {
+ mNOT_OP(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '}':
+ {
+ mRCURLY(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '\'':
+ {
+ mCHAR_LITERAL(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '"':
+ {
+ mSTRING_LITERAL(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ mINT(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '[':
+ {
+ mARG_ACTION(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case '{':
+ {
+ mACTION(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ {
+ mTOKEN_REF(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ mRULE_REF(true);
+ theRetToken = _returnToken;
+ break;
+ }
+ default:
+ if ((LA(1) == '=') && (LA(2) == '>')) {
+ mIMPLIES(true);
+ theRetToken = _returnToken;
+ } else if ((LA(1) == '.') && (LA(2) == '.')) {
+ mRANGE(true);
+ theRetToken = _returnToken;
+ } else if ((LA(1) == '=') && (true)) {
+ mASSIGN(true);
+ theRetToken = _returnToken;
+ } else if ((LA(1) == '.') && (true)) {
+ mWILDCARD(true);
+ theRetToken = _returnToken;
+ } else {
+ if (LA(1) == EOF_CHAR) {
+ uponEOF();
+ _returnToken = makeToken(Token.EOF_TYPE);
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+ }
+ if (_returnToken == null) continue tryAgain; // found SKIP token
+ _ttype = _returnToken.getType();
+ _returnToken.setType(_ttype);
+ return _returnToken;
+ } catch (RecognitionException e) {
+ throw new TokenStreamRecognitionException(e);
+ }
+ } catch (CharStreamException cse) {
+ if (cse instanceof CharStreamIOException) {
+ throw new TokenStreamIOException(((CharStreamIOException)cse).io);
+ } else {
+ throw new TokenStreamException(cse.getMessage());
+ }
+ }
+ }
+ }
+
+ public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = WS;
+ int _saveIndex;
+
+ {
+ switch (LA(1)) {
+ case ' ':
+ {
+ match(' ');
+ break;
+ }
+ case '\t':
+ {
+ match('\t');
+ break;
+ }
+ case '\n':
+ {
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ break;
+ }
+ default:
+ if ((LA(1) == '\r') && (LA(2) == '\n')) {
+ match('\r');
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((LA(1) == '\r') && (true)) {
+ match('\r');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+ }
+ if (inputState.guessing == 0) {
+ _ttype = Token.SKIP;
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = COMMENT;
+ int _saveIndex;
+ Token t = null;
+
+ {
+ if ((LA(1) == '/') && (LA(2) == '/')) {
+ mSL_COMMENT(false);
+ } else if ((LA(1) == '/') && (LA(2) == '*')) {
+ mML_COMMENT(true);
+ t = _returnToken;
+ if (inputState.guessing == 0) {
+ _ttype = t.getType();
+ }
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ if (inputState.guessing == 0) {
+ if (_ttype != DOC_COMMENT) _ttype = Token.SKIP;
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = SL_COMMENT;
+ int _saveIndex;
+
+ match("//");
+ {
+ _loop153:
+ do {
+ if ((_tokenSet_0.member(LA(1)))) {
+ {
+ match(_tokenSet_0);
+ }
+ } else {
+ break _loop153;
+ }
+
+ } while (true);
+ }
+ {
+ if ((LA(1) == '\r') && (LA(2) == '\n')) {
+ match('\r');
+ match('\n');
+ } else if ((LA(1) == '\r') && (true)) {
+ match('\r');
+ } else if ((LA(1) == '\n')) {
+ match('\n');
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = ML_COMMENT;
+ int _saveIndex;
+
+ match("/*");
+ {
+ if (((LA(1) == '*') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) && (LA(2) != '/')) {
+ match('*');
+ if (inputState.guessing == 0) {
+ _ttype = DOC_COMMENT;
+ }
+ } else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ {
+ _loop159:
+ do {
+ // nongreedy exit test
+ if ((LA(1) == '*') && (LA(2) == '/')) break _loop159;
+ if ((LA(1) == '\r') && (LA(2) == '\n')) {
+ match('\r');
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((LA(1) == '\r') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ match('\r');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((_tokenSet_0.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ {
+ match(_tokenSet_0);
+ }
+ } else if ((LA(1) == '\n')) {
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else {
+ break _loop159;
+ }
+
+ } while (true);
+ }
+ match("*/");
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mOPEN_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = OPEN_ELEMENT_OPTION;
+ int _saveIndex;
+
+ match('<');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCLOSE_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = CLOSE_ELEMENT_OPTION;
+ int _saveIndex;
+
+ match('>');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = COMMA;
+ int _saveIndex;
+
+ match(',');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = QUESTION;
+ int _saveIndex;
+
+ match('?');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mTREE_BEGIN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = TREE_BEGIN;
+ int _saveIndex;
+
+ match("#(");
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = LPAREN;
+ int _saveIndex;
+
+ match('(');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = RPAREN;
+ int _saveIndex;
+
+ match(')');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = COLON;
+ int _saveIndex;
+
+ match(':');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = STAR;
+ int _saveIndex;
+
+ match('*');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = PLUS;
+ int _saveIndex;
+
+ match('+');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = ASSIGN;
+ int _saveIndex;
+
+ match('=');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mIMPLIES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = IMPLIES;
+ int _saveIndex;
+
+ match("=>");
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = SEMI;
+ int _saveIndex;
+
+ match(';');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCARET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = CARET;
+ int _saveIndex;
+
+ match('^');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBANG(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = BANG;
+ int _saveIndex;
+
+ match('!');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = OR;
+ int _saveIndex;
+
+ match('|');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mWILDCARD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = WILDCARD;
+ int _saveIndex;
+
+ match('.');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRANGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = RANGE;
+ int _saveIndex;
+
+ match("..");
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mNOT_OP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = NOT_OP;
+ int _saveIndex;
+
+ match('~');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = RCURLY;
+ int _saveIndex;
+
+ match('}');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = CHAR_LITERAL;
+ int _saveIndex;
+
+ match('\'');
+ {
+ switch (LA(1)) {
+ case '\\':
+ {
+ mESC(false);
+ break;
+ }
+ case '\u0003':
+ case '\u0004':
+ case '\u0005':
+ case '\u0006':
+ case '\u0007':
+ case '\u0008':
+ case '\t':
+ case '\n':
+ case '\u000b':
+ case '\u000c':
+ case '\r':
+ case '\u000e':
+ case '\u000f':
+ case '\u0010':
+ case '\u0011':
+ case '\u0012':
+ case '\u0013':
+ case '\u0014':
+ case '\u0015':
+ case '\u0016':
+ case '\u0017':
+ case '\u0018':
+ case '\u0019':
+ case '\u001a':
+ case '\u001b':
+ case '\u001c':
+ case '\u001d':
+ case '\u001e':
+ case '\u001f':
+ case ' ':
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ {
+ matchNot('\'');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+ }
+ match('\'');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = ESC;
+ int _saveIndex;
+
+ match('\\');
+ {
+ switch (LA(1)) {
+ case 'n':
+ {
+ match('n');
+ break;
+ }
+ case 'r':
+ {
+ match('r');
+ break;
+ }
+ case 't':
+ {
+ match('t');
+ break;
+ }
+ case 'b':
+ {
+ match('b');
+ break;
+ }
+ case 'f':
+ {
+ match('f');
+ break;
+ }
+ case 'w':
+ {
+ match('w');
+ break;
+ }
+ case 'a':
+ {
+ match('a');
+ break;
+ }
+ case '"':
+ {
+ match('"');
+ break;
+ }
+ case '\'':
+ {
+ match('\'');
+ break;
+ }
+ case '\\':
+ {
+ match('\\');
+ break;
+ }
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ {
+ {
+ matchRange('0', '3');
+ }
+ {
+ if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ {
+ matchRange('0', '9');
+ }
+ {
+ if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ matchRange('0', '9');
+ } else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && (true)) {
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ } else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && (true)) {
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ break;
+ }
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ {
+ {
+ matchRange('4', '7');
+ }
+ {
+ if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ {
+ matchRange('0', '9');
+ }
+ } else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && (true)) {
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ break;
+ }
+ case 'u':
+ {
+ match('u');
+ mXDIGIT(false);
+ mXDIGIT(false);
+ mXDIGIT(false);
+ mXDIGIT(false);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = STRING_LITERAL;
+ int _saveIndex;
+
+ match('"');
+ {
+ _loop184:
+ do {
+ switch (LA(1)) {
+ case '\\':
+ {
+ mESC(false);
+ break;
+ }
+ case '\u0003':
+ case '\u0004':
+ case '\u0005':
+ case '\u0006':
+ case '\u0007':
+ case '\u0008':
+ case '\t':
+ case '\n':
+ case '\u000b':
+ case '\u000c':
+ case '\r':
+ case '\u000e':
+ case '\u000f':
+ case '\u0010':
+ case '\u0011':
+ case '\u0012':
+ case '\u0013':
+ case '\u0014':
+ case '\u0015':
+ case '\u0016':
+ case '\u0017':
+ case '\u0018':
+ case '\u0019':
+ case '\u001a':
+ case '\u001b':
+ case '\u001c':
+ case '\u001d':
+ case '\u001e':
+ case '\u001f':
+ case ' ':
+ case '!':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '[':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ {
+ matchNot('"');
+ break;
+ }
+ default:
+ {
+ break _loop184;
+ }
+ }
+ } while (true);
+ }
+ match('"');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mXDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = XDIGIT;
+ int _saveIndex;
+
+ switch (LA(1)) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ matchRange('0', '9');
+ break;
+ }
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ {
+ matchRange('a', 'f');
+ break;
+ }
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ {
+ matchRange('A', 'F');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = DIGIT;
+ int _saveIndex;
+
+ matchRange('0', '9');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = VOCAB;
+ int _saveIndex;
+
+ matchRange('\3', '\176');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = INT;
+ int _saveIndex;
+
+ {
+ int _cnt199 = 0;
+ _loop199:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0', '9');
+ } else {
+ if (_cnt199 >= 1) {
+ break _loop199;
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+ }
+
+ _cnt199++;
+ } while (true);
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = ARG_ACTION;
+ int _saveIndex;
+
+ mNESTED_ARG_ACTION(false);
+ if (inputState.guessing == 0) {
+ setText(Tool.stripFrontBack(getText(), "[", "]"));
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mNESTED_ARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = NESTED_ARG_ACTION;
+ int _saveIndex;
+
+ match('[');
+ {
+ _loop203:
+ do {
+ switch (LA(1)) {
+ case '[':
+ {
+ mNESTED_ARG_ACTION(false);
+ break;
+ }
+ case '\n':
+ {
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ break;
+ }
+ case '\'':
+ {
+ mCHAR_LITERAL(false);
+ break;
+ }
+ case '"':
+ {
+ mSTRING_LITERAL(false);
+ break;
+ }
+ case '\u0003':
+ case '\u0004':
+ case '\u0005':
+ case '\u0006':
+ case '\u0007':
+ case '\u0008':
+ case '\t':
+ case '\u000b':
+ case '\u000c':
+ case '\u000e':
+ case '\u000f':
+ case '\u0010':
+ case '\u0011':
+ case '\u0012':
+ case '\u0013':
+ case '\u0014':
+ case '\u0015':
+ case '\u0016':
+ case '\u0017':
+ case '\u0018':
+ case '\u0019':
+ case '\u001a':
+ case '\u001b':
+ case '\u001c':
+ case '\u001d':
+ case '\u001e':
+ case '\u001f':
+ case ' ':
+ case '!':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case '\\':
+ case '^':
+ case '_':
+ case '`':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ {
+ matchNot(']');
+ break;
+ }
+ default:
+ if ((LA(1) == '\r') && (LA(2) == '\n')) {
+ match('\r');
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((LA(1) == '\r') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ match('\r');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else {
+ break _loop203;
+ }
+ }
+ } while (true);
+ }
+ match(']');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = ACTION;
+ int _saveIndex;
+ int actionLine = getLine();
+
+ mNESTED_ACTION(false);
+ {
+ if ((LA(1) == '?')) {
+ match('?');
+ if (inputState.guessing == 0) {
+ _ttype = SEMPRED;
+ }
+ } else {
+ }
+
+ }
+ if (inputState.guessing == 0) {
+
+ if (_ttype == ACTION) {
+ setText(Tool.stripFrontBack(getText(), "{", "}"));
+ } else {
+ setText(Tool.stripFrontBack(getText(), "{", "}?"));
+ }
+ CommonToken t = new CommonToken(_ttype, new String(text.getBuffer(), _begin, text.length() - _begin));
+ t.setLine(actionLine); // set action line to start
+ _token = t;
+
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mNESTED_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = NESTED_ACTION;
+ int _saveIndex;
+
+ match('{');
+ {
+ _loop209:
+ do {
+ // nongreedy exit test
+ if ((LA(1) == '}') && (true)) break _loop209;
+ if ((LA(1) == '\n' || LA(1) == '\r') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ {
+ if ((LA(1) == '\r') && (LA(2) == '\n')) {
+ match('\r');
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((LA(1) == '\r') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ match('\r');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else if ((LA(1) == '\n')) {
+ match('\n');
+ if (inputState.guessing == 0) {
+ newline();
+ }
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ }
+ } else if ((LA(1) == '{') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ mNESTED_ACTION(false);
+ } else if ((LA(1) == '\'') && (_tokenSet_1.member(LA(2)))) {
+ mCHAR_LITERAL(false);
+ } else if ((LA(1) == '/') && (LA(2) == '*' || LA(2) == '/')) {
+ mCOMMENT(false);
+ } else if ((LA(1) == '"') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ mSTRING_LITERAL(false);
+ } else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
+ matchNot(EOF_CHAR);
+ } else {
+ break _loop209;
+ }
+
+ } while (true);
+ }
+ match('}');
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mTOKEN_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = TOKEN_REF;
+ int _saveIndex;
+
+ matchRange('A', 'Z');
+ {
+ _loop212:
+ do {
+ switch (LA(1)) {
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ matchRange('a', 'z');
+ break;
+ }
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ {
+ matchRange('A', 'Z');
+ break;
+ }
+ case '_':
+ {
+ match('_');
+ break;
+ }
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ matchRange('0', '9');
+ break;
+ }
+ default:
+ {
+ break _loop212;
+ }
+ }
+ } while (true);
+ }
+ _ttype = testLiteralsTable(_ttype);
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = RULE_REF;
+ int _saveIndex;
+
+ int t = 0;
+
+
+ t = mINTERNAL_RULE_REF(false);
+ if (inputState.guessing == 0) {
+ _ttype = t;
+ }
+ {
+ if (true && (t == LITERAL_options)) {
+ mWS_LOOP(false);
+ {
+ if ((LA(1) == '{')) {
+ match('{');
+ if (inputState.guessing == 0) {
+ _ttype = OPTIONS;
+ }
+ } else {
+ }
+
+ }
+ } else if (true && (t == LITERAL_tokens)) {
+ mWS_LOOP(false);
+ {
+ if ((LA(1) == '{')) {
+ match('{');
+ if (inputState.guessing == 0) {
+ _ttype = TOKENS;
+ }
+ } else {
+ }
+
+ }
+ } else {
+ }
+
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final int mINTERNAL_RULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int t;
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = INTERNAL_RULE_REF;
+ int _saveIndex;
+
+ t = RULE_REF;
+
+
+ matchRange('a', 'z');
+ {
+ _loop222:
+ do {
+ switch (LA(1)) {
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ matchRange('a', 'z');
+ break;
+ }
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ {
+ matchRange('A', 'Z');
+ break;
+ }
+ case '_':
+ {
+ match('_');
+ break;
+ }
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ matchRange('0', '9');
+ break;
+ }
+ default:
+ {
+ break _loop222;
+ }
+ }
+ } while (true);
+ }
+ if (inputState.guessing == 0) {
+ t = testLiteralsTable(t);
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ return t;
+ }
+
+ protected final void mWS_LOOP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = WS_LOOP;
+ int _saveIndex;
+
+ {
+ _loop219:
+ do {
+ switch (LA(1)) {
+ case '\t':
+ case '\n':
+ case '\r':
+ case ' ':
+ {
+ mWS(false);
+ break;
+ }
+ case '/':
+ {
+ mCOMMENT(false);
+ break;
+ }
+ default:
+ {
+ break _loop219;
+ }
+ }
+ } while (true);
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mWS_OPT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = WS_OPT;
+ int _saveIndex;
+
+ {
+ if ((_tokenSet_2.member(LA(1)))) {
+ mWS(false);
+ } else {
+ }
+
+ }
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mNOT_USEFUL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype;
+ Token _token = null;
+ int _begin = text.length();
+ _ttype = NOT_USEFUL;
+ int _saveIndex;
+
+ boolean synPredMatched227 = false;
+ if (((LA(1) == 'a') && (true))) {
+ int _m227 = mark();
+ synPredMatched227 = true;
+ inputState.guessing++;
+ try {
+ {
+ match('a');
+ }
+ } catch (RecognitionException pe) {
+ synPredMatched227 = false;
+ }
+ rewind(_m227);
+ inputState.guessing--;
+ }
+ if (synPredMatched227) {
+ match('a');
+ } else if ((LA(1) == 'a') && (true)) {
+ match('a');
+ } else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
+ }
+
+ if (_createToken && _token == null && _ttype != Token.SKIP) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
+ }
+ _returnToken = _token;
+ }
+
+
+ private static final long _tokenSet_0_data_[] = { -9224L, 9223372036854775807L, 0L, 0L };
+
+ public static final BitSet _tokenSet_0 = new BitSet(_tokenSet_0_data_);
-public Token nextToken() throws TokenStreamException {
- Token theRetToken=null;
-tryAgain:
- for (;;) {
- Token _token = null;
- int _ttype = Token.INVALID_TYPE;
- resetText();
- try { // for char stream error handling
- try { // for lexical error handling
- switch ( LA(1)) {
- case '\t': case '\n': case '\r': case ' ':
- {
- mWS(true);
- theRetToken=_returnToken;
- break;
- }
- case '/':
- {
- mCOMMENT(true);
- theRetToken=_returnToken;
- break;
- }
- case '<':
- {
- mOPEN_ELEMENT_OPTION(true);
- theRetToken=_returnToken;
- break;
- }
- case '>':
- {
- mCLOSE_ELEMENT_OPTION(true);
- theRetToken=_returnToken;
- break;
- }
- case ',':
- {
- mCOMMA(true);
- theRetToken=_returnToken;
- break;
- }
- case '?':
- {
- mQUESTION(true);
- theRetToken=_returnToken;
- break;
- }
- case '#':
- {
- mTREE_BEGIN(true);
- theRetToken=_returnToken;
- break;
- }
- case '(':
- {
- mLPAREN(true);
- theRetToken=_returnToken;
- break;
- }
- case ')':
- {
- mRPAREN(true);
- theRetToken=_returnToken;
- break;
- }
- case ':':
- {
- mCOLON(true);
- theRetToken=_returnToken;
- break;
- }
- case '*':
- {
- mSTAR(true);
- theRetToken=_returnToken;
- break;
- }
- case '+':
- {
- mPLUS(true);
- theRetToken=_returnToken;
- break;
- }
- case ';':
- {
- mSEMI(true);
- theRetToken=_returnToken;
- break;
- }
- case '^':
- {
- mCARET(true);
- theRetToken=_returnToken;
- break;
- }
- case '!':
- {
- mBANG(true);
- theRetToken=_returnToken;
- break;
- }
- case '|':
- {
- mOR(true);
- theRetToken=_returnToken;
- break;
- }
- case '~':
- {
- mNOT_OP(true);
- theRetToken=_returnToken;
- break;
- }
- case '}':
- {
- mRCURLY(true);
- theRetToken=_returnToken;
- break;
- }
- case '\'':
- {
- mCHAR_LITERAL(true);
- theRetToken=_returnToken;
- break;
- }
- case '"':
- {
- mSTRING_LITERAL(true);
- theRetToken=_returnToken;
- break;
- }
- case '0': case '1': case '2': case '3':
- case '4': case '5': case '6': case '7':
- case '8': case '9':
- {
- mINT(true);
- theRetToken=_returnToken;
- break;
- }
- case '[':
- {
- mARG_ACTION(true);
- theRetToken=_returnToken;
- break;
- }
- case '{':
- {
- mACTION(true);
- theRetToken=_returnToken;
- break;
- }
- case 'A': case 'B': case 'C': case 'D':
- case 'E': case 'F': case 'G': case 'H':
- case 'I': case 'J': case 'K': case 'L':
- case 'M': case 'N': case 'O': case 'P':
- case 'Q': case 'R': case 'S': case 'T':
- case 'U': case 'V': case 'W': case 'X':
- case 'Y': case 'Z':
- {
- mTOKEN_REF(true);
- theRetToken=_returnToken;
- break;
- }
- case 'a': case 'b': case 'c': case 'd':
- case 'e': case 'f': case 'g': case 'h':
- case 'i': case 'j': case 'k': case 'l':
- case 'm': case 'n': case 'o': case 'p':
- case 'q': case 'r': case 's': case 't':
- case 'u': case 'v': case 'w': case 'x':
- case 'y': case 'z':
- {
- mRULE_REF(true);
- theRetToken=_returnToken;
- break;
- }
- default:
- if ((LA(1)=='=') && (LA(2)=='>')) {
- mIMPLIES(true);
- theRetToken=_returnToken;
- }
- else if ((LA(1)=='.') && (LA(2)=='.')) {
- mRANGE(true);
- theRetToken=_returnToken;
- }
- else if ((LA(1)=='=') && (true)) {
- mASSIGN(true);
- theRetToken=_returnToken;
- }
- else if ((LA(1)=='.') && (true)) {
- mWILDCARD(true);
- theRetToken=_returnToken;
- }
- else {
- if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
- else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());}
- }
- }
- if ( _returnToken==null ) continue tryAgain; // found SKIP token
- _ttype = _returnToken.getType();
- _returnToken.setType(_ttype);
- return _returnToken;
- }
- catch (RecognitionException e) {
- throw new TokenStreamRecognitionException(e);
- }
- }
- catch (CharStreamException cse) {
- if ( cse instanceof CharStreamIOException ) {
- throw new TokenStreamIOException(((CharStreamIOException)cse).io);
- }
- else {
- throw new TokenStreamException(cse.getMessage());
- }
- }
- }
-}
+ private static final long _tokenSet_1_data_[] = { -549755813896L, 9223372036854775807L, 0L, 0L };
+
+ public static final BitSet _tokenSet_1 = new BitSet(_tokenSet_1_data_);
- public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = WS;
- int _saveIndex;
-
- {
- switch ( LA(1)) {
- case ' ':
- {
- match(' ');
- break;
- }
- case '\t':
- {
- match('\t');
- break;
- }
- case '\n':
- {
- match('\n');
- if ( inputState.guessing==0 ) {
- newline();
- }
- break;
- }
- default:
- if ((LA(1)=='\r') && (LA(2)=='\n')) {
- match('\r');
- match('\n');
- if ( inputState.guessing==0 ) {
- newline();
- }
- }
- else if ((LA(1)=='\r') && (true)) {
- match('\r');
- if ( inputState.guessing==0 ) {
- newline();
- }
- }
- else {
- throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
- }
- }
- }
- if ( inputState.guessing==0 ) {
- _ttype = Token.SKIP;
- }
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = COMMENT;
- int _saveIndex;
- Token t=null;
-
- {
- if ((LA(1)=='/') && (LA(2)=='/')) {
- mSL_COMMENT(false);
- }
- else if ((LA(1)=='/') && (LA(2)=='*')) {
- mML_COMMENT(true);
- t=_returnToken;
- if ( inputState.guessing==0 ) {
- _ttype = t.getType();
- }
- }
- else {
- throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
- }
-
- }
- if ( inputState.guessing==0 ) {
- if ( _ttype != DOC_COMMENT ) _ttype = Token.SKIP;
- }
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- protected final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = SL_COMMENT;
- int _saveIndex;
-
- match("//");
- {
- _loop153:
- do {
- if ((_tokenSet_0.member(LA(1)))) {
- {
- match(_tokenSet_0);
- }
- }
- else {
- break _loop153;
- }
-
- } while (true);
- }
- {
- if ((LA(1)=='\r') && (LA(2)=='\n')) {
- match('\r');
- match('\n');
- }
- else if ((LA(1)=='\r') && (true)) {
- match('\r');
- }
- else if ((LA(1)=='\n')) {
- match('\n');
- }
- else {
- throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
- }
-
- }
- if ( inputState.guessing==0 ) {
- newline();
- }
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- protected final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = ML_COMMENT;
- int _saveIndex;
-
- match("/*");
- {
- if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '~')))&&( LA(2)!='/' )) {
- match('*');
- if ( inputState.guessing==0 ) {
- _ttype = DOC_COMMENT;
- }
- }
- else if (((LA(1) >= '\u0003' && LA(1) <= '~')) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
- }
- else {
- throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine());
- }
-
- }
- {
- _loop159:
- do {
- // nongreedy exit test
- if ((LA(1)=='*') && (LA(2)=='/')) break _loop159;
- if ((LA(1)=='\r') && (LA(2)=='\n')) {
- match('\r');
- match('\n');
- if ( inputState.guessing==0 ) {
- newline();
- }
- }
- else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
- match('\r');
- if ( inputState.guessing==0 ) {
- newline();
- }
- }
- else if ((_tokenSet_0.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '~'))) {
- {
- match(_tokenSet_0);
- }
- }
- else if ((LA(1)=='\n')) {
- match('\n');
- if ( inputState.guessing==0 ) {
- newline();
- }
- }
- else {
- break _loop159;
- }
-
- } while (true);
- }
- match("*/");
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mOPEN_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = OPEN_ELEMENT_OPTION;
- int _saveIndex;
-
- match('<');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mCLOSE_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = CLOSE_ELEMENT_OPTION;
- int _saveIndex;
-
- match('>');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = COMMA;
- int _saveIndex;
-
- match(',');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = QUESTION;
- int _saveIndex;
-
- match('?');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mTREE_BEGIN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = TREE_BEGIN;
- int _saveIndex;
-
- match("#(");
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = LPAREN;
- int _saveIndex;
-
- match('(');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = RPAREN;
- int _saveIndex;
-
- match(')');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = COLON;
- int _saveIndex;
-
- match(':');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = STAR;
- int _saveIndex;
-
- match('*');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = PLUS;
- int _saveIndex;
-
- match('+');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = ASSIGN;
- int _saveIndex;
-
- match('=');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mIMPLIES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = IMPLIES;
- int _saveIndex;
-
- match("=>");
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = SEMI;
- int _saveIndex;
-
- match(';');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mCARET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = CARET;
- int _saveIndex;
-
- match('^');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mBANG(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = BANG;
- int _saveIndex;
-
- match('!');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = OR;
- int _saveIndex;
-
- match('|');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mWILDCARD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = WILDCARD;
- int _saveIndex;
-
- match('.');
- if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
- _token = makeToken(_ttype);
- _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
- }
- _returnToken = _token;
- }
-
- public final void mRANGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
- int _ttype; Token _token=null; int _begin=text.length();
- _ttype = RANGE;
- int