public ASTNode parse(IElementType t, PsiBuilder b) { parseLight(t, b); return b.getTreeBuilt(); }
public static boolean consumeBlock(PsiBuilder builder_, @SuppressWarnings("UnusedParameters") int level) { PsiFile file = builder_.getUserDataUnprotected(FileContextUtil.CONTAINING_FILE_KEY); VirtualFile data = file != null ? file.getUserData(IndexingDataKeys.VIRTUAL_FILE) : null; if (data == null) return false; int i = 0; PsiBuilder.Marker m = builder_.mark(); do { IElementType type = builder_.getTokenType(); if (type == GoTypes.TYPE_ && nextIdentifier(builder_)) { // don't count a.(type), only type <ident> m.rollbackTo(); return false; } i += type == GoTypes.LBRACE ? 1 : type == GoTypes.RBRACE ? -1 : 0; builder_.advanceLexer(); } while (i > 0 && !builder_.eof()); boolean result = i == 0; if (result) { m.drop(); } else { m.rollbackTo(); } return result; }
public boolean prefixMatches(@NotNull PsiBuilder builder, @NotNull String text) { int builderOffset = builder.getCurrentOffset(); int diff = offset - builderOffset; int length = text.length(); CharSequence fragment = builder.getOriginalText().subSequence(builderOffset, offset); return prefixMatches(fragment.toString(), text); IElementType type = builder.rawLookup(i); int tokenStart = builder.rawTokenTypeStart(i); if (isWhitespaceOrComment(builder, type)) { diff = offset - tokenStart; CharSequence fragment = builder.getOriginalText().subSequence(tokenStart, offset); if (prefixMatches(fragment.toString(), text)) { diff = offset - tokenStart;
@Override public boolean parse(PsiBuilder builder, int level) { if (builder.eof()) return false; builder.advanceLexer(); return true; } };
public static boolean empty_element_parsed_guard_(PsiBuilder builder, String funcName, int pos) { if (pos == current_position_(builder)) { // sometimes this is a correct situation, therefore no explicit marker builder.error("Empty element parsed in '" + funcName + "' at offset " + builder.getCurrentOffset()); return false; } return true; }
public static boolean isNotAResourceDefinition(PsiBuilder builder, int level) { if (builder.getTokenType() != BallerinaTypes.IDENTIFIER) { return false; } IElementType next1Element = builder.lookAhead(1); if (next1Element != null && next1Element.toString().equals("(")) { return true; } return false; }
if (!(force || notEmpty || advance)) return false; String actual = "'" + first(notNullize(builder.getTokenText(), "null"), MAX_ERROR_TOKEN_TEXT, true) + "'"; String message = expectedText + (builder.eof() ? "unexpected end of file" : notEmpty ? "got " + actual : actual + " unexpected"); if (advance) { PsiBuilder.Marker mark = builder.mark(); builder.advanceLexer(); mark.error(message); PsiBuilder.Marker extensionMarker = null; IElementType extensionTokenType = null; PsiBuilderImpl.ProductionMarker latestDoneMarker = elementType == null ? null : (PsiBuilderImpl.ProductionMarker)builder.getLatestDoneMarker(); if (latestDoneMarker != null && frame.position >= latestDoneMarker.getStartIndex() && ((PsiBuilder.Marker)latestDoneMarker).drop(); builder.error(message); if (extensionMarker != null) extensionMarker.done(extensionTokenType); builder.error(message); builder.eof(); // skip whitespaces frame.errorReportedAt = builder.rawTokenIndex(); return true;
public static boolean checkAndConvert(PsiBuilder b, int l, IElementType sourceType, IElementType targetType) { if (b.getTokenType() == sourceType) { PsiBuilder.Marker m = b.mark(); b.advanceLexer(); m.collapse(POD_INDENT_LEVEL); return true; } return false; }
@Override public ASTNode parse(@NotNull IElementType root, @NotNull PsiBuilder builder) { builder.setWhitespaceSkippedCallback(myImportantLinebreakHandler); Marker rootMarker = builder.mark(); this.myBuilder = builder; try { while (!builder.eof()) { Result expr = parseExpression(); if (!expr.isParsed()) { builder.error("The last expression could not be parsed correctly."); builder.advanceLexer(); } catch (CriticalParserError criticalParserError) { rootMarker.rollbackTo(); Marker newRoot = builder.mark(); final Marker errorMark = builder.mark(); while (!builder.eof()) { builder.advanceLexer(); return builder.getTreeBuilt();
if (checkParens) { int tokenIdx = -1; while (builder.rawLookup(tokenIdx) == TokenType.WHITE_SPACE) tokenIdx --; LighterASTNode doneMarker = builder.rawLookup(tokenIdx) == state.braces[0].getLeftBraceType() ? builder.getLatestDoneMarker() : null; if (doneMarker != null && doneMarker.getStartOffset() == builder.rawTokenTypeStart(tokenIdx) && doneMarker.getTokenType() == TokenType.ERROR_ELEMENT) { parenList.add(Pair.create(((PsiBuilder.Marker)doneMarker).precede(), (PsiBuilder.Marker)null)); final IElementType tokenType = builder.getTokenType(); if (checkParens && (tokenType == state.braces[0].getLeftBraceType() || tokenType == state.braces[0].getRightBraceType() && !parenList.isEmpty())) { if (marker != null) { parenList.addFirst(Pair.create(builder.mark(), prev == null ? null : prev.first)); builder.advanceLexer(); if (tokenType == state.braces[0].getRightBraceType()) { final Pair<PsiBuilder.Marker, PsiBuilder.Marker> pair = parenList.removeFirst(); marker = builder.mark(); marker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, null);
@Override public Token nextToken() { TokenIElementType ideaTType = (TokenIElementType)builder.getTokenType(); int type; if ( ideaTType==null ) { type = Token.EOF; } else { type = ideaTType.getType(); } int channel = Token.DEFAULT_CHANNEL; Pair<TokenSource, CharStream> source = new Pair<TokenSource, CharStream>(this, null); String text = builder.getTokenText(); int start = builder.getCurrentOffset(); int length = text != null ? text.length() : 0; int stop = start + length - 1; // PsiBuilder doesn't provide line, column info int line = 0; int charPositionInLine = 0; Token t = factory.create(source, type, text, channel, start, stop, line, charPositionInLine); builder.advanceLexer(); // System.out.println("TOKEN: "+t); return t; }
boolean pinned, @Nullable Parser eatMore) { int initialPos = builder.rawTokenIndex(); boolean willFail = !result && !pinned; replace_variants_with_name_(state, frame, builder, result, pinned); if (!state.suppressErrors && eatMore != null) { state.suppressErrors = true; final boolean eatMoreFlagOnce = !builder.eof() && eatMore.parse(builder, frame.level + 1); boolean eatMoreFlag = eatMoreFlagOnce || !result && frame.position == initialPos && lastErrorPos > frame.position; eatMoreFlagOnce ? (PsiBuilderImpl.ProductionMarker)builder.getLatestDoneMarker() : null; PsiBuilder.Marker extensionMarker = null; IElementType extensionTokenType = null; while ((eatMoreFlag || parenCount > 0) && builder.rawTokenIndex() < lastErrorPos) { IElementType tokenType = builder.getTokenType(); if (state.braces != null) { if (tokenType == state.braces[0].getLeftBraceType()) parenCount ++; else if (tokenType == state.braces[0].getRightBraceType()) parenCount --; if (!(builder.rawTokenIndex() < lastErrorPos)) break; builder.advanceLexer(); eatMoreFlag = eatMore.parse(builder, frame.level + 1); if (errorReported) { if (eatMoreFlag) { builder.advanceLexer(); parseAsTree(state, builder, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
public static boolean smartRemapAndAdvance(PsiBuilder builder, String expectedTokenText, IElementType expectedTokenType, IElementType newTokenType) { IElementType current = builder.getTokenType(); if (current == newTokenType) { // already remapped, probably due to reverting an earlier parse result builder.advanceLexer(); } else if (expectedTokenText.equals(builder.getTokenText()) && current == expectedTokenType) { builder.remapCurrentToken(newTokenType); builder.advanceLexer(); } else { builder.error("unexpected token"); return false; } return true; }
/** Convert ANTLR parse tree to PSI tree. */ protected void walkParseTree(ParseTree parseTree, AstBuilderListener listener, IElementType root, PsiBuilder builder) { PsiBuilder.Marker rootMarker = builder.mark(); ParseTreeWalker.DEFAULT.walk(listener, parseTree); while (!builder.eof()) { builder.advanceLexer(); } rootMarker.done(root); } }
/** * Encloses the current token in a marker (the marker token is the 2nd parameter). * * @param builder Provides the tokens. * @param markAs The type for the marker */ public static void markTokenAndAdvance(PsiBuilder builder, IElementType markAs) { final PsiBuilder.Marker marker = builder.mark(); builder.advanceLexer(); marker.done(markAs); }
public static boolean parseLabelDeclaration(PsiBuilder b, @SuppressWarnings("unused") int l) { if (b.lookAhead(1) == COLON && b.getTokenType() != RESERVED_SUB) { String tokenText = b.getTokenText(); if (tokenText != null && IDENTIFIER_PATTERN.matcher(tokenText).matches()) { b.advanceLexer(); b.advanceLexer(); return true; } } return false; }
/** * Parses use parameters with package processor if it's possible. If not, uses default parsing logic. */ public static boolean parseUseParameters(@NotNull PsiBuilder b, int l, @NotNull Parser defaultParser) { if (b.getTokenType() == PACKAGE) { String packageName = b.getTokenText(); if (StringUtil.isEmpty(packageName)) { return false; } PerlPackageProcessor packageProcessor = PerlPackageProcessorEP.EP.findSingle(packageName); if (packageProcessor != null) { assert b instanceof PerlBuilder; PsiBuilder.Marker m = b.mark(); if (packageProcessor.parseUseParameters((PerlBuilder)b, l)) { m.drop(); return true; } m.rollbackTo(); } } return defaultParser.parse(b, l); }
public static boolean recursion_guard_(PsiBuilder builder, int level, String funcName) { if (level > MAX_RECURSION_LEVEL) { builder.mark().error("Maximum recursion level (" + MAX_RECURSION_LEVEL + ") reached in '" + funcName + "'"); return false; } return true; }
public static boolean nextTokenIsFast(PsiBuilder builder, IElementType... tokens) { IElementType tokenType = builder.getTokenType(); for (IElementType token : tokens) { if (token == tokenType) return true; } return false; }
public void advanceLexer() throws CriticalParserError { if (myBuilder.eof()) { myBuilder.error("More input expected"); throw new CriticalParserError("Unexpected end of input."); } myImportantLinebreakHandler.reset(); myBuilder.advanceLexer(); }