private static void run_hooks_impl_(PsiBuilder builder, ErrorState state, @Nullable IElementType elementType) { if (state.hooks == null) return; PsiBuilder.Marker marker = elementType == null ? null : (PsiBuilder.Marker)builder.getLatestDoneMarker(); if (elementType != null && marker == null) { builder.mark().error("No expected done marker at offset " + builder.getCurrentOffset()); } while (state.hooks != null && state.hooks.level >= state.level) { if (state.hooks.level == state.level) { marker = ((Hook<Object>)state.hooks.hook).run(builder, marker, state.hooks.param); } state.hooks = state.hooks.next; } }
@Nullable private PsiBuilder.Marker error(@Nullable PsiBuilder.Marker marker, @NotNull @NonNls String errorMsg) { if (marker != null) { marker.error(I18N.msg(errorMsg)); } return null; }
private static void run_hooks_impl_(PsiBuilder builder, ErrorState state, @Nullable IElementType elementType) { if (state.hooks == null) return; PsiBuilder.Marker marker = elementType == null ? null : (PsiBuilder.Marker)builder.getLatestDoneMarker(); if (elementType != null && marker == null) { builder.mark().error("No expected done marker at offset " + builder.getCurrentOffset()); } while (state.hooks != null && state.hooks.level >= state.level) { if (state.hooks.level == state.level) { marker = ((Hook<Object>)state.hooks.hook).run(builder, marker, state.hooks.param); } state.hooks = state.hooks.next; } }
private static boolean parseHas(PerlBuilder b, int l) { if (b.getTokenType() != RESERVED_HAS) { return false; } PerlBuilder.Marker m = b.mark(); PerlParserUtil.consumeToken(b, RESERVED_HAS); PerlBuilder.Marker wrapperMarker = b.mark(); if (PerlParserImpl.list_expr(b, l + 1)) { wrapperMarker.done(MOOSE_ATTRIBUTE_WRAPPER); m.done(MOOSE_HAS_EXPR); return true; } wrapperMarker.drop(); m.error("Incomplete has expression"); return true; }
@Override public boolean parseTerm(PsiBuilder b, int l) { if (b.getTokenType() == MASON_SELF_POINTER) { PsiBuilder.Marker m = b.mark(); b.advanceLexer(); if (regular_nested_call(b, l)) { m.done(MASON_SIMPLE_DEREF_EXPR); } else { m.error("Error parsing filter expression"); } return true; } return super.parseTerm(b, l); }
public static boolean parsePodSectionContent(PsiBuilder b, int l, IElementType stopToken, IElementType targetToken, String errorMessage) { PsiBuilder.Marker m = b.mark(); while (!b.eof() && b.getTokenType() != stopToken) { // PsiBuilder.Marker runMarker = b.mark(); b.advanceLexer(); // runMarker.collapse(POD_IDENTIFIER); } m.done(targetToken); if (b.eof()) { b.mark().error(errorMessage); } return true; } }
@Override public Result parse(MathematicaParser parser) throws CriticalParserError { Marker getMark = parser.mark(); IElementType type = MathematicaElementTypes.GET_PREFIX; parser.advanceLexer(); if (parser.matchesToken(MathematicaElementTypes.STRINGIFIED_IDENTIFIER) || parser.matchesToken(MathematicaElementTypes.STRING_LITERAL_BEGIN)) { final Result result1 = parser.parseExpression(myPrecedence); getMark.done(type); return MathematicaParser.result(getMark, type, result1.isParsed()); } else { getMark.error(ParserBundle.message("Get.stringified.symbol.expected")); return MathematicaParser.result(getMark, type, false); } }
public void error(String message) { delegate.error(message); open = false; }
public static void error(PsiBuilder.Marker marker, @PropertyKey(resourceBundle = BUNDLE) String message) { marker.error(BashStrings.message(message)); }
@Override public void error(String message) { marker.error(message); node.markAsError(message); }
private void processBadTag(TagParser tagParser, String message) { PsiBuilder.Marker badMarker = tagParser.getTagMarker().precede(); badMarker.error(message); } }
public static boolean parseKeywordFallback(PsiBuilder b, int l) { if (TemplateToolkitSyntaxElements.KEYWORDS_OR_TEXT_OPERATORS_TOKENSET.contains(b.getTokenType())) { PsiBuilder.Marker m = b.mark(); b.advanceLexer(); m.error(TemplateToolkitBundle.message("tt2.error.keyword.in.identifier")); return true; } return false; }
public static void errorToken(PsiBuilder builder, @PropertyKey(resourceBundle = BUNDLE) String message) { PsiBuilder.Marker marker = builder.mark(); builder.advanceLexer(); marker.error(BashStrings.message(message)); }
private static void extend_marker_impl(PsiBuilder.Marker marker) { PsiBuilder.Marker precede = marker.precede(); IElementType elementType = ((LighterASTNode)marker).getTokenType(); if (elementType == TokenType.ERROR_ELEMENT) { precede.error(notNullize(PsiBuilderImpl.getErrorMessage((LighterASTNode)marker))); } else { precede.done(elementType); } marker.drop(); }
public static boolean recoverTo(PsiBuilder b, IElementType toElement, String errorMessage) { // recover bad code PsiBuilder.Marker errorMarker = b.mark(); while (!b.eof() && b.getTokenType() != toElement) { b.advanceLexer(); ; } errorMarker.error(errorMessage); return b.eof(); } }
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; }
@Override public void error(final String errorMessage) { if (psiBuilder.isErrorReportingEnabled()) { original.error(errorMessage); } else { drop(); if (log.isDebugEnabled()) { log.debug("Marker: suppressed error " + errorMessage); } } }
PsiBuilder.Marker mark = builder.mark(); builder.advanceLexer(); mark.error(message);
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; }
@Override public PsiBuilder.Marker run(PsiBuilder builder, PsiBuilder.Marker marker, String param) { PsiBuilderImpl.ProductionMarker m = (PsiBuilderImpl.ProductionMarker)marker; int start = m == null ? builder.getCurrentOffset() : m.getStartOffset(); int end = m == null ? start : m.getEndOffset(); String prefix = "[" + start + ", " + end + "]" + (m == null ? "" : " " + m.getTokenType()); builder.mark().error(prefix + ": " + param); return marker; } };