## org.codehaus.groovy.antlr.parser
Class GroovyLexer

Field Summary
`int` | `SCS_LIMIT`
`int` | `SCS_LIT`
`int` | `SCS_RE_TYPE`
`int` | `SCS_SQ_TYPE`
`int` | `SCS_TQ_TYPE`
`int` | `SCS_TYPE`
`int` | `SCS_VAL`
`BitSet` | `_tokenSet_0`
`BitSet` | `_tokenSet_1`
`BitSet` | `_tokenSet_10`
`BitSet` | `_tokenSet_2`
`BitSet` | `_tokenSet_3`
`BitSet` | `_tokenSet_4`
`BitSet` | `_tokenSet_5`
`BitSet` | `_tokenSet_6`
`BitSet` | `_tokenSet_7`
`BitSet` | `_tokenSet_8`
`BitSet` | `_tokenSet_9`
`boolean` | `assertEnabled`
`boolean` | `enumEnabled`
`int` | `lastSigTokenType`
`int` | `parenLevel`
`ArrayList` | `parenLevelStack`
`GroovyRecognizer` | `parser`
`int` | `stringCtorState`
`int` | `suppressNewline`
`boolean` | `tracing`
`def` | `ttypes`
`boolean` | `whitespaceIncluded`

Constructor Summary
`GroovyLexer(InputStream in)`
`GroovyLexer(Reader in)`
`GroovyLexer(InputBuffer ib)`
`GroovyLexer(LexerSharedInputState state)`

Method Summary
`boolean` | `allowRegexpLiteral()`
`boolean` | `atValidDollarEscape()`
`void` | `enableAssert(boolean shouldEnable)` flag for enabling 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
`static boolean` | `isExpressionEndingToken(int ttype)` Return true for an operator or punctuation which can end an expression.
`boolean` | `isWhitespaceIncluded()` Are whitespace tokens included?
`void` | `mASSIGN(boolean _createToken)`
`void` | `mAT(boolean _createToken)`
`void` | `mBAND(boolean _createToken)`
`void` | `mBAND_ASSIGN(boolean _createToken)`
`void` | `mBIG_SUFFIX(boolean _createToken)`
`void` | `mBNOT(boolean _createToken)`
`void` | `mBOR(boolean _createToken)`
`void` | `mBOR_ASSIGN(boolean _createToken)`
`void` | `mBSR(boolean _createToken)`
`void` | `mBSR_ASSIGN(boolean _createToken)`
`void` | `mBXOR(boolean _createToken)`
`void` | `mBXOR_ASSIGN(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)`
`void` | `mDIGIT(boolean _createToken)`
`void` | `mDIV(boolean _createToken)`
`void` | `mDIV_ASSIGN(boolean _createToken)`
`void` | `mDOLLAR(boolean _createToken)`
`void` | `mDOT(boolean _createToken)`
`void` | `mELVIS_OPERATOR(boolean _createToken)`
`void` | `mEQUAL(boolean _createToken)`
`void` | `mESC(boolean _createToken)`
`void` | `mEXPONENT(boolean _createToken)`
`void` | `mFLOAT_SUFFIX(boolean _createToken)`
`void` | `mGE(boolean _createToken)`
`void` | `mGT(boolean _createToken)`
`void` | `mHEX_DIGIT(boolean _createToken)`
`void` | `mIDENT(boolean _createToken)`
`void` | `mINC(boolean _createToken)`
`void` | `mLAND(boolean _createToken)`
`void` | `mLBRACK(boolean _createToken)`
`void` | `mLCURLY(boolean _createToken)`
`void` | `mLE(boolean _createToken)`
`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(boolean _createToken)`
`void` | `mMINUS_ASSIGN(boolean _createToken)`
`void` | `mML_COMMENT(boolean _createToken)`
`void` | `mMOD(boolean _createToken)`
`void` | `mMOD_ASSIGN(boolean _createToken)`
`void` | `mNLS(boolean _createToken)`
`void` | `mNOT_EQUAL(boolean _createToken)`
`void` | `mNUM_INT(boolean _createToken)`
`void` | `mONE_NL(boolean _createToken, boolean check)`
`void` | `mOPTIONAL_DOT(boolean _createToken)`
`void` | `mPLUS(boolean _createToken)`
`void` | `mPLUS_ASSIGN(boolean _createToken)`
`void` | `mQUESTION(boolean _createToken)`
`void` | `mRANGE_EXCLUSIVE(boolean _createToken)`
`void` | `mRANGE_INCLUSIVE(boolean _createToken)`
`void` | `mRBRACK(boolean _createToken)`
`void` | `mRCURLY(boolean _createToken)`
`int` | `mREGEXP_CTOR_END(boolean _createToken, boolean fromStart)`
`void` | `mREGEXP_LITERAL(boolean _createToken)`
`void` | `mREGEXP_SYMBOL(boolean _createToken)`
`void` | `mREGEX_FIND(boolean _createToken)`
`void` | `mREGEX_MATCH(boolean _createToken)`
`void` | `mRPAREN(boolean _createToken)`
`void` | `mSEMI(boolean _createToken)`
`void` | `mSH_COMMENT(boolean _createToken)`
`void` | `mSL(boolean _createToken)`
`void` | `mSL_ASSIGN(boolean _createToken)`
`void` | `mSL_COMMENT(boolean _createToken)`
`void` | `mSPREAD_DOT(boolean _createToken)`
`void` | `mSR(boolean _createToken)`
`void` | `mSR_ASSIGN(boolean _createToken)`
`void` | `mSTAR(boolean _createToken)`
`void` | `mSTAR_ASSIGN(boolean _createToken)`
`void` | `mSTAR_STAR(boolean _createToken)`
`void` | `mSTAR_STAR_ASSIGN(boolean _createToken)`
`void` | `mSTRING_CH(boolean _createToken)`
`int` | `mSTRING_CTOR_END(boolean _createToken, boolean fromStart, boolean tripleQuote)`
`void` | `mSTRING_LITERAL(boolean _createToken)`
`void` | `mSTRING_NL(boolean _createToken, boolean allowNewline)`
`void` | `mTRIPLE_DOT(boolean _createToken)`
`void` | `mVOCAB(boolean _createToken)`
`void` | `mWS(boolean _createToken)`
`static def` | `mk_tokenSet_0()`
`static def` | `mk_tokenSet_1()`
`static def` | `mk_tokenSet_10()`
`static def` | `mk_tokenSet_2()`
`static def` | `mk_tokenSet_3()`
`static def` | `mk_tokenSet_4()`
`static def` | `mk_tokenSet_5()`
`static def` | `mk_tokenSet_6()`
`static def` | `mk_tokenSet_7()`
`static def` | `mk_tokenSet_8()`
`static def` | `mk_tokenSet_9()`
`void` | `newlineCheck(boolean check)`
`Token` | `nextToken()`
`TokenStream` | `plumb()` This is a bit of plumbing which resumes collection of string constructor bodies, after an embedded expression has been parsed.
`void` | `popParenLevel()`
`void` | `pushParenLevel()`
`void` | `require(boolean z, String problem, String solution)`
`void` | `restartStringCtor(boolean expectLiteral)`
`void` | `setWhitespaceIncluded(boolean z)` Include whitespace tokens.
`static String` | `tokenStringOf(Token t)`
`void` | `traceIn(String rname)`
`void` | `traceOut(String rname)`

Constructor Detail

### GroovyLexer

    public GroovyLexer(InputStream in)

### GroovyLexer

    public GroovyLexer(Reader in)

### GroovyLexer

    public GroovyLexer(InputBuffer ib)

### GroovyLexer

    public GroovyLexer(LexerSharedInputState state)

Method Detail

### allowRegexpLiteral

    boolean allowRegexpLiteral()

### atValidDollarEscape

    boolean atValidDollarEscape()

### enableAssert

    public void enableAssert(boolean shouldEnable)

  flag for enabling the "assert" keyword

### enableEnum

    public void enableEnum(boolean shouldEnable)

  Enable the "enum" keyword

### isAssertEnabled

    public boolean isAssertEnabled()

  Query the "assert" keyword state

### isEnumEnabled

    public boolean isEnumEnabled()

  Query the "enum" keyword state

### isExpressionEndingToken

    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 '/'.

### isWhitespaceIncluded

    public boolean isWhitespaceIncluded()

  Are whitespace tokens included?

### mASSIGN

    public void mASSIGN(boolean _createToken)

### mAT

    public void mAT(boolean _createToken)

### mBAND

    public void mBAND(boolean _createToken)

### mBAND_ASSIGN

    public void mBAND_ASSIGN(boolean _createToken)

### mBIG_SUFFIX

    void mBIG_SUFFIX(boolean _createToken)

### mBNOT

    public void mBNOT(boolean _createToken)

### mBOR

    public void mBOR(boolean _createToken)

### mBOR_ASSIGN

    public void mBOR_ASSIGN(boolean _createToken)

### mBSR

    public void mBSR(boolean _createToken)

### mBSR_ASSIGN

    public void mBSR_ASSIGN(boolean _createToken)

### mBXOR

    public void mBXOR(boolean _createToken)

### mBXOR_ASSIGN

    public void mBXOR_ASSIGN(boolean _createToken)

### mCLOSABLE_BLOCK_OP

    public void mCLOSABLE_BLOCK_OP(boolean _createToken)

### mCOLON

    public void mCOLON(boolean _createToken)

### mCOMMA

    public void mCOMMA(boolean _createToken)

### mCOMPARE_TO

    public void mCOMPARE_TO(boolean _createToken)

### mDEC

    public void mDEC(boolean _createToken)

### mDIGIT

    void mDIGIT(boolean _createToken)

### mDIV

    void mDIV(boolean _createToken)

### mDIV_ASSIGN

    void mDIV_ASSIGN(boolean _createToken)

### mDOLLAR

    public void mDOLLAR(boolean _createToken)

### mDOT

    public void mDOT(boolean _createToken)

### mELVIS_OPERATOR

    public void mELVIS_OPERATOR(boolean _createToken)

### mEQUAL

    public void mEQUAL(boolean _createToken)

### mESC

    void mESC(boolean _createToken)

### mEXPONENT

    void mEXPONENT(boolean _createToken)

### mFLOAT_SUFFIX

    void mFLOAT_SUFFIX(boolean _createToken)

### mGE

    public void mGE(boolean _createToken)

### mGT

    public void mGT(boolean _createToken)

### mHEX_DIGIT

    void mHEX_DIGIT(boolean _createToken)

### mIDENT

    public void mIDENT(boolean _createToken)

### mINC

    public void mINC(boolean _createToken)

### mLAND

    public void mLAND(boolean _createToken)

### mLBRACK

    public void mLBRACK(boolean _createToken)

### mLCURLY

    public void mLCURLY(boolean _createToken)

### mLE

    public void mLE(boolean _createToken)

### mLETTER

    void mLETTER(boolean _createToken)

### mLNOT

    public void mLNOT(boolean _createToken)

### mLOR

    public void mLOR(boolean _createToken)

### mLPAREN

    public void mLPAREN(boolean _createToken)

### mLT

    public void mLT(boolean _createToken)

### mMEMBER_POINTER

    public void mMEMBER_POINTER(boolean _createToken)

### mMINUS

    public void mMINUS(boolean _createToken)

### mMINUS_ASSIGN

    public void mMINUS_ASSIGN(boolean _createToken)

### mML_COMMENT

    public void mML_COMMENT(boolean _createToken)

### mMOD

    public void mMOD(boolean _createToken)

### mMOD_ASSIGN

    public void mMOD_ASSIGN(boolean _createToken)

### mNLS

    public void mNLS(boolean _createToken)

### mNOT_EQUAL

    public void mNOT_EQUAL(boolean _createToken)

### mNUM_INT

    public void mNUM_INT(boolean _createToken)

### mONE_NL

    void mONE_NL(boolean _createToken, boolean check)

### mOPTIONAL_DOT

    public void mOPTIONAL_DOT(boolean _createToken)

### mPLUS

    public void mPLUS(boolean _createToken)

### mPLUS_ASSIGN

    public void mPLUS_ASSIGN(boolean _createToken)

### mQUESTION

    public void mQUESTION(boolean _createToken)

### mRANGE_EXCLUSIVE

    public void mRANGE_EXCLUSIVE(boolean _createToken)

### mRANGE_INCLUSIVE

    public void mRANGE_INCLUSIVE(boolean _createToken)

### mRBRACK

    public void mRBRACK(boolean _createToken)

### mRCURLY

    public void mRCURLY(boolean _createToken)

### mREGEXP_CTOR_END

    int mREGEXP_CTOR_END(boolean _createToken, boolean fromStart)

### mREGEXP_LITERAL

    public void mREGEXP_LITERAL(boolean _createToken)

### mREGEXP_SYMBOL

    void mREGEXP_SYMBOL(boolean _createToken)

### mREGEX_FIND

    public void mREGEX_FIND(boolean _createToken)

### mREGEX_MATCH

    public void mREGEX_MATCH(boolean _createToken)

### mRPAREN

    public void mRPAREN(boolean _createToken)

### mSEMI

    public void mSEMI(boolean _createToken)

### mSH_COMMENT

    public void mSH_COMMENT(boolean _createToken)

### mSL

    public void mSL(boolean _createToken)

### mSL_ASSIGN

    public void mSL_ASSIGN(boolean _createToken)

### mSL_COMMENT

    public void mSL_COMMENT(boolean _createToken)

### mSPREAD_DOT

    public void mSPREAD_DOT(boolean _createToken)

### mSR

    public void mSR(boolean _createToken)

### mSR_ASSIGN

    public void mSR_ASSIGN(boolean _createToken)

### mSTAR

    public void mSTAR(boolean _createToken)

### mSTAR_ASSIGN

    public void mSTAR_ASSIGN(boolean _createToken)

### mSTAR_STAR

    public void mSTAR_STAR(boolean _createToken)

### mSTAR_STAR_ASSIGN

    public void mSTAR_STAR_ASSIGN(boolean _createToken)

### mSTRING_CH

    void mSTRING_CH(boolean _createToken)

### mSTRING_CTOR_END

    int mSTRING_CTOR_END(boolean _createToken, boolean fromStart, boolean tripleQuote)

### mSTRING_LITERAL

    public void mSTRING_LITERAL(boolean _createToken)

### mSTRING_NL

    void mSTRING_NL(boolean _createToken, boolean allowNewline)

### mTRIPLE_DOT

    public void mTRIPLE_DOT(boolean _createToken)

### mVOCAB

    void mVOCAB(boolean _createToken)

### mWS

    public void mWS(boolean _createToken)

### mk_tokenSet_0

    static def mk_tokenSet_0()

### mk_tokenSet_1

    static def mk_tokenSet_1()

### mk_tokenSet_10

    static def mk_tokenSet_10()

### mk_tokenSet_2

    static def mk_tokenSet_2()

### mk_tokenSet_3

    static def mk_tokenSet_3()

### mk_tokenSet_4

    static def mk_tokenSet_4()

### mk_tokenSet_5

    static def mk_tokenSet_5()

### mk_tokenSet_6

    static def mk_tokenSet_6()

### mk_tokenSet_7

    static def mk_tokenSet_7()

### mk_tokenSet_8

    static def mk_tokenSet_8()

### mk_tokenSet_9

    static def mk_tokenSet_9()

### newlineCheck

    void newlineCheck(boolean check)

### nextToken

    public Token nextToken()

### plumb

    public 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()).

### popParenLevel

    void popParenLevel()

### pushParenLevel

    void pushParenLevel()

### require

    void require(boolean z, String problem, String solution)

### restartStringCtor

    void restartStringCtor(boolean expectLiteral)

### setWhitespaceIncluded

    public void setWhitespaceIncluded(boolean z)

  Include whitespace tokens. Note that this breaks the parser.

### tokenStringOf

    static String tokenStringOf(Token t)

### traceIn

    public void traceIn(String rname)

### traceOut

    public void traceOut(String rname)