public void parse(PsiBuilder builder) {
final PsiBuilder.Marker root = builder.mark();
PsiBuilder.Marker error = null;
while (!builder.eof()) {
final String token = builder.getTokenText();
if ("?".equals(token)) error = builder.mark();
builder.advanceLexer();
if (error != null) {
error.error("test error 2");
error = null;
}
}
root.done(this);
}
private static boolean reportError(
PsiBuilder builder,
ErrorState state,
Frame frame,
IElementType elementType,
boolean force,
boolean advance) {
String expectedText = state.getExpectedText(builder);
boolean notEmpty = StringUtil.isNotEmpty(expectedText);
if (force || notEmpty || advance) {
String gotText =
builder.eof()
? "unexpected end of file"
: notEmpty
? "got '" + builder.getTokenText() + "'"
: "'" + builder.getTokenText() + "' unexpected";
String message = expectedText + gotText;
if (advance) {
PsiBuilder.Marker mark = builder.mark();
builder.advanceLexer();
mark.error(message);
} else if (!force) {
PsiBuilder.Marker extensionMarker = null;
IElementType extensionTokenType = null;
PsiBuilderImpl.ProductionMarker latestDoneMarker =
elementType == null
? null
: (PsiBuilderImpl.ProductionMarker) builder.getLatestDoneMarker();
if (latestDoneMarker != null
&& frame.position >= latestDoneMarker.getStartIndex()
&& frame.position <= latestDoneMarker.getEndIndex()) {
extensionMarker = ((PsiBuilder.Marker) latestDoneMarker).precede();
extensionTokenType = latestDoneMarker.getTokenType();
((PsiBuilder.Marker) latestDoneMarker).drop();
}
builder.error(message);
if (extensionMarker != null) extensionMarker.done(extensionTokenType);
} else {
builder.error(message);
}
builder.eof(); // skip whitespaces
frame.errorReportedAt = builder.rawTokenIndex();
return true;
}
return false;
}
public static boolean exitErrorRecordingSection(
PsiBuilder builder_,
int level,
boolean result,
boolean pinned,
@NotNull String sectionType,
@Nullable Parser eatMore) {
ErrorState state = ErrorState.get(builder_);
Frame frame = state.levelCheck.pollLast();
int initialOffset = builder_.getCurrentOffset();
if (frame == null || level != frame.level || !sectionType.equals(frame.section)) {
LOG.error(
"Unbalanced error section: got "
+ new Frame().init(initialOffset, level, sectionType, "", 0)
+ ", expected "
+ frame);
if (frame != null) state.FRAMES.recycle(frame);
return result;
}
if (sectionType == _SECTION_AND_ || sectionType == _SECTION_NOT_) {
state.predicateCount--;
if (sectionType == _SECTION_NOT_) state.predicateSign = !state.predicateSign;
state.FRAMES.recycle(frame);
return result;
}
if (!result
&& !pinned
&& initialOffset == frame.offset
&& state.lastExpectedVariantOffset == frame.offset
&& frame.name != null
&& state.variants.size() - frame.variantCount > 1) {
state.clearVariants(true, frame.variantCount);
addVariantInner(state, initialOffset, frame.name);
}
if (sectionType == _SECTION_RECOVER_ && !state.suppressErrors && eatMore != null) {
state.suppressErrors = true;
final boolean eatMoreFlagOnce = !builder_.eof() && eatMore.parse(builder_, frame.level + 1);
final int lastErrorPos = getLastVariantOffset(state, initialOffset);
boolean eatMoreFlag =
eatMoreFlagOnce || frame.offset == initialOffset && lastErrorPos > frame.offset;
final LighterASTNode latestDoneMarker =
(pinned || result) && (state.altMode || lastErrorPos > initialOffset) && eatMoreFlagOnce
? builder_.getLatestDoneMarker()
: null;
PsiBuilder.Marker extensionMarker = null;
IElementType extensionTokenType = null;
if (latestDoneMarker instanceof PsiBuilder.Marker) {
extensionMarker = ((PsiBuilder.Marker) latestDoneMarker).precede();
extensionTokenType = latestDoneMarker.getTokenType();
((PsiBuilder.Marker) latestDoneMarker).drop();
}
// advance to the last error pos
// skip tokens until lastErrorPos. parseAsTree might look better here...
int parenCount = 0;
while (eatMoreFlag && builder_.getCurrentOffset() < lastErrorPos) {
if (state.braces != null) {
if (builder_.getTokenType() == state.braces[0].getLeftBraceType()) parenCount++;
else if (builder_.getTokenType() == state.braces[0].getRightBraceType()) parenCount--;
}
builder_.advanceLexer();
eatMoreFlag = parenCount != 0 || eatMore.parse(builder_, frame.level + 1);
}
boolean errorReported = frame.errorReportedAt == initialOffset;
if (errorReported) {
if (eatMoreFlag) {
builder_.advanceLexer();
parseAsTree(state, builder_, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
}
} else if (eatMoreFlag) {
String tokenText = builder_.getTokenText();
String expectedText = state.getExpectedText(builder_);
PsiBuilder.Marker mark = builder_.mark();
builder_.advanceLexer();
final String gotText =
!expectedText.isEmpty() ? "got '" + tokenText + "'" : "'" + tokenText + "' unexpected";
mark.error(expectedText + gotText);
parseAsTree(state, builder_, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
errorReported = true;
} else if (eatMoreFlagOnce || (!result && frame.offset != builder_.getCurrentOffset())) {
reportError(state, builder_, true);
errorReported = true;
}
if (extensionMarker != null) {
extensionMarker.done(extensionTokenType);
}
state.suppressErrors = false;
if (errorReported || result) {
state.clearVariants(true, 0);
state.clearVariants(false, 0);
state.lastExpectedVariantOffset = -1;
}
if (!result && eatMoreFlagOnce && frame.offset != builder_.getCurrentOffset()) result = true;
} else if (!result && pinned && frame.errorReportedAt < 0) {
// do not report if there're errors after current offset
if (getLastVariantOffset(state, initialOffset) == initialOffset) {
// do not force, inner recoverRoot might have skipped some tokens
if (reportError(state, builder_, false)) {
frame.errorReportedAt = initialOffset;
}
}
}
// propagate errorReportedAt up the stack to avoid duplicate reporting
Frame prevFrame = state.levelCheck.isEmpty() ? null : state.levelCheck.getLast();
if (prevFrame != null && prevFrame.errorReportedAt < frame.errorReportedAt)
prevFrame.errorReportedAt = frame.errorReportedAt;
state.FRAMES.recycle(frame);
return result;
}
