org.codehaus.groovy.antlr.parser

## Class GroovyLexer

- java.lang.Object
- - antlr.CharScanner
  - - org.codehaus.groovy.antlr.parser.GroovyLexer

- All Implemented Interfaces:
    antlr.TokenStream, GroovyTokenTypes

      public class GroovyLexer
      extends antlr.CharScanner
      implements GroovyTokenTypes, antlr.TokenStream

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static antlr.collections.impl.BitSet` | `_tokenSet_0`
    `static antlr.collections.impl.BitSet` | `_tokenSet_1`
    `static antlr.collections.impl.BitSet` | `_tokenSet_10`
    `static antlr.collections.impl.BitSet` | `_tokenSet_11`
    `static antlr.collections.impl.BitSet` | `_tokenSet_12`
    `static antlr.collections.impl.BitSet` | `_tokenSet_13`
    `static antlr.collections.impl.BitSet` | `_tokenSet_2`
    `static antlr.collections.impl.BitSet` | `_tokenSet_3`
    `static antlr.collections.impl.BitSet` | `_tokenSet_4`
    `static antlr.collections.impl.BitSet` | `_tokenSet_5`
    `static antlr.collections.impl.BitSet` | `_tokenSet_6`
    `static antlr.collections.impl.BitSet` | `_tokenSet_7`
    `static antlr.collections.impl.BitSet` | `_tokenSet_8`
    `static antlr.collections.impl.BitSet` | `_tokenSet_9`
    `protected int` | `lastSigTokenType`
    `protected int` | `parenLevel` Bumped when inside '[x]' or '(x)', reset inside '{x}'.
    `protected java.util.ArrayList` | `parenLevelStack` Push parenLevel here and reset whenever inside '{x}'.
    `protected GroovyRecognizer` | `parser`
    `protected static int` | `SCS_DRE_TYPE`
    `protected static int` | `SCS_LIMIT`
    `protected static int` | `SCS_LIT`
    `protected static int` | `SCS_RE_TYPE`
    `protected static int` | `SCS_SQ_TYPE`
    `protected static int` | `SCS_TQ_TYPE`
    `protected static int` | `SCS_TYPE`
    `protected static int` | `SCS_VAL`
    `protected int` | `stringCtorState`
    `protected int` | `suppressNewline`
    `static boolean` | `tracing`

    - ### Fields inherited from class antlr.CharScanner

      `_returnToken, caseSensitive, caseSensitiveLiterals, commitToPath, EOF_CHAR, hashString, inputState, literals, saveConsumedInput, tabsize, text, tokenObjectClass, traceDepth`

    - ### Fields inherited from interface org.codehaus.groovy.antlr.parser.GroovyTokenTypes

      `ABSTRACT, ANNOTATION, ANNOTATION_ARRAY_INIT, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, ANNOTATION_MEMBER_VALUE_PAIR, ANNOTATIONS, ARRAY_DECLARATOR, ASSIGN, AT, BAND, BAND_ASSIGN, BIG_SUFFIX, BLOCK, BNOT, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN, CASE_GROUP, CLASS_DEF, CLOSABLE_BLOCK, CLOSABLE_BLOCK_OP, CLOSURE_LIST, COLON, COMMA, COMPARE_TO, CTOR_CALL, CTOR_IDENT, DEC, DIGIT, DIGITS_WITH_UNDERSCORE, DIGITS_WITH_UNDERSCORE_OPT, DIV, DIV_ASSIGN, DOLLAR, DOLLAR_REGEXP_CTOR_END, DOLLAR_REGEXP_LITERAL, DOLLAR_REGEXP_SYMBOL, DOT, DYNAMIC_MEMBER, ELIST, ELVIS_OPERATOR, EMPTY_STAT, ENUM_CONSTANT_DEF, ENUM_DEF, EOF, EQUAL, ESC, ESCAPED_DOLLAR, ESCAPED_SLASH, EXPONENT, EXPR, EXTENDS_CLAUSE, FINAL, FLOAT_SUFFIX, FOR_CONDITION, FOR_EACH_CLAUSE, FOR_IN_ITERABLE, FOR_INIT, FOR_ITERATOR, GE, GT, HEX_DIGIT, IDENT, IDENTICAL, IMPLEMENTS_CLAUSE, IMPLICIT_PARAMETERS, IMPORT, INC, INDEX_OP, INSTANCE_INIT, INTERFACE_DEF, LABELED_ARG, LABELED_STAT, LAND, LBRACK, LCURLY, LE, LETTER, LIST_CONSTRUCTOR, LITERAL_as, LITERAL_assert, LITERAL_boolean, LITERAL_break, LITERAL_byte, LITERAL_case, LITERAL_catch, LITERAL_char, LITERAL_class, LITERAL_continue, LITERAL_def, LITERAL_default, LITERAL_double, LITERAL_else, LITERAL_enum, LITERAL_extends, LITERAL_false, LITERAL_finally, LITERAL_float, LITERAL_for, LITERAL_if, LITERAL_implements, LITERAL_import, LITERAL_in, LITERAL_instanceof, LITERAL_int, LITERAL_interface, LITERAL_long, LITERAL_native, LITERAL_new, LITERAL_null, LITERAL_package, LITERAL_private, LITERAL_protected, LITERAL_public, LITERAL_return, LITERAL_short, LITERAL_static, LITERAL_super, LITERAL_switch, LITERAL_synchronized, LITERAL_this, LITERAL_threadsafe, LITERAL_throw, LITERAL_throws, LITERAL_trait, LITERAL_transient, LITERAL_true, LITERAL_try, LITERAL_void, LITERAL_volatile, LITERAL_while, LNOT, LOR, LPAREN, LT, MAP_CONSTRUCTOR, MEMBER_POINTER, METHOD_CALL, METHOD_DEF, MINUS, MINUS_ASSIGN, ML_COMMENT, MOD, MOD_ASSIGN, MODIFIERS, MULTICATCH, MULTICATCH_TYPES, NLS, NOT_EQUAL, NOT_IDENTICAL, NULL_TREE_LOOKAHEAD, NUM_BIG_DECIMAL, NUM_BIG_INT, NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG, OBJBLOCK, ONE_NL, OPTIONAL_DOT, PACKAGE_DEF, PARAMETER_DEF, PARAMETERS, PLUS, PLUS_ASSIGN, POST_DEC, POST_INC, QUESTION, RANGE_EXCLUSIVE, RANGE_INCLUSIVE, RBRACK, RCURLY, REGEX_FIND, REGEX_MATCH, REGEXP_CTOR_END, REGEXP_LITERAL, REGEXP_SYMBOL, RPAREN, SELECT_SLOT, SEMI, SH_COMMENT, SL, SL_ASSIGN, SL_COMMENT, SLIST, SPREAD_ARG, SPREAD_DOT, SPREAD_MAP_ARG, SR, SR_ASSIGN, STAR, STAR_ASSIGN, STAR_STAR, STAR_STAR_ASSIGN, STATIC_IMPORT, STATIC_INIT, STRICTFP, STRING_CH, STRING_CONSTRUCTOR, STRING_CTOR_END, STRING_CTOR_MIDDLE, STRING_CTOR_START, STRING_LITERAL, STRING_NL, SUPER_CTOR_CALL, TRAIT_DEF, TRIPLE_DOT, TYPE, TYPE_ARGUMENT, TYPE_ARGUMENTS, TYPE_LOWER_BOUNDS, TYPE_PARAMETER, TYPE_PARAMETERS, TYPE_UPPER_BOUNDS, TYPECAST, UNARY_MINUS, UNARY_PLUS, UNUSED_CONST, UNUSED_DO, UNUSED_GOTO, VARIABLE_DEF, VARIABLE_PARAMETER_DEF, VOCAB, WILDCARD_TYPE, WS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `GroovyLexer(antlr.InputBuffer ib)`
    `GroovyLexer(java.io.InputStream in)`
    `GroovyLexer(antlr.LexerSharedInputState state)`
    `GroovyLexer(java.io.Reader in)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `allowRegexpLiteral()`
    `protected boolean` | `atDollarDollarEscape()`
    `protected boolean` | `atDollarSlashEscape()`
    `protected boolean` | `atMultiCommentStart()`
    `protected boolean` | `atValidDollarEscape()`
    `void` | `enableAssert(boolean shouldEnable)` Enable the "assert" keyword
    `void` | `enableEnum(boolean shouldEnable)` Enable the "enum" keyword
    `boolean` | `isAssertEnabled()` Query the "assert" keyword state
    `boolean` | `isEnumEnabled()` Query the "enum" keyword state
    `protected static boolean` | `isExpressionEndingToken(int ttype)` Return true for an operator or punctuation which can end an expression.
    `boolean` | `isWhitespaceIncluded()` Are whitespace tokens included?
    `protected antlr.Token` | `makeToken(int t)`
    `void` | `mASSIGN(boolean _createToken)`
    `void` | `mAT(boolean _createToken)`
    `void` | `mBAND_ASSIGN(boolean _createToken)`
    `void` | `mBAND(boolean _createToken)`
    `protected void` | `mBIG_SUFFIX(boolean _createToken)`
    `void` | `mBNOT(boolean _createToken)`
    `void` | `mBOR_ASSIGN(boolean _createToken)`
    `void` | `mBOR(boolean _createToken)`
    `void` | `mBSR_ASSIGN(boolean _createToken)`
    `void` | `mBSR(boolean _createToken)`
    `void` | `mBXOR_ASSIGN(boolean _createToken)`
    `void` | `mBXOR(boolean _createToken)`
    `void` | `mCLOSABLE_BLOCK_OP(boolean _createToken)`
    `void` | `mCOLON(boolean _createToken)`
    `void` | `mCOMMA(boolean _createToken)`
    `void` | `mCOMPARE_TO(boolean _createToken)`
    `void` | `mDEC(boolean _createToken)`
    `protected void` | `mDIGIT(boolean _createToken)`
    `protected void` | `mDIGITS_WITH_UNDERSCORE_OPT(boolean _createToken)`
    `protected void` | `mDIGITS_WITH_UNDERSCORE(boolean _createToken)`
    `protected void` | `mDIV_ASSIGN(boolean _createToken)`
    `protected void` | `mDIV(boolean _createToken)`
    `protected int` | `mDOLLAR_REGEXP_CTOR_END(boolean _createToken, boolean fromStart)`
    `void` | `mDOLLAR_REGEXP_LITERAL(boolean _createToken)`
    `protected void` | `mDOLLAR_REGEXP_SYMBOL(boolean _createToken)`
    `protected void` | `mDOLLAR(boolean _createToken)`
    `void` | `mDOT(boolean _createToken)`
    `void` | `mELVIS_OPERATOR(boolean _createToken)`
    `void` | `mEQUAL(boolean _createToken)`
    `protected void` | `mESC(boolean _createToken)`
    `protected void` | `mESCAPED_DOLLAR(boolean _createToken)`
    `protected void` | `mESCAPED_SLASH(boolean _createToken)`
    `protected void` | `mEXPONENT(boolean _createToken)`
    `protected void` | `mFLOAT_SUFFIX(boolean _createToken)`
    `void` | `mGE(boolean _createToken)`
    `void` | `mGT(boolean _createToken)`
    `protected void` | `mHEX_DIGIT(boolean _createToken)`
    `void` | `mIDENT(boolean _createToken)`
    `void` | `mIDENTICAL(boolean _createToken)`
    `void` | `mINC(boolean _createToken)`
    `void` | `mLAND(boolean _createToken)`
    `void` | `mLBRACK(boolean _createToken)`
    `void` | `mLCURLY(boolean _createToken)`
    `void` | `mLE(boolean _createToken)`
    `protected void` | `mLETTER(boolean _createToken)`
    `void` | `mLNOT(boolean _createToken)`
    `void` | `mLOR(boolean _createToken)`
    `void` | `mLPAREN(boolean _createToken)`
    `void` | `mLT(boolean _createToken)`
    `void` | `mMEMBER_POINTER(boolean _createToken)`
    `void` | `mMINUS_ASSIGN(boolean _createToken)`
    `void` | `mMINUS(boolean _createToken)`
    `void` | `mML_COMMENT(boolean _createToken)`
    `void` | `mMOD_ASSIGN(boolean _createToken)`
    `void` | `mMOD(boolean _createToken)`
    `void` | `mNLS(boolean _createToken)`
    `void` | `mNOT_EQUAL(boolean _createToken)`
    `void` | `mNOT_IDENTICAL(boolean _createToken)`
    `void` | `mNUM_INT(boolean _createToken)`
    `protected void` | `mONE_NL(boolean _createToken, boolean check)`
    `void` | `mOPTIONAL_DOT(boolean _createToken)`
    `void` | `mPLUS_ASSIGN(boolean _createToken)`
    `void` | `mPLUS(boolean _createToken)`
    `void` | `mQUESTION(boolean _createToken)`
    `void` | `mRANGE_EXCLUSIVE(boolean _createToken)`
    `void` | `mRANGE_INCLUSIVE(boolean _createToken)`
    `void` | `mRBRACK(boolean _createToken)`
    `void` | `mRCURLY(boolean _createToken)`
    `void` | `mREGEX_FIND(boolean _createToken)`
    `void` | `mREGEX_MATCH(boolean _createToken)`
    `protected int` | `mREGEXP_CTOR_END(boolean _createToken, boolean fromStart)`
    `void` | `mREGEXP_LITERAL(boolean _createToken)`
    `protected void` | `mREGEXP_SYMBOL(boolean _createToken)`
    `void` | `mRPAREN(boolean _createToken)`
    `void` | `mSEMI(boolean _createToken)`
    `void` | `mSH_COMMENT(boolean _createToken)`
    `void` | `mSL_ASSIGN(boolean _createToken)`
    `void` | `mSL_COMMENT(boolean _createToken)`
    `void` | `mSL(boolean _createToken)`
    `void` | `mSPREAD_DOT(boolean _createToken)`
    `void` | `mSR_ASSIGN(boolean _createToken)`
    `void` | `mSR(boolean _createToken)`
    `void` | `mSTAR_ASSIGN(boolean _createToken)`
    `void` | `mSTAR_STAR_ASSIGN(boolean _createToken)`
    `void` | `mSTAR_STAR(boolean _createToken)`
    `void` | `mSTAR(boolean _createToken)`
    `protected void` | `mSTRING_CH(boolean _createToken)`
    `protected int` | `mSTRING_CTOR_END(boolean _createToken, boolean fromStart, boolean tripleQuote)`
    `void` | `mSTRING_LITERAL(boolean _createToken)`
    `protected void` | `mSTRING_NL(boolean _createToken, boolean allowNewline)`
    `void` | `mTRIPLE_DOT(boolean _createToken)`
    `protected void` | `mVOCAB(boolean _createToken)`
    `void` | `mWS(boolean _createToken)`
    `protected void` | `newlineCheck(boolean check)`
    `antlr.Token` | `nextToken()`
    `antlr.TokenStream` | `plumb()` This is a bit of plumbing which resumes collection of string constructor bodies, after an embedded expression has been parsed.
    `protected void` | `popParenLevel()`
    `protected void` | `pushParenLevel()`
    `protected void` | `restartStringCtor(boolean expectLiteral)`
    `void` | `setTokenObjectClass(java.lang.String name)`
    `void` | `setWhitespaceIncluded(boolean z)` Include whitespace tokens.
    `void` | `traceIn(java.lang.String rname)`
    `void` | `traceOut(java.lang.String rname)`

    - ### Methods inherited from class antlr.CharScanner

      `append, append, commit, consume, consumeUntil, consumeUntil, getCaseSensitive, getCaseSensitiveLiterals, getColumn, getCommitToPath, getFilename, getInputBuffer, getInputState, getLine, getTabSize, getText, getTokenObject, LA, mark, match, match, match, matchNot, matchRange, newline, panic, panic, reportError, reportError, reportWarning, resetText, rewind, setCaseSensitive, setColumn, setCommitToPath, setFilename, setInputState, setLine, setTabSize, setText, tab, testLiteralsTable, testLiteralsTable, toLower, traceIndent, uponEOF`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### parenLevel

          protected int parenLevel

      Bumped when inside '[x]' or '(x)', reset inside '{x}'. See ONE_NL.

    - #### suppressNewline

          protected int suppressNewline

    - #### SCS_TYPE

          protected static final int SCS_TYPE

      See Also:
        Constant Field Values

    - #### SCS_VAL

          protected static final int SCS_VAL

      See Also:
        Constant Field Values

    - #### SCS_LIT

          protected static final int SCS_LIT

      See Also:
        Constant Field Values

    - #### SCS_LIMIT

          protected static final int SCS_LIMIT

      See Also:
        Constant Field Values

    - #### SCS_SQ_TYPE

          protected static final int SCS_SQ_TYPE

      See Also:
        Constant Field Values

    - #### SCS_TQ_TYPE

          protected static final int SCS_TQ_TYPE

      See Also:
        Constant Field Values

    - #### SCS_RE_TYPE

          protected static final int SCS_RE_TYPE

      See Also:
        Constant Field Values

    - #### SCS_DRE_TYPE

          protected static final int SCS_DRE_TYPE

      See Also:
        Constant Field Values

    - #### stringCtorState

          protected int stringCtorState

    - #### parenLevelStack

          protected java.util.ArrayList parenLevelStack

      Push parenLevel here and reset whenever inside '{x}'.

    - #### lastSigTokenType

          protected int lastSigTokenType

    - #### tracing

          public static boolean tracing

    - #### parser

          protected GroovyRecognizer parser

    - #### _tokenSet_0

          public static final antlr.collections.impl.BitSet _tokenSet_0

    - #### _tokenSet_1

          public static final antlr.collections.impl.BitSet _tokenSet_1

    - #### _tokenSet_2

          public static final antlr.collections.impl.BitSet _tokenSet_2

    - #### _tokenSet_3

          public static final antlr.collections.impl.BitSet _tokenSet_3

    - #### _tokenSet_4

          public static final antlr.collections.impl.BitSet _tokenSet_4

    - #### _tokenSet_5

          public static final antlr.collections.impl.BitSet _tokenSet_5

    - #### _tokenSet_6

          public static final antlr.collections.impl.BitSet _tokenSet_6

    - #### _tokenSet_7

          public static final antlr.collections.impl.BitSet _tokenSet_7

    - #### _tokenSet_8

          public static final antlr.collections.impl.BitSet _tokenSet_8

    - #### _tokenSet_9

          public static final antlr.collections.impl.BitSet _tokenSet_9

    - #### _tokenSet_10

          public static final antlr.collections.impl.BitSet _tokenSet_10

    - #### _tokenSet_11

          public static final antlr.collections.impl.BitSet _tokenSet_11

    - #### _tokenSet_12

          public static final antlr.collections.impl.BitSet _tokenSet_12

    - #### _tokenSet_13

          public static final antlr.collections.impl.BitSet _tokenSet_13

  - ### Constructor Detail

    - #### GroovyLexer

          public GroovyLexer(java.io.InputStream in)

    - #### GroovyLexer

          public GroovyLexer(java.io.Reader in)

    - #### GroovyLexer

          public GroovyLexer(antlr.InputBuffer ib)

    - #### GroovyLexer

          public GroovyLexer(antlr.LexerSharedInputState state)

  - ### Method Detail

    - #### enableAssert

          public void enableAssert(boolean shouldEnable)

      Enable the "assert" keyword

    - #### isAssertEnabled

          public boolean isAssertEnabled()

      Query the "assert" keyword state

    - #### enableEnum

          public void enableEnum(boolean shouldEnable)

      Enable the "enum" keyword

    - #### isEnumEnabled

          public boolean isEnumEnabled()

      Query the "enum" keyword state

    - #### setWhitespaceIncluded

          public void setWhitespaceIncluded(boolean z)

      Include whitespace tokens. Note that this breaks the parser.

    - #### isWhitespaceIncluded

          public boolean isWhitespaceIncluded()

      Are whitespace tokens included?

    - #### setTokenObjectClass

          public void setTokenObjectClass(java.lang.String name)

      Overrides:
        `setTokenObjectClass` in class `antlr.CharScanner`

    - #### makeToken

          protected antlr.Token makeToken(int t)

      Overrides:
        `makeToken` in class `antlr.CharScanner`

    - #### pushParenLevel

          protected void pushParenLevel()

    - #### popParenLevel

          protected void popParenLevel()

    - #### restartStringCtor

          protected void restartStringCtor(boolean expectLiteral)

    - #### allowRegexpLiteral

          protected boolean allowRegexpLiteral()

    - #### isExpressionEndingToken

          protected static boolean isExpressionEndingToken(int ttype)

      Return true for an operator or punctuation which can end an expression. Return true for keywords, identifiers, and literals. Return true for tokens which can end expressions (right brackets, ++, --). Return false for EOF and all other operator and punctuation tokens. Used to suppress the recognition of /foo/ as opposed to the simple division operator '/'.

    - #### newlineCheck

          protected void newlineCheck(boolean check)
                               throws antlr.RecognitionException

      Throws:
        `antlr.RecognitionException`

    - #### atValidDollarEscape

          protected boolean atValidDollarEscape()
                                         throws antlr.CharStreamException

      Throws:
        `antlr.CharStreamException`

    - #### atDollarDollarEscape

          protected boolean atDollarDollarEscape()
                                          throws antlr.CharStreamException

      Throws:
        `antlr.CharStreamException`

    - #### atMultiCommentStart

          protected boolean atMultiCommentStart()
                                         throws antlr.CharStreamException

      Throws:
        `antlr.CharStreamException`

    - #### atDollarSlashEscape

          protected boolean atDollarSlashEscape()
                                         throws antlr.CharStreamException

      Throws:
        `antlr.CharStreamException`

    - #### plumb

          public antlr.TokenStream plumb()

      This is a bit of plumbing which resumes collection of string constructor bodies, after an embedded expression has been parsed. Usage: new GroovyRecognizer(new GroovyLexer(in).plumb()).

    - #### traceIn

          public void traceIn(java.lang.String rname)
                       throws antlr.CharStreamException

      Overrides:
        `traceIn` in class `antlr.CharScanner`
      Throws:
        `antlr.CharStreamException`

    - #### traceOut

          public void traceOut(java.lang.String rname)
                        throws antlr.CharStreamException

      Overrides:
        `traceOut` in class `antlr.CharScanner`
      Throws:
        `antlr.CharStreamException`

    - #### nextToken

          public antlr.Token nextToken()
                                throws antlr.TokenStreamException

      Specified by:
        `nextToken` in interface `antlr.TokenStream`
      Throws:
        `antlr.TokenStreamException`

    - #### mQUESTION

          public final void mQUESTION(boolean _createToken)
                               throws antlr.RecognitionException,
                                      antlr.CharStreamException,
                                      antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLPAREN

          public final void mLPAREN(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mRPAREN

          public final void mRPAREN(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLBRACK

          public final void mLBRACK(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mRBRACK

          public final void mRBRACK(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLCURLY

          public final void mLCURLY(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mRCURLY

          public final void mRCURLY(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mCOLON

          public final void mCOLON(boolean _createToken)
                            throws antlr.RecognitionException,
                                   antlr.CharStreamException,
                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mCOMMA

          public final void mCOMMA(boolean _createToken)
                            throws antlr.RecognitionException,
                                   antlr.CharStreamException,
                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDOT

          public final void mDOT(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mASSIGN

          public final void mASSIGN(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mCOMPARE_TO

          public final void mCOMPARE_TO(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mEQUAL

          public final void mEQUAL(boolean _createToken)
                            throws antlr.RecognitionException,
                                   antlr.CharStreamException,
                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mIDENTICAL

          public final void mIDENTICAL(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLNOT

          public final void mLNOT(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBNOT

          public final void mBNOT(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mNOT_EQUAL

          public final void mNOT_EQUAL(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mNOT_IDENTICAL

          public final void mNOT_IDENTICAL(boolean _createToken)
                                    throws antlr.RecognitionException,
                                           antlr.CharStreamException,
                                           antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDIV

          protected final void mDIV(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDIV_ASSIGN

          protected final void mDIV_ASSIGN(boolean _createToken)
                                    throws antlr.RecognitionException,
                                           antlr.CharStreamException,
                                           antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mPLUS

          public final void mPLUS(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mPLUS_ASSIGN

          public final void mPLUS_ASSIGN(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mINC

          public final void mINC(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mMINUS

          public final void mMINUS(boolean _createToken)
                            throws antlr.RecognitionException,
                                   antlr.CharStreamException,
                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mMINUS_ASSIGN

          public final void mMINUS_ASSIGN(boolean _createToken)
                                   throws antlr.RecognitionException,
                                          antlr.CharStreamException,
                                          antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDEC

          public final void mDEC(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTAR

          public final void mSTAR(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTAR_ASSIGN

          public final void mSTAR_ASSIGN(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mMOD

          public final void mMOD(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mMOD_ASSIGN

          public final void mMOD_ASSIGN(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSR

          public final void mSR(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSR_ASSIGN

          public final void mSR_ASSIGN(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBSR

          public final void mBSR(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBSR_ASSIGN

          public final void mBSR_ASSIGN(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mGE

          public final void mGE(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mGT

          public final void mGT(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSL

          public final void mSL(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSL_ASSIGN

          public final void mSL_ASSIGN(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLE

          public final void mLE(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLT

          public final void mLT(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBXOR

          public final void mBXOR(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBXOR_ASSIGN

          public final void mBXOR_ASSIGN(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBOR

          public final void mBOR(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBOR_ASSIGN

          public final void mBOR_ASSIGN(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLOR

          public final void mLOR(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBAND

          public final void mBAND(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBAND_ASSIGN

          public final void mBAND_ASSIGN(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLAND

          public final void mLAND(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSEMI

          public final void mSEMI(boolean _createToken)
                           throws antlr.RecognitionException,
                                  antlr.CharStreamException,
                                  antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDOLLAR

          protected final void mDOLLAR(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mRANGE_INCLUSIVE

          public final void mRANGE_INCLUSIVE(boolean _createToken)
                                      throws antlr.RecognitionException,
                                             antlr.CharStreamException,
                                             antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mRANGE_EXCLUSIVE

          public final void mRANGE_EXCLUSIVE(boolean _createToken)
                                      throws antlr.RecognitionException,
                                             antlr.CharStreamException,
                                             antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mTRIPLE_DOT

          public final void mTRIPLE_DOT(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSPREAD_DOT

          public final void mSPREAD_DOT(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mOPTIONAL_DOT

          public final void mOPTIONAL_DOT(boolean _createToken)
                                   throws antlr.RecognitionException,
                                          antlr.CharStreamException,
                                          antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mELVIS_OPERATOR

          public final void mELVIS_OPERATOR(boolean _createToken)
                                     throws antlr.RecognitionException,
                                            antlr.CharStreamException,
                                            antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mMEMBER_POINTER

          public final void mMEMBER_POINTER(boolean _createToken)
                                     throws antlr.RecognitionException,
                                            antlr.CharStreamException,
                                            antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mREGEX_FIND

          public final void mREGEX_FIND(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mREGEX_MATCH

          public final void mREGEX_MATCH(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTAR_STAR

          public final void mSTAR_STAR(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTAR_STAR_ASSIGN

          public final void mSTAR_STAR_ASSIGN(boolean _createToken)
                                       throws antlr.RecognitionException,
                                              antlr.CharStreamException,
                                              antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mCLOSABLE_BLOCK_OP

          public final void mCLOSABLE_BLOCK_OP(boolean _createToken)
                                        throws antlr.RecognitionException,
                                               antlr.CharStreamException,
                                               antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mWS

          public final void mWS(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mONE_NL

          protected final void mONE_NL(boolean _createToken,
                                       boolean check)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mNLS

          public final void mNLS(boolean _createToken)
                          throws antlr.RecognitionException,
                                 antlr.CharStreamException,
                                 antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSL_COMMENT

          public final void mSL_COMMENT(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mML_COMMENT

          public final void mML_COMMENT(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSH_COMMENT

          public final void mSH_COMMENT(boolean _createToken)
                                 throws antlr.RecognitionException,
                                        antlr.CharStreamException,
                                        antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTRING_LITERAL

          public final void mSTRING_LITERAL(boolean _createToken)
                                     throws antlr.RecognitionException,
                                            antlr.CharStreamException,
                                            antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTRING_CH

          protected final void mSTRING_CH(boolean _createToken)
                                   throws antlr.RecognitionException,
                                          antlr.CharStreamException,
                                          antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mESC

          protected final void mESC(boolean _createToken)
                             throws antlr.RecognitionException,
                                    antlr.CharStreamException,
                                    antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTRING_NL

          protected final void mSTRING_NL(boolean _createToken,
                                          boolean allowNewline)
                                   throws antlr.RecognitionException,
                                          antlr.CharStreamException,
                                          antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mSTRING_CTOR_END

          protected final int mSTRING_CTOR_END(boolean _createToken,
                                               boolean fromStart,
                                               boolean tripleQuote)
                                        throws antlr.RecognitionException,
                                               antlr.CharStreamException,
                                               antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mREGEXP_LITERAL

          public final void mREGEXP_LITERAL(boolean _createToken)
                                     throws antlr.RecognitionException,
                                            antlr.CharStreamException,
                                            antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mREGEXP_SYMBOL

          protected final void mREGEXP_SYMBOL(boolean _createToken)
                                       throws antlr.RecognitionException,
                                              antlr.CharStreamException,
                                              antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mREGEXP_CTOR_END

          protected final int mREGEXP_CTOR_END(boolean _createToken,
                                               boolean fromStart)
                                        throws antlr.RecognitionException,
                                               antlr.CharStreamException,
                                               antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDOLLAR_REGEXP_LITERAL

          public final void mDOLLAR_REGEXP_LITERAL(boolean _createToken)
                                            throws antlr.RecognitionException,
                                                   antlr.CharStreamException,
                                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDOLLAR_REGEXP_SYMBOL

          protected final void mDOLLAR_REGEXP_SYMBOL(boolean _createToken)
                                              throws antlr.RecognitionException,
                                                     antlr.CharStreamException,
                                                     antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDOLLAR_REGEXP_CTOR_END

          protected final int mDOLLAR_REGEXP_CTOR_END(boolean _createToken,
                                                      boolean fromStart)
                                               throws antlr.RecognitionException,
                                                      antlr.CharStreamException,
                                                      antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mESCAPED_SLASH

          protected final void mESCAPED_SLASH(boolean _createToken)
                                       throws antlr.RecognitionException,
                                              antlr.CharStreamException,
                                              antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mESCAPED_DOLLAR

          protected final void mESCAPED_DOLLAR(boolean _createToken)
                                        throws antlr.RecognitionException,
                                               antlr.CharStreamException,
                                               antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mHEX_DIGIT

          protected final void mHEX_DIGIT(boolean _createToken)
                                   throws antlr.RecognitionException,
                                          antlr.CharStreamException,
                                          antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mVOCAB

          protected final void mVOCAB(boolean _createToken)
                               throws antlr.RecognitionException,
                                      antlr.CharStreamException,
                                      antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mIDENT

          public final void mIDENT(boolean _createToken)
                            throws antlr.RecognitionException,
                                   antlr.CharStreamException,
                                   antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mLETTER

          protected final void mLETTER(boolean _createToken)
                                throws antlr.RecognitionException,
                                       antlr.CharStreamException,
                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDIGIT

          protected final void mDIGIT(boolean _createToken)
                               throws antlr.RecognitionException,
                                      antlr.CharStreamException,
                                      antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDIGITS_WITH_UNDERSCORE

          protected final void mDIGITS_WITH_UNDERSCORE(boolean _createToken)
                                                throws antlr.RecognitionException,
                                                       antlr.CharStreamException,
                                                       antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mDIGITS_WITH_UNDERSCORE_OPT

          protected final void mDIGITS_WITH_UNDERSCORE_OPT(boolean _createToken)
                                                    throws antlr.RecognitionException,
                                                           antlr.CharStreamException,
                                                           antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mNUM_INT

          public final void mNUM_INT(boolean _createToken)
                              throws antlr.RecognitionException,
                                     antlr.CharStreamException,
                                     antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mEXPONENT

          protected final void mEXPONENT(boolean _createToken)
                                  throws antlr.RecognitionException,
                                         antlr.CharStreamException,
                                         antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mFLOAT_SUFFIX

          protected final void mFLOAT_SUFFIX(boolean _createToken)
                                      throws antlr.RecognitionException,
                                             antlr.CharStreamException,
                                             antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mBIG_SUFFIX

          protected final void mBIG_SUFFIX(boolean _createToken)
                                    throws antlr.RecognitionException,
                                           antlr.CharStreamException,
                                           antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`

    - #### mAT

          public final void mAT(boolean _createToken)
                         throws antlr.RecognitionException,
                                antlr.CharStreamException,
                                antlr.TokenStreamException

      Throws:
        `antlr.RecognitionException`
        `antlr.CharStreamException`
        `antlr.TokenStreamException`