/* * SimpleName{,} */ private void parseFunctionLiteralShorthandParameterList() { PsiBuilder.Marker parameterList = mark(); while (!eof()) { PsiBuilder.Marker parameter = mark(); // int parameterNamePos = matchTokenStreamPredicate(new LastBefore(new // At(IDENTIFIER), new AtOffset(doubleArrowPos))); // createTruncatedBuilder(parameterNamePos).parseModifierList(MODIFIER_LIST, // false); if (at(COLON)) { error("Expecting parameter name"); } else { expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(ARROW)); } if (at(COLON)) { advance(); // COLON myJetParsing.parseTypeRef(TokenSet.create(ARROW, COMMA)); } parameter.done(VALUE_PARAMETER); if (at(ARROW)) { break; } else if (at(COMMA)) { advance(); // COMMA } else { error("Expecting '->' or ','"); break; } } parameterList.done(VALUE_PARAMETER_LIST); }
@Inject public XtendTokenSetProvider(final TokenTypeProvider tokenTypeProvider) { IElementType _iElementType = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_SL_COMMENT); TokenSet _create = TokenSet.create(_iElementType); this.slCommentTokens = _create; IElementType _iElementType_1 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT); IElementType _iElementType_2 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_START); IElementType _iElementType_3 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_END); IElementType _iElementType_4 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_INBETWEEN); IElementType _iElementType_5 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_COMMENT_RICH_TEXT_END); IElementType _iElementType_6 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_COMMENT_RICH_TEXT_INBETWEEN); TokenSet _create_1 = TokenSet.create( _iElementType_1, _iElementType_2, _iElementType_3, _iElementType_4, _iElementType_5, _iElementType_6); this.richStringLiteralTokens = _create_1; }
/** Created by Michal on 18.11.2015. */ public class VaadinDesignParserDefinition implements ParserDefinition { public static final TokenSet WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE); public static final TokenSet STRING_LITERALS = TokenSet.create(VDTypes.ATTR_VALUE); // public static final TokenSet COMMENTS = TokenSet.create(SimpleTypes.COMMENT); public static final IFileElementType FILE = new IFileElementType( Language.<VaadinDeclarativeLanguage>findInstance(VaadinDeclarativeLanguage.class)); @NotNull @Override public Lexer createLexer(Project project) { return new FlexAdapter(new VaadinDesignLexer(null)); } @Override public PsiParser createParser(Project project) { return new VaadinDesignParser(); } @Override public IFileElementType getFileNodeType() { return FILE; } @NotNull @Override public TokenSet getWhitespaceTokens() { return WHITE_SPACES; } @NotNull @Override public TokenSet getCommentTokens() { return TokenSet.EMPTY; } @NotNull @Override public TokenSet getStringLiteralElements() { return STRING_LITERALS; } @NotNull @Override public PsiElement createElement(ASTNode node) { return VDTypes.Factory.createElement(node); } @Override public PsiFile createFile(FileViewProvider viewProvider) { return new VaadinDesignFile(viewProvider); } @Override public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode left, ASTNode right) { return SpaceRequirements.MAY; } }
private boolean parseFunctionTypeDotParametersAndType() { PsiBuilder.Marker rollbackMarker = mark(); // True when it's confirmed that body of literal can't be simple expressions and we prefer to // parse // it to function params if possible. boolean preferParamsToExpressions = false; // Last dot before ARROW and RPAR, but also stop at top-level keywords and '{', '}' int lastDot = matchTokenStreamPredicate( new LastBefore( new At(DOT), new AtSet( TokenSet.orSet( TokenSet.create(ARROW, RPAR), TokenSet.orSet( TokenSet.create(LBRACE, RBRACE), TokenSet.andNot( KEYWORDS, TokenSet.create(CAPITALIZED_THIS_KEYWORD))))))); if (lastDot >= 0) { createTruncatedBuilder(lastDot).parseTypeRef(); if (at(DOT)) { advance(); // DOT preferParamsToExpressions = parseFunctionLiteralParametersAndType(); } } return preferParamsToExpressions ? rollbackOrDrop(rollbackMarker, ARROW, "An -> is expected", RBRACE) : rollbackOrDropAt(rollbackMarker, ARROW); }
/* * object * : "object" SimpleName? ":" delegationSpecifier{","}? classBody? * ; */ void parseObject(boolean named, boolean optionalBody) { assert _at(OBJECT_KEYWORD); advance(); // OBJECT_KEYWORD if (named) { PsiBuilder.Marker propertyDeclaration = mark(); if (!parseIdeTemplate()) { expect(IDENTIFIER, "Expecting object name", TokenSet.create(LBRACE)); } propertyDeclaration.done(OBJECT_DECLARATION_NAME); } else { if (at(IDENTIFIER)) { error("An object expression cannot bind a name"); } } if (optionalBody) { if (at(COLON)) { advance(); // COLON parseDelegationSpecifierList(); } if (at(LBRACE)) { parseClassBody(); } } else { if (at(LBRACE)) { parseClassBody(); } else { expect(COLON, "Expecting ':'", TokenSet.create(IDENTIFIER, PACKAGE_KEYWORD)); parseDelegationSpecifierList(); parseClassBody(); } } }
/** Created by IntelliJ IDEA. User: Jon S Akhtar Date: 4/3/11 Time: 12:27 AM */ public class MoonParsingLexerMergingAdapter extends MergingLexerAdapterBase implements MoonTokenTypes { static final TokenSet tokensToMerge = TokenSet.create(LONGSTRING_BEGIN, LONGSTRING, LONGSTRING_END, NL_BEFORE_LONGSTRING); static final TokenSet tokensToMerge2 = TokenSet.create(LONGCOMMENT_BEGIN, LONGCOMMENT, LONGCOMMENT_END, NL_BEFORE_LONGSTRING); static final TokenSet allMergables = TokenSet.orSet(tokensToMerge, tokensToMerge2); public MoonParsingLexerMergingAdapter(Lexer original) { super( original, new MergeFunction() { @Override public IElementType merge(IElementType type, Lexer originalLexer) { if (!allMergables.contains(type)) { return type; } TokenSet merging = tokensToMerge.contains(type) ? tokensToMerge : tokensToMerge2; while (true) { final IElementType tokenType = originalLexer.getTokenType(); if (!merging.contains(tokenType)) break; originalLexer.advance(); } return merging == tokensToMerge ? LONGSTRING : LONGCOMMENT; } }); } }
public class PerlParserDefinition implements ParserDefinition { public static final TokenSet WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE); public static final TokenSet COMMENT = TokenSet.create(PerlTypes.COMMENT); public static final TokenSet LITERAL = TokenSet.create(PerlTypes.LITERAL); public static final IFileElementType FILE = new IFileElementType(Language.<PerlLanguage>findInstance(PerlLanguage.class)); @NotNull @Override public Lexer createLexer(Project project) { return new FlexAdapter(new PerlLexer((Reader) null)); } @NotNull public TokenSet getWhitespaceTokens() { return WHITE_SPACES; } @NotNull public TokenSet getCommentTokens() { return COMMENT; } @NotNull public TokenSet getStringLiteralElements() { return LITERAL; } @NotNull public PsiParser createParser(final Project project) { return new PerlParser(); } @Override public IFileElementType getFileNodeType() { return FILE; } public PsiFile createFile(FileViewProvider viewProvider) { return new PerlFile(viewProvider); } public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode left, ASTNode right) { return SpaceRequirements.MAY; } @NotNull public PsiElement createElement(ASTNode node) { return PerlTypes.Factory.createElement(node); } }
/** @author Stepan Koltsov */ public class RustTokenTypes { static IElementType WHITE_SPACE = TokenType.WHITE_SPACE; static IElementType BAD_CHARACTER = TokenType.BAD_CHARACTER; static IElementType NUMBER = new RustElementType("number"); static IElementType END_OF_LINE_COMMENT = new RustElementType("END_OF_LINE_COMMENT"); static IElementType KEY_CHARACTERS = new RustElementType("KEY_CHARACTERS"); static IElementType VALUE_CHARACTERS = new RustElementType("VALUE_CHARACTERS"); static IElementType KEY_VALUE_SEPARATOR = new RustElementType("KEY_VALUE_SEPARATOR"); static TokenSet COMMENTS = TokenSet.create(END_OF_LINE_COMMENT); static TokenSet WHITESPACES = TokenSet.create(WHITE_SPACE); }
/* * for * : "for" "(" annotations ("val" | "var")? (multipleVariableDeclarations | variableDeclarationEntry) "in" expression ")" expression * ; * * TODO: empty loop body (at the end of the block)? */ private void parseFor() { assert _at(FOR_KEYWORD); PsiBuilder.Marker loop = mark(); advance(); // FOR_KEYWORD if (expect(LPAR, "Expecting '(' to open a loop range", EXPRESSION_FIRST)) { myBuilder.disableNewlines(); if (!at(RPAR)) { PsiBuilder.Marker parameter = mark(); if (!at(IN_KEYWORD)) { myJetParsing.parseModifierList(DEFAULT, TokenSet.create(IN_KEYWORD, RPAR, COLON)); } if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD if (at(LPAR)) { myJetParsing.parseMultiDeclarationName(TokenSet.create(IN_KEYWORD, LBRACE)); parameter.done(DESTRUCTURING_DECLARATION); } else { expect(IDENTIFIER, "Expecting a variable name", TokenSet.create(COLON, IN_KEYWORD)); if (at(COLON)) { advance(); // COLON myJetParsing.parseTypeRef(TokenSet.create(IN_KEYWORD)); } parameter.done(VALUE_PARAMETER); } if (expect(IN_KEYWORD, "Expecting 'in'", TokenSet.create(LPAR, LBRACE, RPAR))) { PsiBuilder.Marker range = mark(); parseExpression(); range.done(LOOP_RANGE); } } else { error("Expecting a variable name"); } expectNoAdvance(RPAR, "Expecting ')'"); myBuilder.restoreNewlinesState(); } parseControlStructureBody(); loop.done(FOR); }
/* * typeConstraint * : attributes SimpleName ":" type * : attributes "class" "object" SimpleName ":" type * ; */ private void parseTypeConstraint() { PsiBuilder.Marker constraint = mark(); parseAnnotations(false); if (at(CLASS_KEYWORD)) { advance(); // CLASS_KEYWORD expect(OBJECT_KEYWORD, "Expecting 'object'", TYPE_REF_FIRST); } PsiBuilder.Marker reference = mark(); if (expect( IDENTIFIER, "Expecting type parameter name", TokenSet.orSet(TokenSet.create(COLON, COMMA), TYPE_REF_FIRST))) { reference.done(REFERENCE_EXPRESSION); } else { reference.drop(); } expect(COLON, "Expecting ':' before the upper bound", TYPE_REF_FIRST); parseTypeRef(); constraint.done(TYPE_CONSTRAINT); }
static { // in regular case, these tokens should be created in extension class TOKENS_MAP.put("inner", RESERVED_INNER); TOKENS_MAP.put("with", RESERVED_WITH); TOKENS_MAP.put("extends", RESERVED_EXTENDS); TOKENS_MAP.put("meta", RESERVED_META); TOKENS_MAP.put("override", RESERVED_OVERRIDE); TOKENS_MAP.put("around", RESERVED_AROUND); TOKENS_MAP.put("super", RESERVED_SUPER); TOKENS_MAP.put("augment", RESERVED_AUGMENT); TOKENS_MAP.put("after", RESERVED_AFTER); TOKENS_MAP.put("before", RESERVED_BEFORE); TOKENS_MAP.put("has", RESERVED_HAS); RESERVED_TO_STATEMENT_MAP.put(RESERVED_INNER, MOOSE_STATEMENT_INNER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_WITH, MOOSE_STATEMENT_WITH); RESERVED_TO_STATEMENT_MAP.put(RESERVED_EXTENDS, MOOSE_STATEMENT_EXTENDS); RESERVED_TO_STATEMENT_MAP.put(RESERVED_META, MOOSE_STATEMENT_META); RESERVED_TO_STATEMENT_MAP.put(RESERVED_OVERRIDE, MOOSE_STATEMENT_OVERRIDE); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AROUND, MOOSE_STATEMENT_AROUND); RESERVED_TO_STATEMENT_MAP.put(RESERVED_SUPER, MOOSE_STATEMENT_SUPER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AUGMENT, MOOSE_STATEMENT_AUGMENT); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AFTER, MOOSE_STATEMENT_AFTER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_BEFORE, MOOSE_STATEMENT_BEFORE); RESERVED_TO_STATEMENT_MAP.put(RESERVED_HAS, MOOSE_STATEMENT_HAS); MOOSE_TOKEN_SET = TokenSet.create(TOKENS_MAP.values().toArray(new IElementType[TOKENS_MAP.values().size()])); }
public JetWordsScanner() { super( new JetLexer(), TokenSet.create(JetTokens.IDENTIFIER), JetTokens.COMMENTS, JetTokens.STRINGS); }
/** @author ilyas */ public interface LuaDocTokenTypes { IElementType LDOC_TAG_NAME = new LuaDocElementTypeImpl("LDOC_TAG_NAME"); IElementType LDOC_TAG_PLAIN_VALUE_TOKEN = new LuaDocElementTypeImpl("LDOC_TAG_VALUE_TOKEN"); IElementType LDOC_TAG_VALUE = new LuaDocTagValueTokenType(); IElementType LDOC_COMMENT_START = new LuaDocElementTypeImpl("LDOC_COMMENT_START"); IElementType LDOC_COMMENT_DATA = new LuaDocElementTypeImpl("LDOC_COMMENT_DATA"); IElementType LDOC_WHITESPACE = new LuaDocElementTypeImpl("LDOC_WHITESPACE"); IElementType LDOC_DASHES = new LuaDocElementTypeImpl("LDOC_DASHES"); IElementType LDOC_COMMENT_BAD_CHARACTER = TokenType.BAD_CHARACTER; TokenSet LUA_DOC_TOKENS = TokenSet.create( LDOC_COMMENT_START, LDOC_COMMENT_DATA, LDOC_WHITESPACE, LDOC_DASHES, LDOC_TAG_NAME, LDOC_TAG_VALUE, LDOC_TAG_PLAIN_VALUE_TOKEN, LDOC_COMMENT_BAD_CHARACTER); }
/* * whenEntry * // TODO : consider empty after -> * : whenCondition{","} "->" element SEMI * : "else" "->" element SEMI * ; */ private void parseWhenEntry() { PsiBuilder.Marker entry = mark(); if (at(ELSE_KEYWORD)) { advance(); // ELSE_KEYWORD if (!at(ARROW)) { errorUntil("Expecting '->'", TokenSet.create(ARROW, RBRACE, EOL_OR_SEMICOLON)); } if (at(ARROW)) { advance(); // ARROW if (atSet(WHEN_CONDITION_RECOVERY_SET)) { error("Expecting an element"); } else { parseExpressionPreferringBlocks(); } } else if (!atSet(WHEN_CONDITION_RECOVERY_SET)) { errorAndAdvance("Expecting '->'"); } } else { parseWhenEntryNotElse(); } entry.done(WHEN_ENTRY); consumeIf(SEMICOLON); }
/* * expressions * : SEMI* statement{SEMI+} SEMI* */ public void parseStatements() { while (at(SEMICOLON)) advance(); // SEMICOLON while (!eof() && !at(RBRACE)) { if (!atSet(STATEMENT_FIRST)) { errorAndAdvance("Expecting an element"); } if (atSet(STATEMENT_FIRST)) { parseStatement(); } if (at(SEMICOLON)) { while (at(SEMICOLON)) advance(); // SEMICOLON } else if (at(RBRACE)) { break; } else if (!myBuilder.newlineBeforeCurrentToken()) { String severalStatementsError = "Unexpected tokens (use ';' to separate expressions on the same line)"; if (atSet(STATEMENT_NEW_LINE_QUICK_RECOVERY_SET)) { error(severalStatementsError); } else { errorUntil(severalStatementsError, TokenSet.create(EOL_OR_SEMICOLON, LBRACE, RBRACE)); } } } }
/** User: jansorg Date: 21.05.2009 Time: 10:36:06 */ public class BashWordImpl extends BashPsiElementImpl implements BashWord { private static final TokenSet nonWrappableChilds = TokenSet.create(BashElementTypes.STRING_ELEMENT, BashTokenTypes.STRING2, BashTokenTypes.WORD); public BashWordImpl(final ASTNode astNode) { super(astNode, "bash combined word"); } @Override public void accept(@NotNull PsiElementVisitor visitor) { if (visitor instanceof BashVisitor) { ((BashVisitor) visitor).visitCombinedWord(this); } else { visitor.visitElement(this); } } public boolean isWrappable() { return findChildByType(nonWrappableChilds) == null; } public String getUnwrappedCharSequence() { return getText(); } public boolean isStatic() { return BashPsiUtils.isStaticWordExpr(getFirstChild()); } }
class GoBinaryExpressionBlock extends GoBlock { public enum Mode { Normal, Compact } private static final TokenSet EMPTY_SPACE_TOKENS = TokenSet.create(oMUL, oQUOTIENT, oREMAINDER, oSHIFT_LEFT, oSHIFT_RIGHT); private final Spacing spacing; public GoBinaryExpressionBlock( ASTNode node, Alignment alignment, Wrap wrap, CommonCodeStyleSettings settings) { super(node, alignment, Indent.getNormalIndent(), wrap, settings); GoBinaryExpression psi = node.getPsi(GoBinaryExpression.class); if (psi != null && EMPTY_SPACE_TOKENS.contains(psi.getOperator())) { spacing = EMPTY_SPACING_KEEP_LINE_BREAKS; } else { spacing = BASIC_SPACING_KEEP_LINE_BREAKS; } } @Override protected Spacing getGoBlockSpacing(GoBlock child1, GoBlock child2) { return isCommentBlock(child1) || isCommentBlock(child2) ? BASIC_SPACING_KEEP_LINE_BREAKS : spacing; } @Override protected Indent getChildIndent(@Nullable PsiElement child) { return null; } }
@NotNull public Count getCount() { final ASTNode[] nodes = getNode().getChildren(RegExpTokens.QUANTIFIERS); assert nodes.length > 0; final IElementType type = nodes[0].getElementType(); if (type == RegExpTokens.QUEST) { return SimpleCount.ONE_OR_ZERO; } else if (type == RegExpTokens.STAR) { return SimpleCount.ZERO_OR_MORE; } else if (type == RegExpTokens.PLUS) { return SimpleCount.ONE_OR_MORE; } else if (type == RegExpTokens.LBRACE) { final ASTNode[] numbers = getNode().getChildren(TokenSet.create(RegExpTokens.NUMBER)); if (numbers.length >= 1) { final String min = numbers[0].getText(); final String max; if (numbers.length == 2) { max = numbers[1].getText(); } else if (getNode().findChildByType(RegExpTokens.COMMA) != null) { max = ""; } else { max = min; } return new RepeatedCount(min, max); } // syntactically incorrect return new RepeatedCount("", ""); } assert false; return null; }
/* * initializer * : attributes "this" valueArguments * : attributes constructorInvocation // type parameters may (must?) be omitted * ; */ private void parseInitializer() { PsiBuilder.Marker initializer = mark(); parseAnnotations(false); IElementType type; if (at(THIS_KEYWORD)) { PsiBuilder.Marker mark = mark(); advance(); // THIS_KEYWORD mark.done(THIS_CONSTRUCTOR_REFERENCE); type = THIS_CALL; } else if (atSet(TYPE_REF_FIRST)) { PsiBuilder.Marker reference = mark(); parseTypeRef(); reference.done(CONSTRUCTOR_CALLEE); type = DELEGATOR_SUPER_CALL; } else { errorWithRecovery( "Expecting constructor call (this(...)) or supertype initializer", TokenSet.create(LBRACE, COMMA)); initializer.drop(); return; } myExpressionParsing.parseValueArgumentList(); initializer.done(type); }
@Override @NotNull public ASTNode getValOrVarNode() { ASTNode node = getNode().findChildByType(TokenSet.create(VAL_KEYWORD, VAR_KEYWORD)); assert node != null : "Val or var should always exist for property"; return node; }
/* * import * : "import" ("namespace" ".")? SimpleName{"."} ("." "*" | "as" SimpleName)? SEMI? * ; */ private void parseImportDirective() { assert _at(IMPORT_KEYWORD); PsiBuilder.Marker importDirective = mark(); advance(); // IMPORT_KEYWORD PsiBuilder.Marker qualifiedName = mark(); if (at(PACKAGE_KEYWORD)) { advance(); // PACKAGE_KEYWORD expect(DOT, "Expecting '.'", TokenSet.create(IDENTIFIER, MUL, SEMICOLON)); } PsiBuilder.Marker reference = mark(); expect(IDENTIFIER, "Expecting qualified name"); reference.done(REFERENCE_EXPRESSION); while (at(DOT) && lookahead(1) != MUL) { advance(); // DOT reference = mark(); if (expect( IDENTIFIER, "Qualified name must be a '.'-separated identifier list", IMPORT_RECOVERY_SET)) { reference.done(REFERENCE_EXPRESSION); } else { reference.drop(); } PsiBuilder.Marker precede = qualifiedName.precede(); qualifiedName.done(DOT_QUALIFIED_EXPRESSION); qualifiedName = precede; } qualifiedName.drop(); if (at(DOT)) { advance(); // DOT assert _at(MUL); advance(); // MUL handleUselessRename(); } if (at(AS_KEYWORD)) { advance(); // AS_KEYWORD expect(IDENTIFIER, "Expecting identifier", TokenSet.create(SEMICOLON)); } consumeIf(SEMICOLON); importDirective.done(IMPORT_DIRECTIVE); }
static { Set<IElementType> operations = new HashSet<IElementType>(); Precedence[] values = Precedence.values(); for (Precedence precedence : values) { operations.addAll(Arrays.asList(precedence.getOperations().getTypes())); } ALL_OPERATIONS = TokenSet.create(operations.toArray(new IElementType[operations.size()])); }
/** * "(" (modifiers SimpleName (":" type)?){","} ")" * * @return true if at least one comma was found */ private boolean parseFunctionLiteralParameterList() { PsiBuilder.Marker list = mark(); expect(LPAR, "Expecting a parameter list in parentheses (...)", TokenSet.create(ARROW, COLON)); boolean hasComma = false; myBuilder.disableNewlines(); if (!at(RPAR)) { while (true) { if (at(COMMA)) errorAndAdvance("Expecting a parameter declaration"); PsiBuilder.Marker parameter = mark(); int parameterNamePos = matchTokenStreamPredicate( new LastBefore( new At(IDENTIFIER), new AtSet(COMMA, RPAR, COLON, ARROW, RBRACE, LBRACE))); createTruncatedBuilder(parameterNamePos) .parseModifierList(MODIFIER_LIST, REGULAR_ANNOTATIONS_ONLY_WITH_BRACKETS); expect(IDENTIFIER, "Expecting parameter declaration"); if (at(COLON)) { advance(); // COLON myJetParsing.parseTypeRef(); } parameter.done(VALUE_PARAMETER); if (!at(COMMA)) break; advance(); // COMMA hasComma = true; if (at(RPAR)) { error("Expecting a parameter declaration"); break; } } } myBuilder.restoreNewlinesState(); expect(RPAR, "Expecting ')'", TokenSet.create(ARROW, COLON)); list.done(VALUE_PARAMETER_LIST); return hasComma; }
public final class XPath2ElementTypes { public static final IFileElementType FILE = new IFileElementType("XPATH2_FILE", XPathFileType.XPATH2.getLanguage()); public static final IElementType SEQUENCE = new XPath2ElementType("SEQUENCE"); public static final IElementType RANGE_EXPRESSION = new XPath2ElementType("RANGE_EXPRESSION"); public static final IElementType IF = new XPath2ElementType("IF"); public static final IElementType FOR = new XPath2ElementType("FOR"); public static final IElementType BODY = new XPath2ElementType("RETURN"); public static final IElementType QUANTIFIED = new XPath2ElementType("QUANTIFIED"); public static final IElementType INSTANCE_OF = new XPath2ElementType("INSTANCE_OF"); public static final IElementType TREAT_AS = new XPath2ElementType("TREAT_AS"); public static final IElementType CASTABLE_AS = new XPath2ElementType("CASTABLE_AS"); public static final IElementType CAST_AS = new XPath2ElementType("CAST_AS"); public static final IElementType BINDING_SEQ = new XPath2ElementType("BINDING_SEQ"); public static final IElementType VARIABLE_DECL = new XPath2ElementType("VARIABLE_DECL"); public static final IElementType CONTEXT_ITEM = new XPath2ElementType("CONTEXT_ITEM"); public static final IElementType SEQUENCE_TYPE = new XPath2ElementType("SEQUENCE_TYPE"); public static final IElementType SINGLE_TYPE = new XPath2ElementType("SINGLE_TYPE"); public static final IElementType ITEM_OR_EMPTY_SEQUENCE = new XPath2ElementType("ITEM_OR_EMPTY_SEQUENCE"); public static final TokenSet TYPE_ELEMENTS = TokenSet.create(SEQUENCE_TYPE, SINGLE_TYPE); public static final TokenSet EXPRESSIONS = TokenSet.orSet( XPathElementTypes.EXPRESSIONS, TokenSet.create( XPathElementTypes.NODE_TYPE, SEQUENCE, CONTEXT_ITEM, IF, FOR, RANGE_EXPRESSION, QUANTIFIED, INSTANCE_OF, TREAT_AS, CASTABLE_AS, CAST_AS)); private XPath2ElementTypes() {} }
@Singleton public class PureXbaseTokenTypeProvider implements TokenTypeProvider { private static final String[] TOKEN_NAMES = new PsiInternalPureXbaseParser(null).getTokenNames(); private static final IElementType[] tokenTypes = new IElementType[TOKEN_NAMES.length]; static { for (int i = 0; i < TOKEN_NAMES.length; i++) { tokenTypes[i] = new IndexedElementType(TOKEN_NAMES[i], i, PureXbaseLanguage.INSTANCE); } } private static final TokenSet WHITESPACE_TOKENS = TokenSet.create(tokenTypes[RULE_WS]); private static final TokenSet COMMENT_TOKENS = TokenSet.create(tokenTypes[RULE_SL_COMMENT], tokenTypes[RULE_ML_COMMENT]); private static final TokenSet STRING_TOKENS = TokenSet.create(tokenTypes[RULE_STRING]); @Override public int getAntlrType(IElementType iElementType) { return (iElementType instanceof IndexedElementType) ? ((IndexedElementType) iElementType).getLocalIndex() : org.antlr.runtime.Token.INVALID_TOKEN_TYPE; } @Override public IElementType getIElementType(int antlrType) { return tokenTypes[antlrType]; } @Override public TokenSet getWhitespaceTokens() { return WHITESPACE_TOKENS; } @Override public TokenSet getCommentTokens() { return COMMENT_TOKENS; } @Override public TokenSet getStringLiteralTokens() { return STRING_TOKENS; } }
private boolean parseValueParameter(boolean rollbackOnFailure) { PsiBuilder.Marker parameter = mark(); parseModifierListWithShortAnnotations( MODIFIER_LIST, TokenSet.create(IDENTIFIER), TokenSet.create(COMMA, RPAR, COLON)); if (at(VAR_KEYWORD) || at(VAL_KEYWORD)) { advance(); // VAR_KEYWORD | VAL_KEYWORD } if (!parseFunctionParameterRest() && rollbackOnFailure) { parameter.rollbackTo(); return false; } parameter.done(VALUE_PARAMETER); return true; }
@Override public void setUp() throws Exception { super.setUp(); lexer = new LayeredLexer( new LatteTopLexer(), dummyLexer = new MyDummyLexer(), TokenSet.create(LatteTokenTypes.PARAMS, LatteTokenTypes.N_ATTR_VALUE)); }
/** @author fernandohur */ public class EamlParserDefinition implements ParserDefinition { public static final TokenSet WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE); public static final IFileElementType FILE = new IFileElementType(Language.<EamlLanguage>findInstance(EamlLanguage.class)); @NotNull @Override public Lexer createLexer(final Project project) { return new EamlLexerAdapter(); } @NotNull @Override public TokenSet getWhitespaceTokens() { return WHITE_SPACES; } @NotNull @Override public TokenSet getCommentTokens() { return TokenSet.EMPTY; } @NotNull @Override public TokenSet getStringLiteralElements() { return TokenSet.EMPTY; } @Override public PsiParser createParser(final Project project) { return new EamlParser(); } @Override public IFileElementType getFileNodeType() { return FILE; } @Override public PsiFile createFile(final FileViewProvider fileViewProvider) { return new EamlFile(fileViewProvider); } @Override public SpaceRequirements spaceExistanceTypeBetweenTokens( final ASTNode astNode, final ASTNode astNode1) { return SpaceRequirements.MAY; } @NotNull @Override public PsiElement createElement(final ASTNode astNode) { return EamlTypes.Factory.createElement(astNode); } }
/** Created by Anastasia Izmaylova on 12/10/15. */ public class IGGYFindUsesProvider implements FindUsagesProvider { WordsScanner scanner = new DefaultWordsScanner( new IGGYLexer(), TokenSet.create(IGGYTokenTypes.TERMINAL), TokenSet.create(IGGYTokenTypes.COMMENT), TokenSet.EMPTY); @Nullable @Override public WordsScanner getWordsScanner() { return scanner; } @Override public boolean canFindUsagesFor(PsiElement psiElement) { return psiElement instanceof NontName$DeclarationImpl; } @Nullable @Override public String getHelpId(PsiElement psiElement) { return null; } @NotNull @Override public String getType(PsiElement element) { return "Nonterminal name"; } @NotNull @Override public String getDescriptiveName(@NotNull PsiElement element) { return element.getText(); } @NotNull @Override public String getNodeText(@NotNull PsiElement element, boolean useFullName) { return element.getText(); } }
/* * try * : "try" block catchBlock* finallyBlock? * ; * catchBlock * : "catch" "(" annotations SimpleName ":" userType ")" block * ; * * finallyBlock * : "finally" block * ; */ private void parseTry() { assert _at(TRY_KEYWORD); PsiBuilder.Marker tryExpression = mark(); advance(); // TRY_KEYWORD myJetParsing.parseBlock(); boolean catchOrFinally = false; while (at(CATCH_KEYWORD)) { catchOrFinally = true; PsiBuilder.Marker catchBlock = mark(); advance(); // CATCH_KEYWORD TokenSet recoverySet = TokenSet.create(LBRACE, FINALLY_KEYWORD, CATCH_KEYWORD); if (atSet(recoverySet)) { error("Expecting exception variable declaration"); } else { PsiBuilder.Marker parameters = mark(); expect(LPAR, "Expecting '('", recoverySet); if (!atSet(recoverySet)) { myJetParsing.parseValueParameter(/*typeRequired = */ true); expect(RPAR, "Expecting ')'", recoverySet); } else { error("Expecting exception variable declaration"); } parameters.done(VALUE_PARAMETER_LIST); } if (at(LBRACE)) { myJetParsing.parseBlock(); } else { error("Expecting a block: { ... }"); } catchBlock.done(CATCH); } if (at(FINALLY_KEYWORD)) { catchOrFinally = true; PsiBuilder.Marker finallyBlock = mark(); advance(); // FINALLY_KEYWORD myJetParsing.parseBlock(); finallyBlock.done(FINALLY); } if (!catchOrFinally) { error("Expecting 'catch' or 'finally'"); } tryExpression.done(TRY); }