From 1aad49904fb2220bd3b93f31ab0c335aed025841 Mon Sep 17 00:00:00 2001 From: Maxim Medvedev Date: Tue, 6 Sep 2011 16:11:53 +0400 Subject: [PATCH] get rid of GroovyTokenTypes.mWS. Use TokenType.WHITE_SPACE instead. --- .../generate/GroovyGenerationInfo.java | 4 +- .../bugs/GroovyRangeTypeCheckInspection.java | 9 +- .../highlighter/GroovyBraceMatcher.java | 1 - .../editor/actions/GroovyEnterHandler.java | 4 +- .../lang/groovydoc/lexer/GroovyDocLexer.java | 7 +- .../groovydoc/lexer/GroovyDocTokenTypes.java | 4 +- .../lang/groovydoc/lexer/_GroovyDocLexer.java | 94 +- .../groovy/lang/groovydoc/lexer/gdoc.flex | 15 +- .../groovy/lang/lexer/GroovyLexer.java | 7 +- .../groovy/lang/lexer/GroovyTokenTypes.java | 1 - .../plugins/groovy/lang/lexer/TokenSets.java | 5 +- .../groovy/lang/lexer/_GroovyLexer.java | 1353 +++++++++-------- .../plugins/groovy/lang/lexer/groovy.flex | 21 +- .../lang/parser/GroovyParserDefinition.java | 6 +- 14 files changed, 771 insertions(+), 760 deletions(-) diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/actions/generate/GroovyGenerationInfo.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/actions/generate/GroovyGenerationInfo.java index 445e55b465d9..66beada33ee4 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/actions/generate/GroovyGenerationInfo.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/actions/generate/GroovyGenerationInfo.java @@ -24,7 +24,7 @@ import com.intellij.psi.tree.IElementType; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.plugins.groovy.lang.GrReferenceAdjuster; -import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes; +import org.jetbrains.plugins.groovy.lang.lexer.TokenSets; import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement; import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition; @@ -72,7 +72,7 @@ public class GroovyGenerationInfo extends PsiGenerationInfo } final IElementType type = element.getNode().getElementType(); - if (type == GroovyTokenTypes.mNLS || type == GroovyTokenTypes.mWS) { + if (TokenSets.WHITE_SPACES_SET.contains(type)) { return element.getNextSibling(); } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/GroovyRangeTypeCheckInspection.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/GroovyRangeTypeCheckInspection.java index 09c7337e1dbc..b3a037cb2aca 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/GroovyRangeTypeCheckInspection.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/GroovyRangeTypeCheckInspection.java @@ -36,7 +36,6 @@ import org.jetbrains.plugins.groovy.codeInspection.BaseInspectionVisitor; import org.jetbrains.plugins.groovy.codeInspection.GroovyFix; import org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle; import org.jetbrains.plugins.groovy.lang.GrReferenceAdjuster; -import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes; import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory; import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult; import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrCodeBlock; @@ -286,8 +285,8 @@ public class GroovyRangeTypeCheckInspection extends BaseInspection { } if (anchor == null) return; list = (GrReferenceList)myPsiClass.addBefore(list, anchor); - myPsiClass.getNode().addLeaf(GroovyTokenTypes.mWS, " ", anchor.getNode()); - myPsiClass.getNode().addLeaf(GroovyTokenTypes.mWS, " ", list.getNode()); + myPsiClass.getNode().addLeaf(TokenType.WHITE_SPACE, " ", anchor.getNode()); + myPsiClass.getNode().addLeaf(TokenType.WHITE_SPACE, " ", list.getNode()); } } else { @@ -297,8 +296,8 @@ public class GroovyRangeTypeCheckInspection extends BaseInspection { PsiElement anchor = myPsiClass.getBody(); if (anchor == null) return; list = (GrReferenceList)myPsiClass.addBefore(list, anchor); - myPsiClass.getNode().addLeaf(GroovyTokenTypes.mWS, " ", list.getNode()); - myPsiClass.getNode().addLeaf(GroovyTokenTypes.mWS, " ", anchor.getNode()); + myPsiClass.getNode().addLeaf(TokenType.WHITE_SPACE, " ", list.getNode()); + myPsiClass.getNode().addLeaf(TokenType.WHITE_SPACE, " ", anchor.getNode()); } } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/highlighter/GroovyBraceMatcher.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/highlighter/GroovyBraceMatcher.java index 4fe4f106afff..afb6fb98d793 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/highlighter/GroovyBraceMatcher.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/highlighter/GroovyBraceMatcher.java @@ -53,7 +53,6 @@ public class GroovyBraceMatcher implements PairedBraceMatcher { public boolean isPairedBracesAllowedBeforeType(@NotNull IElementType ibraceType, @Nullable IElementType tokenType) { return tokenType == null - || GroovyTokenTypes.mWS == tokenType || TokenType.WHITE_SPACE == tokenType || TokenSets.COMMENT_SET.contains(tokenType) || tokenType == GroovyTokenTypes.mSEMI diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/editor/actions/GroovyEnterHandler.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/editor/actions/GroovyEnterHandler.java index e770e32c753d..25b2116f8f30 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/editor/actions/GroovyEnterHandler.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/editor/actions/GroovyEnterHandler.java @@ -67,7 +67,7 @@ public class GroovyEnterHandler extends EnterHandlerDelegateAdapter { if (caret >= 1 && caret < text.length() && CodeInsightSettings.getInstance().SMART_INDENT_ON_ENTER) { HighlighterIterator iterator = highlighter.createIterator(caret); iterator.retreat(); - while (!iterator.atEnd() && (mWS == iterator.getTokenType() || TokenType.WHITE_SPACE == iterator.getTokenType())) { + while (!iterator.atEnd() && TokenType.WHITE_SPACE == iterator.getTokenType()) { iterator.retreat(); } boolean afterArrow = !iterator.atEnd() && iterator.getTokenType() == mCLOSABLE_BLOCK_OP; @@ -78,7 +78,7 @@ public class GroovyEnterHandler extends EnterHandlerDelegateAdapter { } iterator = highlighter.createIterator(editor.getCaretModel().getOffset()); - while (!iterator.atEnd() && (mWS == iterator.getTokenType() || TokenType.WHITE_SPACE == iterator.getTokenType())) { + while (!iterator.atEnd() && TokenType.WHITE_SPACE == iterator.getTokenType()) { iterator.advance(); } if (!iterator.atEnd() && mRCURLY == iterator.getTokenType()) { diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocLexer.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocLexer.java index ec08cf5eb4d2..95aefa370e8c 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocLexer.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocLexer.java @@ -18,6 +18,7 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.lexer; import com.intellij.lexer.LexerBase; import com.intellij.lexer.MergingLexerAdapter; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import com.intellij.util.text.CharArrayUtil; @@ -31,7 +32,7 @@ public class GroovyDocLexer extends MergingLexerAdapter implements GroovyDocToke private static final TokenSet TOKENS_TO_MERGE = TokenSet.create( mGDOC_COMMENT_DATA, - mGDOC_WHITESPACE + TokenType.WHITE_SPACE ); public GroovyDocLexer() { @@ -101,7 +102,7 @@ public class GroovyDocLexer extends MergingLexerAdapter implements GroovyDocToke if (myTokenType != null) return; _locateToken(); - if (myTokenType == mGDOC_WHITESPACE) { + if (myTokenType == TokenType.WHITE_SPACE) { myAfterLineBreak = CharArrayUtil.containLineBreaks(myBuffer, getTokenStart(), getTokenEnd()); } } @@ -148,7 +149,7 @@ public class GroovyDocLexer extends MergingLexerAdapter implements GroovyDocToke if (myBufferIndex < myTokenEndOffset) { myTokenType = lf || state == _GroovyDocLexer.PARAM_TAG_SPACE || state == _GroovyDocLexer.TAG_DOC_SPACE || state == _GroovyDocLexer.INLINE_TAG_NAME || state == _GroovyDocLexer.DOC_TAG_VALUE_IN_PAREN - ? mGDOC_WHITESPACE + ? TokenType.WHITE_SPACE : mGDOC_COMMENT_DATA; return; diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocTokenTypes.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocTokenTypes.java index 2e66af1d9164..5c8e18a29b3f 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocTokenTypes.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/GroovyDocTokenTypes.java @@ -16,8 +16,8 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.lexer; -import com.intellij.psi.tree.TokenSet; import com.intellij.psi.tree.IElementType; +import com.intellij.psi.tree.TokenSet; import org.jetbrains.plugins.groovy.lang.groovydoc.parser.elements.GroovyDocTagValueTokenType; /** @@ -51,7 +51,7 @@ public interface GroovyDocTokenTypes { mGDOC_COMMENT_END, mGDOC_COMMENT_DATA, mGDOC_TAG_NAME, - mGDOC_WHITESPACE, +// mGDOC_WHITESPACE, mGDOC_TAG_VALUE_TOKEN, mGDOC_TAG_VALUE_LPAREN, mGDOC_TAG_VALUE_RPAREN, diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/_GroovyDocLexer.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/_GroovyDocLexer.java index c89e7dfe2a35..d19451242790 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/_GroovyDocLexer.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/_GroovyDocLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.1 on 12/18/09 8:54 PM */ +/* The following code was generated by JFlex 1.4.3 on 06.09.11 15:42 */ /* * Copyright 2000-2008 JetBrains s.r.o. @@ -18,29 +18,41 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.lexer; import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; /** * This class is a scanner generated by - * JFlex 1.4.1 - * on 12/18/09 8:54 PM from the specification file - * /Users/ilya/work/git/IDEA/tools/lexer/../../community/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex + * JFlex 1.4.3 + * on 06.09.11 15:42 from the specification file + * C:/Home/IDEA/tools/lexer/../../community/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex */ -public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes { +public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes, TokenType { /** initial size of the lookahead buffer */ private static final int ZZ_BUFFERSIZE = 16384; /** lexical states */ - public static final int INLINE_TAG_NAME = 8; - public static final int PARAM_TAG_SPACE = 4; - public static final int COMMENT_DATA = 2; - public static final int DOC_TAG_VALUE = 5; - public static final int COMMENT_DATA_START = 1; - public static final int TAG_DOC_SPACE = 3; + public static final int INLINE_TAG_NAME = 16; + public static final int PARAM_TAG_SPACE = 8; + public static final int COMMENT_DATA = 4; + public static final int DOC_TAG_VALUE = 10; + public static final int COMMENT_DATA_START = 2; + public static final int TAG_DOC_SPACE = 6; public static final int YYINITIAL = 0; - public static final int DOC_TAG_VALUE_IN_PAREN = 6; - public static final int DOC_TAG_VALUE_IN_LTGT = 7; + public static final int DOC_TAG_VALUE_IN_PAREN = 12; + public static final int DOC_TAG_VALUE_IN_LTGT = 14; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, + 8, 8 + }; /** * Translates characters to character classes @@ -524,7 +536,7 @@ public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes { zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; - zzState = zzLexicalState; + zzState = ZZ_LEXSTATE[zzLexicalState]; zzForAction: { @@ -572,8 +584,8 @@ public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes { zzMarkedPos = zzMarkedPosL; switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { - case 9: - { yybegin(COMMENT_DATA); return mGDOC_WHITESPACE; + case 8: + { yybegin(DOC_TAG_VALUE); return WHITE_SPACE; } case 21: break; case 15: @@ -596,30 +608,28 @@ public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes { { yybegin(COMMENT_DATA_START); return mGDOC_COMMENT_START; } case 26: break; + case 3: + { return WHITE_SPACE; + } + case 27: break; case 20: { yybegin(PARAM_TAG_SPACE); return mGDOC_TAG_NAME; } - case 27: break; + case 28: break; case 18: { yybegin(TAG_DOC_SPACE); return mGDOC_TAG_NAME; } - case 28: break; - case 4: - { if (checkAhead('@')){ - yybegin(INLINE_TAG_NAME); - } - else{ - yybegin(COMMENT_DATA); - } - return mGDOC_INLINE_TAG_START; - } case 29: break; case 16: { yybegin(COMMENT_DATA); return mGDOC_TAG_VALUE_GT; } case 30: break; - case 3: - { return mGDOC_WHITESPACE; + case 7: + { if (checkAhead('<') || checkAhead('\"')) yybegin(COMMENT_DATA); + else if (checkAhead('\u007b') ) yybegin(COMMENT_DATA); //lbrace - there's some error in JLex when typing lbrace directly + else yybegin(DOC_TAG_VALUE); + + return WHITE_SPACE; } case 31: break; case 11: @@ -630,29 +640,31 @@ public class _GroovyDocLexer implements FlexLexer, GroovyDocTokenTypes { { yybegin(COMMENT_DATA); return mGDOC_INLINE_TAG_END; } case 33: break; - case 7: - { if (checkAhead('<') || checkAhead('\"')) yybegin(COMMENT_DATA); - else if (checkAhead('\u007b') ) yybegin(COMMENT_DATA); //lbrace - there's some error in JLex when typing lbrace directly - else yybegin(DOC_TAG_VALUE); - - return mGDOC_WHITESPACE; + case 4: + { if (checkAhead('@')){ + yybegin(INLINE_TAG_NAME); + } + else{ + yybegin(COMMENT_DATA); + } + return mGDOC_INLINE_TAG_START; } case 34: break; - case 8: - { yybegin(DOC_TAG_VALUE); return mGDOC_WHITESPACE; - } - case 35: break; case 17: { return mGDOC_COMMENT_END; } - case 36: break; + case 35: break; case 10: { return mGDOC_TAG_VALUE_TOKEN; } - case 37: break; + case 36: break; case 14: { yybegin(DOC_TAG_VALUE_IN_LTGT); return mGDOC_TAG_VALUE_LT; } + case 37: break; + case 9: + { yybegin(COMMENT_DATA); return WHITE_SPACE; + } case 38: break; case 13: { return mGDOC_TAG_VALUE_COMMA; diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex index 273137019110..d587bed073fe 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/groovydoc/lexer/gdoc.flex @@ -17,11 +17,12 @@ package org.jetbrains.plugins.groovy.lang.groovydoc.lexer; import com.intellij.lexer.FlexLexer; import com.intellij.psi.tree.IElementType; +import com.intellij.psi.TokenType; %% %class _GroovyDocLexer -%implements FlexLexer, GroovyDocTokenTypes +%implements FlexLexer, GroovyDocTokenTypes, TokenType %unicode %public @@ -77,20 +78,20 @@ IDENTIFIER={ALPHA}({ALPHA}|{DIGIT}|[":.-"])* %% "/**" { yybegin(COMMENT_DATA_START); return mGDOC_COMMENT_START; } - {WHITE_DOC_SPACE_CHAR}+ { return mGDOC_WHITESPACE; } + {WHITE_DOC_SPACE_CHAR}+ { return WHITE_SPACE; } {WHITE_DOC_SPACE_NO_NL}+ { return mGDOC_COMMENT_DATA; } - [\n\r]+{WHITE_DOC_SPACE_CHAR}* { return mGDOC_WHITESPACE; } + [\n\r]+{WHITE_DOC_SPACE_CHAR}* { return WHITE_SPACE; } - {WHITE_DOC_SPACE_CHAR}+ { yybegin(COMMENT_DATA); return mGDOC_WHITESPACE; } + {WHITE_DOC_SPACE_CHAR}+ { yybegin(COMMENT_DATA); return WHITE_SPACE; } ({ALPHA}|[_0-9\."$"\[\]])+ { return mGDOC_TAG_VALUE_TOKEN; } [\(] { yybegin(DOC_TAG_VALUE_IN_PAREN); return mGDOC_TAG_VALUE_LPAREN; } [\)] { yybegin(DOC_TAG_VALUE); return mGDOC_TAG_VALUE_RPAREN; } [#] { return mGDOC_TAG_VALUE_SHARP_TOKEN; } [,] { return mGDOC_TAG_VALUE_COMMA; } - {WHITE_DOC_SPACE_CHAR}+ { return mGDOC_WHITESPACE; } + {WHITE_DOC_SPACE_CHAR}+ { return WHITE_SPACE; } "@param" { yybegin(PARAM_TAG_SPACE); return mGDOC_TAG_NAME; } - {WHITE_DOC_SPACE_CHAR}+ {yybegin(DOC_TAG_VALUE); return mGDOC_WHITESPACE;} + {WHITE_DOC_SPACE_CHAR}+ {yybegin(DOC_TAG_VALUE); return WHITE_SPACE;} [\<] { yybegin(DOC_TAG_VALUE_IN_LTGT); return mGDOC_TAG_VALUE_LT; } {IDENTIFIER} { return mGDOC_TAG_VALUE_TOKEN; } [\>] { yybegin(COMMENT_DATA); return mGDOC_TAG_VALUE_GT; } @@ -116,7 +117,7 @@ IDENTIFIER={ALPHA}({ALPHA}|{DIGIT}|[":.-"])* else if (checkAhead('\u007b') ) yybegin(COMMENT_DATA); //lbrace - there's some error in JLex when typing lbrace directly else yybegin(DOC_TAG_VALUE); - return mGDOC_WHITESPACE; + return WHITE_SPACE; } "*"+"/" { return mGDOC_COMMENT_END; } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyLexer.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyLexer.java index 377dcce335c3..74eeaec421c1 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyLexer.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyLexer.java @@ -22,6 +22,7 @@ import com.intellij.lexer.MergingLexerAdapter; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; +import static com.intellij.psi.TokenType.WHITE_SPACE; import static org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes.*; /** @@ -34,7 +35,7 @@ public class GroovyLexer extends LookAheadLexer { mREGEX_BEGIN, mREGEX_CONTENT, mREGEX_END, - mWS + WHITE_SPACE ); public GroovyLexer() { @@ -47,8 +48,8 @@ public class GroovyLexer extends LookAheadLexer { if (type == mDOT || type == kIMPORT || type == kPACKAGE) { addToken(type); baseLexer.advance(); - while (baseLexer.getTokenType() == mWS) { - addToken(mWS); + while (baseLexer.getTokenType() == WHITE_SPACE) { + addToken(WHITE_SPACE); baseLexer.advance(); } final IElementType token = baseLexer.getTokenType(); diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyTokenTypes.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyTokenTypes.java index 1ced1d3bfcbc..08502bac1eb5 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyTokenTypes.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/GroovyTokenTypes.java @@ -35,7 +35,6 @@ public interface GroovyTokenTypes extends GroovyDocElementTypes { * Whitespaces & NewLines * ****************************************************************************************************/ - IElementType mWS = new GroovyElementType("white space"); IElementType mNLS = new GroovyElementType("new line"); /* ************************************************************************************************** diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/TokenSets.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/TokenSets.java index 2761af173e49..76ce926d9ea9 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/TokenSets.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/TokenSets.java @@ -46,8 +46,7 @@ public abstract class TokenSets { public static TokenSet WHITE_SPACE_TOKEN_SET = TokenSet.create( - mWS, - mGDOC_WHITESPACE + TokenType.WHITE_SPACE ); public static final TokenSet NUMBERS = TokenSet.create(mNUM_INT, @@ -139,7 +138,7 @@ public abstract class TokenSets { mGE, kIN ); - public static final TokenSet WHITE_SPACES_SET = TokenSet.create(mWS, mNLS, TokenType.WHITE_SPACE); + public static final TokenSet WHITE_SPACES_SET = TokenSet.create(mNLS, TokenType.WHITE_SPACE); public static final TokenSet COMMENT_SET = TokenSet.create(mML_COMMENT, mSH_COMMENT, mSL_COMMENT, GROOVY_DOC_COMMENT); diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/_GroovyLexer.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/_GroovyLexer.java index 44f74656d5a7..00916a48881c 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/_GroovyLexer.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/_GroovyLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 03.09.11 14:18 */ +/* The following code was generated by JFlex 1.4.3 on 06.09.11 15:37 */ /* * Copyright 2000-2010 JetBrains s.r.o. @@ -18,6 +18,7 @@ package org.jetbrains.plugins.groovy.lang.lexer; import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import java.util.Stack; @@ -26,10 +27,10 @@ import java.util.Stack; /** * This class is a scanner generated by * JFlex 1.4.3 - * on 03.09.11 14:18 from the specification file + * on 06.09.11 15:37 from the specification file * C:/Home/IDEA/tools/lexer/../../community/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/groovy.flex */ -public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { +public class _GroovyLexer implements FlexLexer, GroovyTokenTypes, TokenType { /** initial size of the lookahead buffer */ private static final int ZZ_BUFFERSIZE = 16384; @@ -1762,67 +1763,197 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { zzMarkedPos = zzMarkedPosL; switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { - case 73: + case 6: { yybegin(WAIT_FOR_REGEX); - return(mSPREAD_DOT); + return(mSTAR); } case 172: break; + case 76: + { yybegin(WAIT_FOR_REGEX); + return(mNOT_EQUAL); + } + case 173: break; + case 56: + { blockStack.push(mLCURLY); + braceCount.push(mLCURLY); + yybegin(NLS_AFTER_LBRACE); + return(mLCURLY); + } + case 174: break; + case 130: + { return( kTRUE ); + } + case 175: break; + case 129: + { return( kNULL ); + } + case 176: break; + case 24: + { yybegin(WAIT_FOR_REGEX); + return(mCOMMA); + } + case 177: break; + case 127: + { return( kENUM ); + } + case 178: break; + case 86: + { yybegin(WAIT_FOR_REGEX); + return(mDEC); + } + case 179: break; + case 83: + { return( kDO ); + } + case 180: break; + case 89: + { yybegin(WAIT_FOR_REGEX); + return(mRANGE_INCLUSIVE); + } + case 181: break; + case 75: + { return mSH_COMMENT; + } + case 182: break; + case 60: + { return mWRONG_REGEX_LITERAL; + } + case 183: break; + case 122: + { yybegin(WAIT_FOR_REGEX); + return(mSR_ASSIGN); + } + case 184: break; + case 62: + { yybegin(IN_REGEX_DOT); + return mIDENT; + } + case 185: break; + case 58: + { yypushback(1); + if (blockStack.isEmpty()){ + yybegin(YYINITIAL); + } else { + yybegin(IN_INNER_BLOCK); + } + } + case 186: break; + case 8: + { return mIDENT; + } + case 187: break; + case 26: + { yybegin(WAIT_FOR_REGEX); + return(mGT); + } + case 188: break; + case 144: + { return( kSUPER ); + } + case 189: break; + case 118: + { yybegin(IN_TRIPLE_GSTRING); + gStringStack.push(mLBRACK); + return mGSTRING_BEGIN; + } + case 190: break; + case 71: + { yybegin(WAIT_FOR_REGEX); + return(mDIV_ASSIGN); + } + case 191: break; + case 169: + { return( kINSTANCEOF ); + } + case 192: break; + case 95: + { yybegin(WAIT_FOR_REGEX); + return(mEQUAL); + } + case 193: break; + case 19: + { yybegin(WAIT_FOR_REGEX); + braceCount.push(mLPAREN); + return(mLPAREN); + } + case 194: break; + case 23: + { yybegin(WAIT_FOR_REGEX); + return(mCOLON); + } + case 195: break; + case 154: + { return( kSTATIC ); + } + case 196: break; + case 51: + { if (blockStack.isEmpty()){ + yybegin(YYINITIAL); + } else { + yybegin(IN_INNER_BLOCK); + } + return mREGEX_END; + } + case 197: break; + case 143: + { return( kCATCH ); + } + case 198: break; + case 30: + { yybegin(WAIT_FOR_REGEX); + return(mBOR); + } + case 199: break; + case 54: + { return mREGEX_CONTENT; + } + case 200: break; case 28: { yybegin(WAIT_FOR_REGEX); return(mMOD); } - case 173: break; - case 47: - { yybegin(NLS_AFTER_NLS); - afterComment = IN_TRIPLE_IDENT; - return mNLS; - } - case 174: break; - case 4: - { return mWS; - } - case 175: break; - case 109: + case 201: break; + case 25: { yybegin(WAIT_FOR_REGEX); - return(mSTAR_STAR_ASSIGN); + return(mLT); } - case 176: break; - case 130: - { return( kTRUE ); + case 202: break; + case 168: + { return( kPROTECTED ); } - case 177: break; - case 119: + case 203: break; + case 110: + { return mNUM_BIG_DECIMAL; + } + case 204: break; + case 73: { yybegin(WAIT_FOR_REGEX); - return(mREGEX_MATCH); + return(mSPREAD_DOT); } - case 178: break; - case 72: - { yybegin(WAIT_FOR_REGEX); - return(mSTAR_STAR); + case 205: break; + case 148: + { return( kDOUBLE ); } - case 179: break; - case 129: - { return( kNULL ); + case 206: break; + case 38: + { yybegin(IN_TRIPLE_DOT); + return mIDENT; } - case 180: break; - case 127: - { return( kENUM ); - } - case 181: break; - case 55: - { yybegin(KING_STATE_CONTENT); - return mREGEX_CONTENT; - } - case 182: break; - case 63: - { blockStack.push(mDIV); + case 207: break; + case 36: + { blockStack.push(mLPAREN); braceCount.push(mLCURLY); yybegin(NLS_AFTER_LBRACE); return mLCURLY; } - case 183: break; - case 64: - { if (!gStringStack.isEmpty()) { + case 208: break; + case 53: + { yypushback(yytext().length()); + yybegin(KING_STATE_INNER_CONTENT); + } + case 209: break; + case 123: + { if (!gStringStack.isEmpty()){ gStringStack.pop(); } if (blockStack.isEmpty()){ @@ -1830,26 +1961,136 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } else { yybegin(IN_INNER_BLOCK); } - return mREGEX_END; + return mGSTRING_END; } - case 184: break; - case 83: - { return( kDO ); + case 210: break; + case 116: + { return( kNEW ); } - case 185: break; - case 68: + case 211: break; + case 48: + { yypushback(yytext().length()); + yybegin(KING_STATE_INNER); + } + case 212: break; + case 149: + { return( kNATIVE ); + } + case 213: break; + case 90: + { yybegin(WAIT_FOR_REGEX); + return(mMEMBER_POINTER); + } + case 214: break; + case 20: + { if (!braceCount.isEmpty() && mLPAREN == braceCount.peek()) { + braceCount.pop(); + } + return(mRPAREN); + } + case 215: break; + case 67: { yypushback(1); - yybegin(NLS_AFTER_COMMENT); + yybegin(WAIT_FOR_REGEX); } - case 186: break; - case 75: - { return mSH_COMMENT; + case 216: break; + case 111: + { return( kFOR ); } - case 187: break; - case 60: - { return mWRONG_REGEX_LITERAL; + case 217: break; + case 133: + { return( kCHAR ); } - case 188: break; + case 218: break; + case 147: + { return( kIMPORT ); + } + case 219: break; + case 93: + { yybegin(WAIT_FOR_REGEX); + return(mOPTIONAL_DOT); + } + case 220: break; + case 103: + { yybegin(WAIT_FOR_REGEX); + return(mBAND_ASSIGN); + } + case 221: break; + case 158: + { return( kEXTENDS ); + } + case 222: break; + case 10: + { yybegin(WAIT_FOR_REGEX); + return(mPLUS); + } + case 223: break; + case 96: + { yybegin(WAIT_FOR_REGEX); + return(mREGEX_FIND); + } + case 224: break; + case 27: + { yybegin(WAIT_FOR_REGEX); + return(mBNOT); + } + case 225: break; + case 101: + { yybegin(WAIT_FOR_REGEX); + return(mBOR_ASSIGN); + } + case 226: break; + case 156: + { return( kFINALLY ); + } + case 227: break; + case 102: + { yybegin(WAIT_FOR_REGEX); + return(mLOR); + } + case 228: break; + case 74: + { yybegin(WAIT_FOR_REGEX); + return(mSTAR_ASSIGN); + } + case 229: break; + case 134: + { return( kVOID ); + } + case 230: break; + case 152: + { return( kPUBLIC ); + } + case 231: break; + case 126: + { return( kELSE ); + } + case 232: break; + case 39: + { blockStack.push(mLBRACK); + braceCount.push(mLCURLY); + yybegin(NLS_AFTER_LBRACE); + return mLCURLY; + } + case 233: break; + case 14: + { return mSTRING_LITERAL; + } + case 234: break; + case 87: + { yybegin(WAIT_FOR_REGEX); + return(mMINUS_ASSIGN); + } + case 235: break; + case 88: + { yybegin(WAIT_FOR_REGEX); + return(mCLOSABLE_BLOCK_OP); + } + case 236: break; + case 170: + { return( kIMPLEMENTS ); + } + case 237: break; case 43: { if (!gStringStack.isEmpty()) { gStringStack.pop(); @@ -1861,103 +2102,75 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } return mGSTRING_END; } - case 189: break; - case 8: - { return mIDENT; - } - case 190: break; - case 144: - { return( kSUPER ); - } - case 191: break; - case 96: - { yybegin(WAIT_FOR_REGEX); - return(mREGEX_FIND); - } - case 192: break; - case 101: - { yybegin(WAIT_FOR_REGEX); - return(mBOR_ASSIGN); - } - case 193: break; - case 169: - { return( kINSTANCEOF ); - } - case 194: break; - case 36: - { blockStack.push(mLPAREN); - braceCount.push(mLCURLY); - yybegin(NLS_AFTER_LBRACE); - return mLCURLY; - } - case 195: break; - case 76: - { yybegin(WAIT_FOR_REGEX); - return(mNOT_EQUAL); - } - case 196: break; - case 105: - // lookahead expression with fixed base length - zzMarkedPos = zzStartRead + 1; - { yybegin(IN_SINGLE_IDENT); - return mDOT; - } - case 197: break; - case 154: - { return( kSTATIC ); - } - case 198: break; - case 102: - { yybegin(WAIT_FOR_REGEX); - return(mLOR); - } - case 199: break; - case 65: - { yypushback(1); - yybegin(IN_REGEX); - } - case 200: break; - case 143: - { return( kCATCH ); - } - case 201: break; - case 52: - { yybegin(KING_STATE); - return mREGEX_BEGIN; - } - case 202: break; - case 54: - { return mREGEX_CONTENT; - } - case 203: break; + case 238: break; case 99: { yybegin(WAIT_FOR_REGEX); return(mMOD_ASSIGN); } - case 204: break; - case 168: - { return( kPROTECTED ); - } - case 205: break; - case 89: + case 239: break; + case 17: { yybegin(WAIT_FOR_REGEX); - return(mRANGE_INCLUSIVE); + return(mQUESTION); } - case 206: break; - case 110: - { return mNUM_BIG_DECIMAL; + case 240: break; + case 9: + { return mNUM_INT; } - case 207: break; - case 26: + case 241: break; + case 166: + { return( kINTERFACE ); + } + case 242: break; + case 32: { yybegin(WAIT_FOR_REGEX); - return(mGT); + return(mSEMI); } - case 208: break; - case 34: - { yypushback(1); - yybegin(IN_SINGLE_GSTRING); + case 243: break; + case 161: + { return( kPACKAGE ); } - case 209: break; + case 244: break; + case 141: + { return( kTHROW ); + } + case 245: break; + case 136: + { if (blockStack.isEmpty()){ + yybegin(YYINITIAL); + } else { + yybegin(IN_INNER_BLOCK); + } + return(mDOLLAR_SLASHY_LITERAL); + } + case 246: break; + case 18: + { yybegin(WAIT_FOR_REGEX); + return(mASSIGN); + } + case 247: break; + case 82: + { return( kIN ); + } + case 248: break; + case 69: + { return mSL_COMMENT; + } + case 249: break; + case 13: + { yybegin(IN_SINGLE_GSTRING); + gStringStack.push(mLPAREN); + return mGSTRING_BEGIN; + } + case 250: break; + case 128: + { return( kBYTE ); + } + case 251: break; + case 104: + { yybegin(WAIT_FOR_REGEX); + return(mLAND); + } + case 252: break; case 124: { if (blockStack.isEmpty()){ yybegin(YYINITIAL); @@ -1966,166 +2179,160 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } return(mREGEX_LITERAL); } - case 210: break; - case 48: - { yypushback(yytext().length()); - yybegin(KING_STATE_INNER); - } - case 211: break; - case 122: - { yybegin(WAIT_FOR_REGEX); - return(mSR_ASSIGN); - } - case 212: break; - case 148: - { return( kDOUBLE ); - } - case 213: break; - case 118: - { yybegin(IN_TRIPLE_GSTRING); - gStringStack.push(mLBRACK); - return mGSTRING_BEGIN; - } - case 214: break; - case 116: - { return( kNEW ); - } - case 215: break; - case 37: + case 253: break; + case 34: { yypushback(1); - yybegin(IN_TRIPLE_GSTRING); + yybegin(IN_SINGLE_GSTRING); } - case 216: break; - case 18: + case 254: break; + case 29: { yybegin(WAIT_FOR_REGEX); - return(mASSIGN); + return(mBXOR); } - case 217: break; - case 149: - { return( kNATIVE ); + case 255: break; + case 65: + { yypushback(1); + yybegin(IN_REGEX); } - case 218: break; - case 111: - { return( kFOR ); - } - case 219: break; - case 100: - { yybegin(WAIT_FOR_REGEX); - return(mBXOR_ASSIGN); - } - case 220: break; - case 133: - { return( kCHAR ); - } - case 221: break; - case 93: - { yybegin(WAIT_FOR_REGEX); - return(mOPTIONAL_DOT); - } - case 222: break; - case 25: - { yybegin(WAIT_FOR_REGEX); - return(mLT); - } - case 223: break; - case 147: - { return( kIMPORT ); - } - case 224: break; - case 158: - { return( kEXTENDS ); - } - case 225: break; + case 256: break; case 66: { yypushback(1); yybegin(afterComment); } - case 226: break; - case 156: - { return( kFINALLY ); + case 257: break; + case 5: + { if (zzStartRead == 0 || + zzBuffer.subSequence(0, zzStartRead).toString().trim().length() == 0) { + yypushback(1); + yybegin(WAIT_FOR_REGEX); + } else { + return(mDIV); + } } - case 227: break; - case 85: + case 258: break; + case 171: + { return( kSYNCHRONIZED ); + } + case 259: break; + case 121: { yybegin(WAIT_FOR_REGEX); - return(mPLUS_ASSIGN); + return(mSL_ASSIGN); } - case 228: break; - case 134: - { return( kVOID ); + case 260: break; + case 52: + { yybegin(KING_STATE); + return mREGEX_BEGIN; } - case 229: break; - case 152: - { return( kPUBLIC ); + case 261: break; + case 37: + { yypushback(1); + yybegin(IN_TRIPLE_GSTRING); } - case 230: break; - case 126: - { return( kELSE ); + case 262: break; + case 117: + { return( kTRY ); } - case 231: break; - case 14: - { return mSTRING_LITERAL; - } - case 232: break; - case 7: - { yybegin(WAIT_FOR_REGEX); - return(mLNOT); - } - case 233: break; + case 263: break; case 11: { yybegin(WAIT_FOR_REGEX); return(mMINUS); } - case 234: break; - case 67: - { yypushback(1); - yybegin(WAIT_FOR_REGEX); - } - case 235: break; - case 31: - { yybegin(WAIT_FOR_REGEX); - return(mBAND); - } - case 236: break; - case 170: - { return( kIMPLEMENTS ); - } - case 237: break; - case 6: - { yybegin(WAIT_FOR_REGEX); - return(mSTAR); - } - case 238: break; + case 264: break; case 12: { yybegin(WAIT_FOR_REGEX); return(mDOT); } - case 239: break; - case 9: - { return mNUM_INT; + case 265: break; + case 132: + { return( kCASE ); } - case 240: break; - case 166: - { return( kINTERFACE ); + case 266: break; + case 105: + // lookahead expression with fixed base length + zzMarkedPos = zzStartRead + 1; + { yybegin(IN_SINGLE_IDENT); + return mDOT; } - case 241: break; + case 267: break; + case 80: + { return mNUM_DOUBLE; + } + case 268: break; + case 157: + { return( kDEFAULT ); + } + case 269: break; + case 119: + { yybegin(WAIT_FOR_REGEX); + return(mREGEX_MATCH); + } + case 270: break; + case 1: + { gStringStack.clear(); + yybegin(YYINITIAL); + return mWRONG_REGEX_LITERAL; + } + case 271: break; + case 167: + { return( kTRANSIENT ); + } + case 272: break; + case 55: + { yybegin(KING_STATE_CONTENT); + return mREGEX_CONTENT; + } + case 273: break; case 84: { yybegin(WAIT_FOR_REGEX); return(mINC); } - case 242: break; - case 161: - { return( kPACKAGE ); + case 274: break; + case 108: + { return GROOVY_DOC_COMMENT; } - case 243: break; + case 275: break; + case 3: + { yybegin(NLS_AFTER_NLS); + afterComment = WAIT_FOR_REGEX; + return !braceCount.isEmpty() && + mLPAREN == braceCount.peek() ? WHITE_SPACE : mNLS; + } + case 276: break; + case 61: + { yybegin(NLS_AFTER_NLS); + afterComment = YYINITIAL; + clearStacks(); + return mNLS; + } + case 277: break; + case 155: + { return( kSWITCH ); + } + case 278: break; case 59: { afterComment = YYINITIAL; - return(mWS); + return(WHITE_SPACE); } - case 244: break; - case 141: - { return( kTHROW ); + case 279: break; + case 91: + { return mGSTRING_LITERAL; } - case 245: break; + case 280: break; + case 21: + { yybegin(WAIT_FOR_REGEX); + braceCount.push(mLPAREN); + return(mLBRACK); + } + case 281: break; + case 46: + { yypushback(1); + yybegin(IN_TRIPLE_IDENT); + } + case 282: break; + case 137: + { return( kFLOAT ); + } + case 283: break; case 57: { if (!blockStack.isEmpty()) { IElementType br = blockStack.pop(); @@ -2141,148 +2348,176 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } return mRCURLY; } - case 246: break; - case 94: - { yybegin(WAIT_FOR_REGEX); - return(mELVIS); - } - case 247: break; - case 82: - { return( kIN ); - } - case 248: break; - case 87: - { yybegin(WAIT_FOR_REGEX); - return(mMINUS_ASSIGN); - } - case 249: break; - case 69: - { return mSL_COMMENT; - } - case 250: break; - case 38: - { yybegin(IN_TRIPLE_DOT); - return mIDENT; - } - case 251: break; - case 21: - { yybegin(WAIT_FOR_REGEX); - braceCount.push(mLPAREN); - return(mLBRACK); - } - case 252: break; - case 128: - { return( kBYTE ); - } - case 253: break; + case 284: break; case 135: { yybegin(WAIT_FOR_REGEX); return(mBSR_ASSIGN); } - case 254: break; - case 62: - { yybegin(IN_REGEX_DOT); + case 285: break; + case 81: + { return( kIF ); + } + case 286: break; + case 94: + { yybegin(WAIT_FOR_REGEX); + return(mELVIS); + } + case 287: break; + case 138: + { return( kFINAL ); + } + case 288: break; + case 35: + { yybegin(IN_SINGLE_DOT); return mIDENT; } - case 255: break; - case 3: - { yybegin(NLS_AFTER_NLS); - afterComment = WAIT_FOR_REGEX; - return !braceCount.isEmpty() && - mLPAREN == braceCount.peek() ? mWS : mNLS; + case 289: break; + case 98: + { yybegin(WAIT_FOR_REGEX); + return(mGE); } - case 256: break; - case 45: - { yybegin(IN_TRIPLE_GSTRING_DOLLAR); - return mDOLLAR; + case 290: break; + case 151: + { return( kTHROWS ); } - case 257: break; - case 58: - { yypushback(1); - if (blockStack.isEmpty()){ - yybegin(YYINITIAL); - } else { - yybegin(IN_INNER_BLOCK); - } + case 291: break; + case 78: + { return mNUM_FLOAT; } - case 258: break; - case 171: - { return( kSYNCHRONIZED ); - } - case 259: break; + case 292: break; case 114: { yybegin(WAIT_FOR_REGEX); return(mTRIPLE_DOT); } - case 260: break; - case 88: + case 293: break; + case 49: + { yypushback(yytext().length()); + gStringStack.push(mDIV); // For regexes + yybegin(IN_REGEX_DOLLAR); + } + case 294: break; + case 112: + { return( kINT ); + } + case 295: break; + case 164: + { return( kSTRICTFP ); + } + case 296: break; + case 68: + { yypushback(1); + yybegin(NLS_AFTER_COMMENT); + } + case 297: break; + case 162: + { return( kABSTRACT ); + } + case 298: break; + case 139: + { return( kFALSE ); + } + case 299: break; + case 92: + { return( kAS ); + } + case 300: break; + case 47: + { yybegin(NLS_AFTER_NLS); + afterComment = IN_TRIPLE_IDENT; + return mNLS; + } + case 301: break; + case 115: { yybegin(WAIT_FOR_REGEX); - return(mCLOSABLE_BLOCK_OP); + return(mRANGE_EXCLUSIVE); } - case 261: break; - case 90: + case 302: break; + case 163: + { return( kCONTINUE ); + } + case 303: break; + case 33: { yybegin(WAIT_FOR_REGEX); - return(mMEMBER_POINTER); + return(mAT); } - case 262: break; - case 1: - { gStringStack.clear(); - yybegin(YYINITIAL); - return mWRONG_REGEX_LITERAL; + case 304: break; + case 125: + { return( kLONG ); } - case 263: break; - case 117: - { return( kTRY ); + case 305: break; + case 79: + { return mNUM_LONG; } - case 264: break; + case 306: break; + case 140: + { return( kBREAK ); + } + case 307: break; + case 97: + { yybegin(WAIT_FOR_REGEX); + return(mLE); + } + case 308: break; + case 159: + { return( kBOOLEAN ); + } + case 309: break; + case 153: + { return( kASSERT ); + } + case 310: break; + case 107: + // lookahead expression with fixed base length + zzMarkedPos = zzStartRead + 1; + { yybegin(IN_REGEX_IDENT); + return mDOT; + } + case 311: break; + case 4: + { return WHITE_SPACE; + } + case 312: break; + case 131: + { return( kTHIS ); + } + case 313: break; + case 160: + { return( kPRIVATE ); + } + case 314: break; + case 45: + { yybegin(IN_TRIPLE_GSTRING_DOLLAR); + return mDOLLAR; + } + case 315: break; + case 145: + { return( kSHORT ); + } + case 316: break; case 22: { if (!braceCount.isEmpty() && mLPAREN == braceCount.peek()) { braceCount.pop(); } return(mRBRACK); } - case 265: break; - case 132: - { return( kCASE ); + case 317: break; + case 15: + { yybegin(NLS_AFTER_LBRACE); + braceCount.push(mLCURLY); + return(mLCURLY); } - case 266: break; - case 80: - { return mNUM_DOUBLE; + case 318: break; + case 165: + { return( kVOLATILE ); } - case 267: break; - case 157: - { return( kDEFAULT ); + case 319: break; + case 106: + // lookahead expression with fixed base length + zzMarkedPos = zzStartRead + 1; + { yybegin(IN_TRIPLE_NLS); + return mDOT; } - case 268: break; - case 123: - { if (!gStringStack.isEmpty()){ - gStringStack.pop(); - } - if (blockStack.isEmpty()){ - yybegin(YYINITIAL); - } else { - yybegin(IN_INNER_BLOCK); - } - return mGSTRING_END; - } - case 269: break; - case 167: - { return( kTRANSIENT ); - } - case 270: break; - case 108: - { return GROOVY_DOC_COMMENT; - } - case 271: break; - case 17: - { yybegin(WAIT_FOR_REGEX); - return(mQUESTION); - } - case 272: break; - case 155: - { return( kSWITCH ); - } - case 273: break; + case 320: break; case 16: { while (!braceCount.isEmpty() && mLCURLY != braceCount.peek()) { braceCount.pop(); @@ -2292,308 +2527,65 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } return(mRCURLY); } - case 274: break; - case 5: - { if (zzStartRead == 0 || - zzBuffer.subSequence(0, zzStartRead).toString().trim().length() == 0) { - yypushback(1); - yybegin(WAIT_FOR_REGEX); - } else { - return(mDIV); + case 321: break; + case 7: + { yybegin(WAIT_FOR_REGEX); + return(mLNOT); + } + case 322: break; + case 72: + { yybegin(WAIT_FOR_REGEX); + return(mSTAR_STAR); + } + case 323: break; + case 77: + { return mNUM_BIG_INT; + } + case 324: break; + case 64: + { if (!gStringStack.isEmpty()) { + gStringStack.pop(); } - } - case 275: break; - case 91: - { return mGSTRING_LITERAL; - } - case 276: break; - case 121: - { yybegin(WAIT_FOR_REGEX); - return(mSL_ASSIGN); - } - case 277: break; - case 137: - { return( kFLOAT ); - } - case 278: break; - case 46: - { yypushback(1); - yybegin(IN_TRIPLE_IDENT); - } - case 279: break; - case 35: - { yybegin(IN_SINGLE_DOT); - return mIDENT; - } - case 280: break; - case 120: - { yybegin(WAIT_FOR_REGEX); - return(mCOMPARE_TO); - } - case 281: break; - case 81: - { return( kIF ); - } - case 282: break; - case 138: - { return( kFINAL ); - } - case 283: break; - case 103: - { yybegin(WAIT_FOR_REGEX); - return(mBAND_ASSIGN); - } - case 284: break; - case 151: - { return( kTHROWS ); - } - case 285: break; - case 78: - { return mNUM_FLOAT; - } - case 286: break; - case 51: - { if (blockStack.isEmpty()){ + if (blockStack.isEmpty()){ yybegin(YYINITIAL); } else { yybegin(IN_INNER_BLOCK); } return mREGEX_END; } - case 287: break; - case 39: - { blockStack.push(mLBRACK); - braceCount.push(mLCURLY); - yybegin(NLS_AFTER_LBRACE); - return mLCURLY; - } - case 288: break; - case 56: - { blockStack.push(mLCURLY); - braceCount.push(mLCURLY); - yybegin(NLS_AFTER_LBRACE); - return(mLCURLY); - } - case 289: break; - case 112: - { return( kINT ); - } - case 290: break; - case 164: - { return( kSTRICTFP ); - } - case 291: break; - case 49: - { yypushback(yytext().length()); - gStringStack.push(mDIV); // For regexes - yybegin(IN_REGEX_DOLLAR); - } - case 292: break; - case 10: - { yybegin(WAIT_FOR_REGEX); - return(mPLUS); - } - case 293: break; - case 162: - { return( kABSTRACT ); - } - case 294: break; - case 139: - { return( kFALSE ); - } - case 295: break; - case 42: - { yybegin(IN_SINGLE_GSTRING_DOLLAR); - return mDOLLAR; - } - case 296: break; - case 27: - { yybegin(WAIT_FOR_REGEX); - return(mBNOT); - } - case 297: break; - case 13: - { yybegin(IN_SINGLE_GSTRING); - gStringStack.push(mLPAREN); - return mGSTRING_BEGIN; - } - case 298: break; - case 92: - { return( kAS ); - } - case 299: break; - case 74: - { yybegin(WAIT_FOR_REGEX); - return(mSTAR_ASSIGN); - } - case 300: break; - case 163: - { return( kCONTINUE ); - } - case 301: break; - case 41: - { clearStacks(); - yybegin(NLS_AFTER_NLS); - afterComment = YYINITIAL; - return mNLS; - } - case 302: break; - case 125: - { return( kLONG ); - } - case 303: break; - case 79: - { return mNUM_LONG; - } - case 304: break; - case 140: - { return( kBREAK ); - } - case 305: break; - case 159: - { return( kBOOLEAN ); - } - case 306: break; - case 153: - { return( kASSERT ); - } - case 307: break; - case 98: - { yybegin(WAIT_FOR_REGEX); - return(mGE); - } - case 308: break; - case 24: - { yybegin(WAIT_FOR_REGEX); - return(mCOMMA); - } - case 309: break; - case 95: - { yybegin(WAIT_FOR_REGEX); - return(mEQUAL); - } - case 310: break; - case 131: - { return( kTHIS ); - } - case 311: break; - case 61: - { yybegin(NLS_AFTER_NLS); - afterComment = YYINITIAL; - clearStacks(); - return mNLS; - } - case 312: break; - case 160: - { return( kPRIVATE ); - } - case 313: break; - case 19: - { yybegin(WAIT_FOR_REGEX); - braceCount.push(mLPAREN); - return(mLPAREN); - } - case 314: break; - case 106: - // lookahead expression with fixed base length - zzMarkedPos = zzStartRead + 1; - { yybegin(IN_TRIPLE_NLS); - return mDOT; - } - case 315: break; - case 53: - { yypushback(yytext().length()); - yybegin(KING_STATE_INNER_CONTENT); - } - case 316: break; - case 145: - { return( kSHORT ); - } - case 317: break; - case 86: - { yybegin(WAIT_FOR_REGEX); - return(mDEC); - } - case 318: break; - case 32: - { yybegin(WAIT_FOR_REGEX); - return(mSEMI); - } - case 319: break; - case 165: - { return( kVOLATILE ); - } - case 320: break; - case 15: - { yybegin(NLS_AFTER_LBRACE); - braceCount.push(mLCURLY); - return(mLCURLY); - } - case 321: break; - case 33: - { yybegin(WAIT_FOR_REGEX); - return(mAT); - } - case 322: break; - case 77: - { return mNUM_BIG_INT; - } - case 323: break; - case 115: - { yybegin(WAIT_FOR_REGEX); - return(mRANGE_EXCLUSIVE); - } - case 324: break; + case 325: break; case 142: { return( kCLASS ); } - case 325: break; - case 71: - { yybegin(WAIT_FOR_REGEX); - return(mDIV_ASSIGN); - } case 326: break; - case 136: - { if (blockStack.isEmpty()){ - yybegin(YYINITIAL); - } else { - yybegin(IN_INNER_BLOCK); - } - return(mDOLLAR_SLASHY_LITERAL); + case 85: + { yybegin(WAIT_FOR_REGEX); + return(mPLUS_ASSIGN); } case 327: break; - case 97: + case 31: { yybegin(WAIT_FOR_REGEX); - return(mLE); + return(mBAND); } case 328: break; - case 150: - { return( kRETURN ); + case 120: + { yybegin(WAIT_FOR_REGEX); + return(mCOMPARE_TO); } case 329: break; - case 23: + case 100: { yybegin(WAIT_FOR_REGEX); - return(mCOLON); + return(mBXOR_ASSIGN); } case 330: break; - case 107: - // lookahead expression with fixed base length - zzMarkedPos = zzStartRead + 1; - { yybegin(IN_REGEX_IDENT); - return mDOT; + case 150: + { return( kRETURN ); } case 331: break; case 50: { return mREGEX_BEGIN; } case 332: break; - case 20: - { if (!braceCount.isEmpty() && mLPAREN == braceCount.peek()) { - braceCount.pop(); - } - return(mRPAREN); - } - case 333: break; case 44: // general lookahead, find correct zzMarkedPos { int zzFState = 24; @@ -2617,28 +2609,37 @@ public class _GroovyLexer implements FlexLexer, GroovyTokenTypes { } { return mGSTRING_CONTENT; } - case 334: break; + case 333: break; case 40: { return mGSTRING_CONTENT; } + case 334: break; + case 109: + { yybegin(WAIT_FOR_REGEX); + return(mSTAR_STAR_ASSIGN); + } case 335: break; - case 104: - { yybegin(WAIT_FOR_REGEX); - return(mLAND); - } - case 336: break; - case 30: - { yybegin(WAIT_FOR_REGEX); - return(mBOR); - } - case 337: break; case 113: { return( kDEF ); } + case 336: break; + case 42: + { yybegin(IN_SINGLE_GSTRING_DOLLAR); + return mDOLLAR; + } + case 337: break; + case 41: + { clearStacks(); + yybegin(NLS_AFTER_NLS); + afterComment = YYINITIAL; + return mNLS; + } case 338: break; - case 29: - { yybegin(WAIT_FOR_REGEX); - return(mBXOR); + case 63: + { blockStack.push(mDIV); + braceCount.push(mLCURLY); + yybegin(NLS_AFTER_LBRACE); + return mLCURLY; } case 339: break; case 146: diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/groovy.flex b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/groovy.flex index 4dc771310edc..d78f687da266 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/groovy.flex +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/lexer/groovy.flex @@ -16,6 +16,7 @@ package org.jetbrains.plugins.groovy.lang.lexer; import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import java.util.*; import java.lang.reflect.Field; @@ -24,7 +25,7 @@ import org.jetbrains.annotations.NotNull; %% %class _GroovyLexer -%implements FlexLexer, GroovyTokenTypes +%implements FlexLexer, GroovyTokenTypes, TokenType %unicode %public @@ -59,8 +60,8 @@ import org.jetbrains.annotations.NotNull; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// mONE_NL = \r | \n | \r\n // NewLines -mWS = " " | \t | \f | \\ {mONE_NL} // Whitespaces -mNLS = {mONE_NL}({mONE_NL}|{mWS})* +WHITE_SPACE = " " | \t | \f | \\ {mONE_NL} // Whitespaces +mNLS = {mONE_NL}({mONE_NL}|{WHITE_SPACE})* //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////// Comments //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -235,21 +236,21 @@ mGSTRING_LITERAL = \"\" {mML_COMMENT} { return mML_COMMENT; } {mDOC_COMMENT} { return GROOVY_DOC_COMMENT; } - ({mNLS}|{mWS})+ { return mWS; } + ({mNLS}|{WHITE_SPACE})+ { return WHITE_SPACE; } [^] { yypushback(1); yybegin(afterComment); } } { - ({mNLS}|{mWS})+ { return mWS; } + ({mNLS}|{WHITE_SPACE})+ { return WHITE_SPACE; } [^] { yypushback(1); yybegin(WAIT_FOR_REGEX); } } { - ({mNLS}|{mWS})+ { return mWS; } + ({mNLS}|{WHITE_SPACE})+ { return WHITE_SPACE; } [^] { yypushback(1); yybegin(NLS_AFTER_COMMENT); } @@ -549,8 +550,8 @@ mGSTRING_LITERAL = \"\" { -{mWS} { afterComment = YYINITIAL; - return(mWS); } +{WHITE_SPACE} { afterComment = YYINITIAL; + return(WHITE_SPACE); } {mSL_COMMENT} { return mSL_COMMENT; } {mML_COMMENT} { return mML_COMMENT; } @@ -653,11 +654,11 @@ mGSTRING_LITERAL = \"\" ///////////////////////// White spaces & NewLines ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{mWS} { return mWS; } +{WHITE_SPACE} { return WHITE_SPACE; } {mNLS} { yybegin(NLS_AFTER_NLS); afterComment = WAIT_FOR_REGEX; return !braceCount.isEmpty() && - mLPAREN == braceCount.peek() ? mWS : mNLS; } + mLPAREN == braceCount.peek() ? WHITE_SPACE : mNLS; } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////Comments ////////////////////////////////////////////////////////////////////////////////////// diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/parser/GroovyParserDefinition.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/parser/GroovyParserDefinition.java index 1cb5d2826796..c48439285e44 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/parser/GroovyParserDefinition.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/parser/GroovyParserDefinition.java @@ -36,9 +36,7 @@ import org.jetbrains.plugins.groovy.lang.lexer.TokenSets; import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyFileImpl; import org.jetbrains.plugins.groovy.lang.psi.stubs.elements.GrStubFileElementType; -import static com.intellij.lang.ParserDefinition.SpaceRequirements.MAY; -import static com.intellij.lang.ParserDefinition.SpaceRequirements.MUST; -import static com.intellij.lang.ParserDefinition.SpaceRequirements.MUST_LINE_BREAK; +import static com.intellij.lang.ParserDefinition.SpaceRequirements.*; import static org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes.*; /** @@ -85,7 +83,7 @@ public class GroovyParserDefinition implements ParserDefinition { } public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode left, ASTNode right) { - if (right.getElementType() == kIMPORT && left.getElementType() != mWS && left.getElementType() != TokenType.WHITE_SPACE) { + if (right.getElementType() == kIMPORT && left.getElementType() != TokenType.WHITE_SPACE) { return MUST_LINE_BREAK; } else if (left.getElementType() == MODIFIERS && right.getElementType() == MODIFIERS) {