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; }
private static boolean exitMode(@NotNull PsiBuilder builder_, @SuppressWarnings("UnusedParameters") int level, String mode, boolean safe) { TObjectIntHashMap<String> flags = getParsingModes(builder_); int count = flags.get(mode); if (count == 1) flags.remove(mode); else if (count > 1) flags.put(mode, count - 1); else if (!safe) builder_.error("Could not exit inactive '" + mode + "' mode at offset " + builder_.getCurrentOffset()); return true; }
/** * Wrapper for {@link PsiBuilder#error(String)} * * @param s * Error message */ public void error(String s) { myBuilder.error(s); }
@Override public void error(String message) { builder.error(message); } }
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 void error(PsiBuilder builder, @PropertyKey(resourceBundle = BUNDLE) String message) { builder.error(BashStrings.message(message)); }
private boolean rule(PsiBuilder builder, int level, BnfRule rule, Map<String, Parser> externalArguments) { BitSet bitSet = myBitSets[builder.getCurrentOffset()]; int ruleNumber = myRuleNumbers.get(rule); if (bitSet.get(ruleNumber)) { builder.error("Endless recursion detected for '" + rule.getName() + "'"); return false; } bitSet.set(ruleNumber); boolean result = expression(builder, level, rule, rule.getExpression(), rule.getName(), externalArguments); bitSet.clear(ruleNumber); return result; }
/** * Overridden method which only reports errors if error reporting is switched on. * * @param message The message to report. */ public void error(String message) { if (isErrorReportingEnabled()) { myDelegate.error(message); } else if (log.isDebugEnabled()) { log.debug("Supressed psi error: " + message); } }
public static void registerHook(PsiBuilder builder, String name, String value) { final GeneratedParserUtilBase.Hook hookObj = getHook(name); if (hookObj == null) return; Object hookParam = ObjectUtils.notNull(getHookParam(value), value); GeneratedParserUtilBase.register_hook_(builder, (builder1, marker, param) -> { try { return hookObj.run(builder1, marker, param); } catch (Exception e) { builder1.error("hook crashed: " + e.toString()); return marker; } }, hookParam); }
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; }
public void advanceLexer() throws CriticalParserError { if (myBuilder.eof()) { myBuilder.error("More input expected"); throw new CriticalParserError("Unexpected end of input."); } myImportantLinebreakHandler.reset(); myBuilder.advanceLexer(); }
private void error(final String message) { if (suppressMessages == 0) { ++errorCount; // auto column = index < tokens.length ? tokens[index].column : tokens[$ - 1].column; // auto line = index < tokens.length ? tokens[index].line : tokens[$ - 1].line; // if (messageFunction == null) // stderr.writefln("%s(%d:%d)[error]: %s", fileName, line, column, message); // else // messageFunction(fileName, line, column, message, true); builder.error(message); } else ++suppressedErrorCount; while (moreTokens()) { if (currentIsOneOf(tok(";"), tok("}"), tok(")"), tok("]"))) { advance(); break; } else advance(); } }
Result expr = parseExpression(); if (!expr.isParsed()) { builder.error("The last expression could not be parsed correctly."); builder.advanceLexer();