protected static boolean wrapExpression(@NotNull IElementType elementType, @NotNull PerlBuilder b, int l) { PerlParserUtil.passPackageAndVersion(b, l); PsiBuilder.Marker m = b.mark(); if (PerlParserImpl.expr(b, l, -1)) { m.done(elementType); return true; } m.rollbackTo(); return false; } }
/** * Attempts to parse anon hash as call argument if comma is after it */ public static boolean parseHashSmart(@NotNull PsiBuilder b, int l) { if (b.getTokenType() != LEFT_BRACE) { return false; } PsiBuilder.Marker rollbackMarker = b.mark(); boolean r = PerlParserImpl.anon_hash(b, l) && b.getTokenType() == COMMA; rollbackMarker.rollbackTo(); return r && PerlParserImpl.list_expr(b, l); } }
public final boolean isValid(BashPsiBuilder builder) { PsiBuilder.Marker start = builder.mark(); // if accepted, read in command local var defs if (acceptFrontVarDef && CommandParsingUtil.isAssignmentOrRedirect(builder, CommandParsingUtil.Mode.StrictAssignmentMode, acceptArrayVars)) { if (!CommandParsingUtil.readAssignmentsAndRedirects(builder, false, CommandParsingUtil.Mode.StrictAssignmentMode, acceptArrayVars)) { start.rollbackTo(); return false; } } String currentTokenText = builder.getTokenText(); start.rollbackTo(); return LanguageBuiltins.isInternalCommand(currentTokenText, builder.isBash4()) && commandName.equals(currentTokenText); }
@Override public boolean parseFileContents(PsiBuilder b, int l) { PsiBuilder.Marker m = b.mark(); if (super.parseFileContents(b, l)) { m.done(NAMESPACE_CONTENT); m.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER); PsiBuilder.Marker definitionMarker = m.precede(); definitionMarker.done(MASON_NAMESPACE_DEFINITION); definitionMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER); return true; } m.rollbackTo(); return false; }
public static boolean parseSwitchCondition(PerlBuilder b, int l) { PerlBuilder.Marker m = b.mark(); boolean r = PerlParserUtil.consumeToken(b, LEFT_PAREN); r = r && PerlParserImpl.scalar_expr(b, l); r = r && PerlParserUtil.consumeToken(b, RIGHT_PAREN); if (r) { m.done(SWITCH_CONDITION); } else { m.rollbackTo(); } return r; }
public void rollbackTo() { delegate.rollbackTo(); open = false; }
public static boolean strictID(PsiBuilder builder_, int level_) { final PsiBuilder.Marker marker_ = builder_.mark(); final boolean result_ = consumeToken(builder_, MonkeyTypes.IDENTIFIER); if (result_) { marker_.done(MonkeyTypes.ID); return true; } marker_.rollbackTo(); return false; } }
protected ParseTree parse(TParser parser, IElementType root, PsiBuilder builder) { PsiBuilder.Marker rollbackMarker = builder.mark(); try { return parseImpl(parser, root, builder); } finally { rollbackMarker.rollbackTo(); } }
private void goToBookmark(final Bookmark bookmark) { --suppressMessages; if (suppressMessages == 0) suppressedErrorCount = 0; index = bookmark.num; // assert !bookmark.dropped; bookmark.m.rollbackTo(); bookmark.dropped = true; }
private static boolean parseAnnotatedSimpleStatement(PerlBuilder b, int l, IElementType keywordToken, IElementType statementToken) { PerlBuilder.Marker m = b.mark(); if (PerlParserUtil.consumeToken(b, keywordToken)) { if (PerlParserImpl.expr(b, l, -1)) { PerlParserUtil.parseStatementModifier(b, l); m.done(statementToken); return true; } } m.rollbackTo(); return false; }
@Override public void rollbackTo() { original.rollbackTo(); psiBuilder.recycle(this); }
public boolean parse(BashPsiBuilder builder) { PsiBuilder.Marker marker = builder.mark(); boolean ok = ParserUtil.conditionalRead(builder, acceptedWords); if (ok && acceptedEqualTokens.contains(builder.getTokenType())) { marker.done(VAR_DEF_ELEMENT); builder.advanceLexer(); } else { marker.rollbackTo(); } return next.parse(builder); } }
private boolean isValidParentesisExpression(BashPsiBuilder builder) { PsiBuilder.Marker marker = builder.mark(); ArithmeticParsingFunction parenthesisParser = ArithmeticFactory.parenthesisParser(); boolean ok = parenthesisParser.isValid(builder) && parenthesisParser.parse(builder) && operators.contains(builder.getTokenType(checkWhitespace)); marker.rollbackTo(); return ok; }
public static boolean parseNamespaceContent(PsiBuilder b, int l) { PsiBuilder.Marker m = b.mark(); if (PerlParserGenerated.real_namespace_content(b, l)) { m.done(NAMESPACE_CONTENT); m.setCustomEdgeTokenBinders(GREEDY_LEFT_BINDER, NAMESPACE_RIGHT_BINDER); return true; } m.rollbackTo(); return false; }
public static boolean parseCaseCondition(PerlBuilder b, int l) { PerlBuilder.Marker m = b.mark(); boolean r = parseCaseConditionParenthesised(b, l); r = r || PerlParserImpl.normal_block(b, l); r = r || parseCaseConditionSimple(b, l); if (r) { m.done(CASE_CONDITION); } else { m.rollbackTo(); } return r; }
public static boolean parseTokens(PsiBuilder builder, boolean smart, int pin, IElementType... tokens) { PsiBuilder.Marker marker = builder.mark(); boolean result = consumeTokens(builder, smart, pin, tokens); if (!result) { marker.rollbackTo(); } else { marker.drop(); } return result; }
public boolean isPipelineCommand(BashPsiBuilder builder) { final PsiBuilder.Marker start = builder.mark(); boolean result = isPipelineCommandNoRollback(builder); start.rollbackTo(); return result; }
private static void close_marker_impl_(Frame frame, PsiBuilder.Marker marker, IElementType elementType, boolean result) { if (marker == null) return; if (result) { if (elementType != null) { marker.done(elementType); } else { marker.drop(); } } else { if (frame != null) { int position = ((PsiBuilderImpl.ProductionMarker)marker).getStartIndex(); if (frame.errorReportedAt > position && frame.parentFrame != null) { frame.errorReportedAt = frame.parentFrame.errorReportedAt; } } marker.rollbackTo(); } }
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 static boolean parseTokens(PsiBuilder builder, boolean smart, int pin, IElementType... tokens) { PsiBuilder.Marker marker = builder.mark(); boolean result = consumeTokens(builder, smart, pin, tokens); if (!result) { marker.rollbackTo(); } else { marker.drop(); } return result; }