private static int getThreadNum() {
Matcher matcher =
Pattern.compile("JobScheduler FJ pool (\\d*)/(\\d*)")
.matcher(Thread.currentThread().getName());
String num = matcher.matches() ? matcher.group(1) : null;
return StringUtil.parseInt(num, 0);
}
@Nullable
public static SemVer parseFromText(@NotNull String text) {
int majorEndInd = text.indexOf('.');
if (majorEndInd < 0) {
return null;
}
int major = StringUtil.parseInt(text.substring(0, majorEndInd), -1);
int minorEndInd = text.indexOf('.', majorEndInd + 1);
if (minorEndInd < 0) {
return null;
}
int minor = StringUtil.parseInt(text.substring(majorEndInd + 1, minorEndInd), -1);
final String patchStr;
int dashInd = text.indexOf('-', minorEndInd + 1);
if (dashInd >= 0) {
patchStr = text.substring(minorEndInd + 1, dashInd);
} else {
patchStr = text.substring(minorEndInd + 1);
}
int patch = StringUtil.parseInt(patchStr, -1);
if (major >= 0 && minor >= 0 && patch >= 0) {
return new SemVer(text, major, minor, patch);
}
return null;
}
/**
* This class is a runtime engine for parsers generated by <a
* href="https://github.com/JetBrains/Grammar-Kit">Grammar-Kit</a>. <br>
* Here is the original <a
* href="https://github.com/JetBrains/Grammar-Kit/blob/master/support/org/intellij/grammar/parser/GeneratedParserUtilBase.java">
* GeneratedParserUtilBase</a> code. <br>
* <br>
* CAUTION: Authorized personnel only. Do not modify or refactor.
*
* @author gregsh
*/
public class GeneratedParserUtilBase {
private static final Logger LOG =
Logger.getInstance("org.intellij.grammar.parser.GeneratedParserUtilBase");
private static final int MAX_RECURSION_LEVEL =
StringUtil.parseInt(System.getProperty("grammar.kit.gpub.max.level"), 1000);
private static final int MAX_VARIANTS_SIZE = 10000;
private static final int MAX_VARIANTS_TO_DISPLAY = 50;
private static final int INITIAL_VARIANTS_SIZE = 1000;
private static final int VARIANTS_POOL_SIZE = 10000;
private static final int FRAMES_POOL_SIZE = 500;
public static final IElementType DUMMY_BLOCK = new DummyBlockElementType();
public interface Parser {
boolean parse(PsiBuilder builder, int level);
}
public static final Parser TOKEN_ADVANCER =
new Parser() {
@Override
public boolean parse(PsiBuilder builder, int level) {
if (builder.eof()) return false;
builder.advanceLexer();
return true;
}
};
public static final Parser TRUE_CONDITION =
new Parser() {
@Override
public boolean parse(PsiBuilder builder, int level) {
return true;
}
};
public static boolean eof(PsiBuilder builder, int level) {
return builder.eof();
}
public static int current_position_(PsiBuilder builder) {
return builder.rawTokenIndex();
}
public static boolean recursion_guard_(PsiBuilder builder, int level, String funcName) {
if (level > MAX_RECURSION_LEVEL) {
builder.error(
"Maximum recursion level (" + MAX_RECURSION_LEVEL + ") reached in '" + funcName + "'");
return false;
}
return true;
}
public static boolean empty_element_parsed_guard_(PsiBuilder builder, String funcName, int pos) {
if (pos == current_position_(builder)) {
builder.error(
"Empty element parsed in '" + funcName + "' at offset " + builder.getCurrentOffset());
return false;
}
return true;
}
public static boolean invalid_left_marker_guard_(
PsiBuilder builder, PsiBuilder.Marker marker, String funcName) {
// builder.error("Invalid left marker encountered in " + funcName_ +" at offset " +
// builder.getCurrentOffset());
boolean goodMarker =
marker != null; // && ((LighterASTNode)marker).getTokenType() != TokenType.ERROR_ELEMENT;
if (!goodMarker) return false;
ErrorState state = ErrorState.get(builder);
return state.currentFrame != null;
}
public static TokenSet create_token_set_(IElementType... tokenTypes) {
return TokenSet.create(tokenTypes);
}
public static boolean leftMarkerIs(PsiBuilder builder, IElementType type) {
LighterASTNode marker = builder.getLatestDoneMarker();
return marker != null && marker.getTokenType() == type;
}
private static boolean consumeTokens(
PsiBuilder builder, boolean smart, int pin, IElementType... tokens) {
ErrorState state = ErrorState.get(builder);
if (state.completionState != null && state.predicateSign) {
addCompletionVariant(builder, state.completionState, tokens);
}
// suppress single token completion
CompletionState completionState = state.completionState;
state.completionState = null;
boolean result = true;
boolean pinned = false;
for (int i = 0, tokensLength = tokens.length; i < tokensLength; i++) {
if (pin > 0 && i == pin) pinned = result;
if (result || pinned) {
boolean fast = smart && i == 0;
if (!(fast ? consumeTokenFast(builder, tokens[i]) : consumeToken(builder, tokens[i]))) {
result = false;
if (pin < 0 || pinned) report_error_(builder, state, false);
}
}
}
state.completionState = completionState;
return pinned || result;
}
public static boolean consumeTokens(PsiBuilder builder, int pin, IElementType... token) {
return consumeTokens(builder, false, pin, token);
}
public static boolean consumeTokensSmart(PsiBuilder builder, int pin, IElementType... token) {
return consumeTokens(builder, true, pin, token);
}
public static boolean parseTokens(PsiBuilder builder, int pin, IElementType... tokens) {
return parseTokens(builder, false, pin, tokens);
}
public static boolean parseTokensSmart(PsiBuilder builder, int pin, IElementType... tokens) {
return parseTokens(builder, true, pin, tokens);
}
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 static boolean consumeTokenSmart(PsiBuilder builder, IElementType token) {
addCompletionVariantSmart(builder, token);
return consumeTokenFast(builder, token);
}
public static boolean consumeTokenSmart(PsiBuilder builder, String token) {
addCompletionVariantSmart(builder, token);
return consumeTokenFast(builder, token);
}
public static boolean consumeToken(PsiBuilder builder, IElementType token) {
addVariantSmart(builder, token, true);
if (nextTokenIsFast(builder, token)) {
builder.advanceLexer();
return true;
}
return false;
}
public static boolean consumeTokenFast(PsiBuilder builder, IElementType token) {
if (nextTokenIsFast(builder, token)) {
builder.advanceLexer();
return true;
}
return false;
}
public static boolean consumeToken(PsiBuilder builder, String text) {
return consumeToken(builder, text, ErrorState.get(builder).caseSensitive);
}
public static boolean consumeToken(PsiBuilder builder, String text, boolean caseSensitive) {
addVariantSmart(builder, text, true);
int count = nextTokenIsFast(builder, text, caseSensitive);
if (count > 0) {
while (count-- > 0) builder.advanceLexer();
return true;
}
return false;
}
public static boolean consumeTokenFast(PsiBuilder builder, String text) {
int count = nextTokenIsFast(builder, text, ErrorState.get(builder).caseSensitive);
if (count > 0) {
while (count-- > 0) builder.advanceLexer();
return true;
}
return false;
}
public static boolean nextTokenIsFast(PsiBuilder builder, IElementType token) {
return builder.getTokenType() == token;
}
public static boolean nextTokenIsFast(PsiBuilder builder, IElementType... tokens) {
IElementType tokenType = builder.getTokenType();
for (IElementType token : tokens) {
if (token == tokenType) return true;
}
return false;
}
public static boolean nextTokenIs(PsiBuilder builder, String frameName, IElementType... tokens) {
ErrorState state = ErrorState.get(builder);
if (state.completionState != null) return true;
boolean track = !state.suppressErrors && state.predicateCount < 2 && state.predicateSign;
if (!track) return nextTokenIsFast(builder, tokens);
IElementType tokenType = builder.getTokenType();
if (StringUtil.isNotEmpty(frameName)) {
addVariantInner(state, builder.rawTokenIndex(), frameName);
} else {
for (IElementType token : tokens) {
addVariant(builder, state, token);
}
}
if (tokenType == null) return false;
for (IElementType token : tokens) {
if (tokenType == token) return true;
}
return false;
}
public static boolean nextTokenIs(PsiBuilder builder, IElementType token) {
if (!addVariantSmart(builder, token, false)) return true;
return nextTokenIsFast(builder, token);
}
public static boolean nextTokenIs(PsiBuilder builder, String tokenText) {
if (!addVariantSmart(builder, tokenText, false)) return true;
return nextTokenIsFast(builder, tokenText, ErrorState.get(builder).caseSensitive) > 0;
}
public static boolean nextTokenIsFast(PsiBuilder builder, String tokenText) {
return nextTokenIsFast(builder, tokenText, ErrorState.get(builder).caseSensitive) > 0;
}
public static int nextTokenIsFast(PsiBuilder builder, String tokenText, boolean caseSensitive) {
CharSequence sequence = builder.getOriginalText();
int offset = builder.getCurrentOffset();
int endOffset = offset + tokenText.length();
CharSequence subSequence = sequence.subSequence(offset, Math.min(endOffset, sequence.length()));
if (!Comparing.equal(subSequence, tokenText, caseSensitive)) return 0;
int count = 0;
while (true) {
int nextOffset = builder.rawTokenTypeStart(++count);
if (nextOffset > endOffset) {
return -count;
} else if (nextOffset == endOffset) {
break;
}
}
return count;
}
private static void addCompletionVariantSmart(PsiBuilder builder, Object token) {
ErrorState state = ErrorState.get(builder);
CompletionState completionState = state.completionState;
if (completionState != null && state.predicateSign) {
addCompletionVariant(builder, completionState, token);
}
}
private static boolean addVariantSmart(PsiBuilder builder, Object token, boolean force) {
ErrorState state = ErrorState.get(builder);
// skip FIRST check in completion mode
if (state.completionState != null && !force) return false;
builder.eof();
if (!state.suppressErrors && state.predicateCount < 2) {
addVariant(builder, state, token);
}
return true;
}
public static void addVariant(PsiBuilder builder, String text) {
addVariant(builder, ErrorState.get(builder), text);
}
private static void addVariant(PsiBuilder builder, ErrorState state, Object o) {
builder.eof(); // skip whitespaces
addVariantInner(state, builder.rawTokenIndex(), o);
CompletionState completionState = state.completionState;
if (completionState != null && state.predicateSign) {
addCompletionVariant(builder, completionState, o);
}
}
private static void addVariantInner(ErrorState state, int pos, Object o) {
Variant variant = state.VARIANTS.alloc().init(pos, o);
if (state.predicateSign) {
state.variants.add(variant);
if (state.lastExpectedVariantPos < variant.position) {
state.lastExpectedVariantPos = variant.position;
}
} else {
state.unexpected.add(variant);
}
}
private static void addCompletionVariant(
@NotNull PsiBuilder builder, @NotNull CompletionState completionState, Object o) {
int offset = builder.getCurrentOffset();
if (!builder.eof() && offset == builder.rawTokenTypeStart(1))
return; // suppress for zero-length tokens
boolean add = false;
int diff = completionState.offset - offset;
String text = completionState.convertItem(o);
int length = text == null ? 0 : text.length();
if (length == 0) return;
if (diff == 0) {
add = true;
} else if (diff > 0 && diff <= length) {
CharSequence fragment = builder.getOriginalText().subSequence(offset, completionState.offset);
add = completionState.prefixMatches(fragment.toString(), text);
} else if (diff < 0) {
for (int i = -1; ; i--) {
IElementType type = builder.rawLookup(i);
int tokenStart = builder.rawTokenTypeStart(i);
if (isWhitespaceOrComment(builder, type)) {
diff = completionState.offset - tokenStart;
} else if (type != null && tokenStart < completionState.offset) {
CharSequence fragment =
builder.getOriginalText().subSequence(tokenStart, completionState.offset);
if (completionState.prefixMatches(fragment.toString(), text)) {
diff = completionState.offset - tokenStart;
}
break;
} else break;
}
add = diff >= 0 && diff < length;
}
add =
add
&& length > 1
&& !(text.charAt(0) == '<' && text.charAt(length - 1) == '>')
&& !(text.charAt(0) == '\'' && text.charAt(length - 1) == '\'' && length < 5);
if (add) {
completionState.addItem(builder, text);
}
}
public static boolean isWhitespaceOrComment(
@NotNull PsiBuilder builder, @Nullable IElementType type) {
return ((PsiBuilderImpl) ((Builder) builder).getDelegate()).whitespaceOrComment(type);
}
// here's the new section API for compact parsers & less IntelliJ platform API exposure
public static final int _NONE_ = 0x0;
public static final int _COLLAPSE_ = 0x1;
public static final int _LEFT_ = 0x2;
public static final int _LEFT_INNER_ = 0x4;
public static final int _AND_ = 0x8;
public static final int _NOT_ = 0x10;
public static final int _UPPER_ = 0x20;
// simple enter/exit methods pair that doesn't require frame object
public static PsiBuilder.Marker enter_section_(PsiBuilder builder) {
return builder.mark();
}
public static void exit_section_(
PsiBuilder builder,
PsiBuilder.Marker marker,
@Nullable IElementType elementType,
boolean result) {
close_marker_impl_(ErrorState.get(builder).currentFrame, marker, elementType, result);
}
// complex enter/exit methods pair with frame object
public static PsiBuilder.Marker enter_section_(
PsiBuilder builder, int level, int modifiers, String frameName) {
return enter_section_(builder, level, modifiers, null, frameName);
}
public static PsiBuilder.Marker enter_section_(PsiBuilder builder, int level, int modifiers) {
return enter_section_(builder, level, modifiers, null, null);
}
public static PsiBuilder.Marker enter_section_(
PsiBuilder builder, int level, int modifiers, IElementType elementType, String frameName) {
PsiBuilder.Marker marker = builder.mark();
enter_section_impl_(builder, level, modifiers, elementType, frameName);
return marker;
}
private static void enter_section_impl_(
PsiBuilder builder, int level, int modifiers, IElementType elementType, String frameName) {
ErrorState state = ErrorState.get(builder);
Frame frame =
state.FRAMES.alloc().init(builder, state, level, modifiers, elementType, frameName);
Frame prevFrame = state.currentFrame;
if (prevFrame != null && prevFrame.errorReportedAt > frame.position) {
// report error for previous unsuccessful frame
reportError(builder, state, frame, null, true, false);
}
if (((frame.modifiers & _LEFT_) | (frame.modifiers & _LEFT_INNER_)) != 0) {
PsiBuilder.Marker left = (PsiBuilder.Marker) builder.getLatestDoneMarker();
if (invalid_left_marker_guard_(builder, left, frameName)) {
frame.leftMarker = left;
}
}
state.currentFrame = frame;
if ((modifiers & _AND_) != 0) {
if (state.predicateCount == 0 && !state.predicateSign) {
throw new AssertionError("Incorrect false predicate sign");
}
state.predicateCount++;
} else if ((modifiers & _NOT_) != 0) {
if (state.predicateCount == 0) {
state.predicateSign = false;
} else {
state.predicateSign = !state.predicateSign;
}
state.predicateCount++;
}
}
public static void exit_section_(
PsiBuilder builder,
int level,
PsiBuilder.Marker marker,
boolean result,
boolean pinned,
@Nullable Parser eatMore) {
exit_section_(builder, level, marker, null, result, pinned, eatMore);
}
public static void exit_section_(
PsiBuilder builder,
int level,
PsiBuilder.Marker marker,
@Nullable IElementType elementType,
boolean result,
boolean pinned,
@Nullable Parser eatMore) {
ErrorState state = ErrorState.get(builder);
Frame frame = state.currentFrame;
state.currentFrame = frame == null ? null : frame.parentFrame;
if (frame != null && frame.elementType != null) elementType = frame.elementType;
if (frame == null || level != frame.level) {
LOG.error("Unbalanced error section: got " + frame + ", expected level " + level);
if (frame != null) state.FRAMES.recycle(frame);
close_marker_impl_(frame, marker, elementType, result);
return;
}
if (((frame.modifiers & _AND_) | (frame.modifiers & _NOT_)) != 0) {
close_marker_impl_(frame, marker, null, false);
state.predicateCount--;
if ((frame.modifiers & _NOT_) != 0) state.predicateSign = !state.predicateSign;
} else {
close_frame_impl_(state, frame, builder, marker, elementType, result, pinned);
exit_section_impl_(state, frame, builder, elementType, result, pinned, eatMore);
}
state.FRAMES.recycle(frame);
}
private static void exit_section_impl_(
ErrorState state,
Frame frame,
PsiBuilder builder,
@Nullable IElementType elementType,
boolean result,
boolean pinned,
@Nullable Parser eatMore) {
int initialPos = builder.rawTokenIndex();
boolean willFail = !result && !pinned;
if (willFail
&& initialPos == frame.position
&& state.lastExpectedVariantPos == frame.position
&& frame.name != null
&& state.variants.size() - frame.variantCount > 1) {
state.clearVariants(true, frame.variantCount);
addVariantInner(state, initialPos, frame.name);
}
int lastErrorPos = getLastVariantPos(state, initialPos);
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;
PsiBuilderImpl.ProductionMarker latestDoneMarker =
(pinned || result) && (state.altMode || elementType != null) && eatMoreFlagOnce
? (PsiBuilderImpl.ProductionMarker) builder.getLatestDoneMarker()
: null;
PsiBuilder.Marker extensionMarker = null;
IElementType extensionTokenType = null;
// whitespace prefix makes the very first frame offset bigger than marker start offset which
// is always 0
if (latestDoneMarker != null
&& frame.position >= latestDoneMarker.getStartIndex()
&& frame.position <= latestDoneMarker.getEndIndex()) {
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 || parenCount > 0) && builder.rawTokenIndex() < 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 = eatMore.parse(builder, frame.level + 1);
}
boolean errorReported =
frame.errorReportedAt == initialPos || !result && frame.errorReportedAt >= frame.position;
if (errorReported) {
if (eatMoreFlag) {
builder.advanceLexer();
parseAsTree(state, builder, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
}
} else if (eatMoreFlag) {
errorReported = reportError(builder, state, frame, null, true, true);
parseAsTree(state, builder, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
} else if (eatMoreFlagOnce
|| (!result && frame.position != builder.rawTokenIndex())
|| frame.errorReportedAt > initialPos) {
errorReported = reportError(builder, state, frame, null, true, false);
} else if (!result && pinned && frame.errorReportedAt < 0) {
errorReported = reportError(builder, state, frame, elementType, false, false);
}
if (extensionMarker != null) {
extensionMarker.done(extensionTokenType);
}
state.suppressErrors = false;
if (errorReported || result) {
state.clearVariants(true, 0);
state.clearVariants(false, 0);
state.lastExpectedVariantPos = -1;
}
} else if (!result && pinned && frame.errorReportedAt < 0) {
// do not report if there are errors beyond current position
if (lastErrorPos == initialPos) {
// do not force, inner recoverRoot might have skipped some tokens
reportError(builder, state, frame, elementType, false, false);
} else if (lastErrorPos > initialPos) {
// set error pos here as if it is reported for future reference
frame.errorReportedAt = lastErrorPos;
}
}
// propagate errorReportedAt up the stack to avoid duplicate reporting
Frame prevFrame = willFail && eatMore == null ? null : state.currentFrame;
if (prevFrame != null && prevFrame.errorReportedAt < frame.errorReportedAt) {
prevFrame.errorReportedAt = frame.errorReportedAt;
}
}
private static void close_frame_impl_(
ErrorState state,
Frame frame,
PsiBuilder builder,
PsiBuilder.Marker marker,
IElementType elementType,
boolean result,
boolean pinned) {
if (elementType != null && marker != null) {
if ((frame.modifiers & _COLLAPSE_) != 0) {
PsiBuilderImpl.ProductionMarker last =
result || pinned
? (PsiBuilderImpl.ProductionMarker) builder.getLatestDoneMarker()
: null;
if (last != null
&& last.getStartIndex() == frame.position
&& state.typeExtends(last.getTokenType(), elementType)) {
IElementType resultType = last.getTokenType();
((PsiBuilder.Marker) last).drop();
marker.done(resultType);
return;
}
}
if (result || pinned) {
if ((frame.modifiers & _UPPER_) != 0) {
marker.drop();
frame.parentFrame.elementType = elementType;
} else if ((frame.modifiers & _LEFT_INNER_) != 0 && frame.leftMarker != null) {
marker.done(elementType);
frame.leftMarker.precede().done(((LighterASTNode) frame.leftMarker).getTokenType());
frame.leftMarker.drop();
} else if ((frame.modifiers & _LEFT_) != 0 && frame.leftMarker != null) {
marker.drop();
frame.leftMarker.precede().done(elementType);
} else {
if (frame.level == 0) builder.eof(); // skip whitespaces
marker.done(elementType);
}
} else {
close_marker_impl_(frame, marker, null, false);
}
} else if (result || pinned) {
if (marker != null) marker.drop();
if ((frame.modifiers & _LEFT_INNER_) != 0 && frame.leftMarker != null) {
frame.leftMarker.precede().done(((LighterASTNode) frame.leftMarker).getTokenType());
frame.leftMarker.drop();
}
} else {
close_marker_impl_(frame, marker, null, false);
}
}
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 report_error_(PsiBuilder builder, boolean result) {
if (!result) report_error_(builder, ErrorState.get(builder), false);
return result;
}
public static void report_error_(PsiBuilder builder, ErrorState state, boolean advance) {
Frame frame = state.currentFrame;
if (frame == null) {
LOG.error("unbalanced enter/exit section call: got null");
return;
}
int position = builder.rawTokenIndex();
if (frame.errorReportedAt < position && getLastVariantPos(state, position + 1) <= position) {
reportError(builder, state, frame, null, true, advance);
}
}
private static int getLastVariantPos(ErrorState state, int defValue) {
return state.lastExpectedVariantPos < 0 ? defValue : state.lastExpectedVariantPos;
}
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 final Key<CompletionState> COMPLETION_STATE_KEY =
Key.create("COMPLETION_STATE_KEY");
public static class CompletionState implements Function<Object, String> {
public final int offset;
public final Collection<String> items = ContainerUtil.newTroveSet();
public CompletionState(int offset_) {
offset = offset_;
}
@Nullable
public String convertItem(Object o) {
return o instanceof Object[] ? StringUtil.join((Object[]) o, this, " ") : o.toString();
}
@Override
public String fun(Object o) {
return o.toString();
}
public void addItem(@NotNull PsiBuilder builder, @NotNull String text) {
items.add(text);
}
public boolean prefixMatches(@NotNull String prefix, @NotNull String variant) {
boolean matches =
new CamelHumpMatcher(prefix, false).prefixMatches(variant.replace(' ', '_'));
if (matches && StringUtil.isWhiteSpace(prefix.charAt(prefix.length() - 1))) {
return StringUtil.startsWithIgnoreCase(variant, prefix);
}
return matches;
}
}
public static class Builder extends PsiBuilderAdapter {
public final ErrorState state;
public final PsiParser parser;
public Builder(PsiBuilder builder, ErrorState state_, PsiParser parser_) {
super(builder);
state = state_;
parser = parser_;
}
public Lexer getLexer() {
return ((PsiBuilderImpl) myDelegate).getLexer();
}
}
public static PsiBuilder adapt_builder_(IElementType root, PsiBuilder builder, PsiParser parser) {
return adapt_builder_(root, builder, parser, null);
}
public static PsiBuilder adapt_builder_(
IElementType root, PsiBuilder builder, PsiParser parser, TokenSet[] extendsSets) {
ErrorState state = new ErrorState();
ErrorState.initState(state, builder, root, extendsSets);
return new Builder(builder, state, parser);
}
public static class ErrorState {
TokenSet[] extendsSets;
public PairProcessor<IElementType, IElementType> altExtendsChecker;
int predicateCount;
boolean predicateSign = true;
boolean suppressErrors;
public Frame currentFrame;
public CompletionState completionState;
private boolean caseSensitive;
public BracePair[] braces;
public boolean altMode;
int lastExpectedVariantPos = -1;
MyList<Variant> variants = new MyList<Variant>(INITIAL_VARIANTS_SIZE);
MyList<Variant> unexpected = new MyList<Variant>(INITIAL_VARIANTS_SIZE / 10);
final LimitedPool<Variant> VARIANTS =
new LimitedPool<Variant>(
VARIANTS_POOL_SIZE,
new LimitedPool.ObjectFactory<Variant>() {
@NotNull
@Override
public Variant create() {
return new Variant();
}
@Override
public void cleanup(@NotNull Variant o) {}
});
final LimitedPool<Frame> FRAMES =
new LimitedPool<Frame>(
FRAMES_POOL_SIZE,
new LimitedPool.ObjectFactory<Frame>() {
@NotNull
@Override
public Frame create() {
return new Frame();
}
@Override
public void cleanup(@NotNull Frame o) {}
});
public static ErrorState get(PsiBuilder builder) {
return ((Builder) builder).state;
}
public static void initState(
ErrorState state, PsiBuilder builder, IElementType root, TokenSet[] extendsSets) {
state.extendsSets = extendsSets;
PsiFile file = builder.getUserDataUnprotected(FileContextUtil.CONTAINING_FILE_KEY);
state.completionState = file == null ? null : file.getUserData(COMPLETION_STATE_KEY);
Language language = file == null ? root.getLanguage() : file.getLanguage();
state.caseSensitive = language.isCaseSensitive();
PairedBraceMatcher matcher = LanguageBraceMatching.INSTANCE.forLanguage(language);
state.braces = matcher == null ? null : matcher.getPairs();
if (state.braces != null && state.braces.length == 0) state.braces = null;
}
public String getExpectedText(PsiBuilder builder) {
int position = builder.rawTokenIndex();
StringBuilder sb = new StringBuilder();
if (addExpected(sb, position, true)) {
sb.append(" expected, ");
}
return sb.toString();
}
private boolean addExpected(StringBuilder sb, int position, boolean expected) {
MyList<Variant> list = expected ? variants : unexpected;
String[] strings = new String[list.size()];
long[] hashes = new long[strings.length];
Arrays.fill(strings, "");
int count = 0;
loop:
for (Variant variant : list) {
if (position == variant.position) {
String text = variant.object.toString();
long hash = StringHash.calc(text);
for (int i = 0; i < count; i++) {
if (hashes[i] == hash) continue loop;
}
hashes[count] = hash;
strings[count] = text;
count++;
}
}
Arrays.sort(strings);
count = 0;
for (String s : strings) {
if (s.length() == 0) continue;
if (count++ > 0) {
if (count > MAX_VARIANTS_TO_DISPLAY) {
sb.append(" and ...");
break;
} else {
sb.append(", ");
}
}
char c = s.charAt(0);
String displayText = c == '<' || StringUtil.isJavaIdentifierStart(c) ? s : '\'' + s + '\'';
sb.append(displayText);
}
if (count > 1 && count < MAX_VARIANTS_TO_DISPLAY) {
int idx = sb.lastIndexOf(", ");
sb.replace(idx, idx + 1, " or");
}
return count > 0;
}
public void clearVariants(Frame frame) {
clearVariants(true, frame == null ? 0 : frame.variantCount);
}
void clearVariants(boolean expected, int start) {
MyList<Variant> list = expected ? variants : unexpected;
if (start < 0 || start >= list.size()) return;
for (int i = start, len = list.size(); i < len; i++) {
VARIANTS.recycle(list.get(i));
}
list.setSize(start);
}
public boolean typeExtends(IElementType child, IElementType parent) {
if (child == parent) return true;
if (extendsSets != null) {
for (TokenSet set : extendsSets) {
if (set.contains(child) && set.contains(parent)) return true;
}
}
return altExtendsChecker != null && altExtendsChecker.process(child, parent);
}
}
public static class Frame {
public Frame parentFrame;
public IElementType elementType;
public int offset;
public int position;
public int level;
public int modifiers;
public String name;
public int variantCount;
public int errorReportedAt;
public PsiBuilder.Marker leftMarker;
public Frame() {}
public Frame init(
PsiBuilder builder,
ErrorState state,
int level_,
int modifiers_,
IElementType elementType_,
String name_) {
parentFrame = state.currentFrame;
elementType = elementType_;
offset = builder.getCurrentOffset();
position = builder.rawTokenIndex();
level = level_;
modifiers = modifiers_;
name = name_;
variantCount = state.variants.size();
errorReportedAt = -1;
leftMarker = null;
return this;
}
@Override
public String toString() {
String mod =
modifiers == _NONE_
? "_NONE_, "
: ((modifiers & _COLLAPSE_) != 0 ? "_CAN_COLLAPSE_, " : "")
+ ((modifiers & _LEFT_) != 0 ? "_LEFT_, " : "")
+ ((modifiers & _LEFT_INNER_) != 0 ? "_LEFT_INNER_, " : "")
+ ((modifiers & _AND_) != 0 ? "_AND_, " : "")
+ ((modifiers & _NOT_) != 0 ? "_NOT_, " : "")
+ ((modifiers & _UPPER_) != 0 ? "_UPPER_, " : "");
return String.format(
"{%s:%s:%d, %d, %s%s, %s}",
offset, position, level, errorReportedAt, mod, elementType, name);
}
}
private static class Variant {
int position;
Object object;
public Variant init(int pos, Object o) {
position = pos;
object = o;
return this;
}
@Override
public String toString() {
return "<" + position + ", " + object + ">";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Variant variant = (Variant) o;
if (position != variant.position) return false;
if (!this.object.equals(variant.object)) return false;
return true;
}
@Override
public int hashCode() {
int result = position;
result = 31 * result + object.hashCode();
return result;
}
}
private static final int MAX_CHILDREN_IN_TREE = 10;
public static boolean parseAsTree(
ErrorState state,
final PsiBuilder builder,
int level,
final IElementType chunkType,
boolean checkBraces,
final Parser parser,
final Parser eatMoreCondition) {
final LinkedList<Pair<PsiBuilder.Marker, PsiBuilder.Marker>> parenList =
new LinkedList<Pair<PsiBuilder.Marker, PsiBuilder.Marker>>();
final LinkedList<Pair<PsiBuilder.Marker, Integer>> siblingList =
new LinkedList<Pair<PsiBuilder.Marker, Integer>>();
PsiBuilder.Marker marker = null;
final Runnable checkSiblingsRunnable =
new Runnable() {
@Override
public void run() {
main:
while (!siblingList.isEmpty()) {
final Pair<PsiBuilder.Marker, PsiBuilder.Marker> parenPair = parenList.peek();
final int rating = siblingList.getFirst().second;
int count = 0;
for (Pair<PsiBuilder.Marker, Integer> pair : siblingList) {
if (pair.second != rating || parenPair != null && pair.first == parenPair.second)
break main;
if (++count >= MAX_CHILDREN_IN_TREE) {
PsiBuilder.Marker parentMarker = pair.first.precede();
parentMarker.setCustomEdgeTokenBinders(
WhitespacesBinders.GREEDY_LEFT_BINDER, null);
while (count-- > 0) {
siblingList.removeFirst();
}
parentMarker.done(chunkType);
siblingList.addFirst(Pair.create(parentMarker, rating + 1));
continue main;
}
}
break;
}
}
};
boolean checkParens = state.braces != null && checkBraces;
int totalCount = 0;
int tokenCount = 0;
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));
}
}
while (true) {
final IElementType tokenType = builder.getTokenType();
if (checkParens
&& (tokenType == state.braces[0].getLeftBraceType()
|| tokenType == state.braces[0].getRightBraceType() && !parenList.isEmpty())) {
if (marker != null) {
marker.done(chunkType);
siblingList.addFirst(Pair.create(marker, 1));
marker = null;
tokenCount = 0;
}
if (tokenType == state.braces[0].getLeftBraceType()) {
final Pair<PsiBuilder.Marker, Integer> prev = siblingList.peek();
parenList.addFirst(Pair.create(builder.mark(), prev == null ? null : prev.first));
}
checkSiblingsRunnable.run();
builder.advanceLexer();
if (tokenType == state.braces[0].getRightBraceType()) {
final Pair<PsiBuilder.Marker, PsiBuilder.Marker> pair = parenList.removeFirst();
pair.first.done(chunkType);
// drop all markers inside parens
while (!siblingList.isEmpty() && siblingList.getFirst().first != pair.second) {
siblingList.removeFirst();
}
siblingList.addFirst(Pair.create(pair.first, 1));
checkSiblingsRunnable.run();
}
} else {
if (marker == null) {
marker = builder.mark();
marker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, null);
}
final boolean result =
(!parenList.isEmpty() || eatMoreCondition.parse(builder, level + 1))
&& parser.parse(builder, level + 1);
if (result) {
tokenCount++;
totalCount++;
}
if (!result) {
break;
}
}
if (tokenCount >= MAX_CHILDREN_IN_TREE && marker != null) {
marker.done(chunkType);
siblingList.addFirst(Pair.create(marker, 1));
checkSiblingsRunnable.run();
marker = null;
tokenCount = 0;
}
}
if (marker != null) {
marker.drop();
}
for (Pair<PsiBuilder.Marker, PsiBuilder.Marker> pair : parenList) {
pair.first.drop();
}
return totalCount != 0;
}
private static class DummyBlockElementType extends IElementType implements ICompositeElementType {
DummyBlockElementType() {
super("DUMMY_BLOCK", Language.ANY);
}
@NotNull
@Override
public ASTNode createCompositeNode() {
return new DummyBlock();
}
}
public static class DummyBlock extends CompositePsiElement {
DummyBlock() {
super(DUMMY_BLOCK);
}
@NotNull
@Override
public PsiReference[] getReferences() {
return PsiReference.EMPTY_ARRAY;
}
@NotNull
@Override
public Language getLanguage() {
return getParent().getLanguage();
}
}
private static class MyList<E> extends ArrayList<E> {
MyList(int initialCapacity) {
super(initialCapacity);
}
protected void setSize(int fromIndex) {
removeRange(fromIndex, size());
}
@Override
public boolean add(E e) {
int size = size();
if (size >= MAX_VARIANTS_SIZE) {
removeRange(MAX_VARIANTS_SIZE / 4, size - MAX_VARIANTS_SIZE / 4);
}
return super.add(e);
}
}
}
public void apply() throws ConfigurationException {
EditorSettingsExternalizable editorSettings = EditorSettingsExternalizable.getInstance();
CodeInsightSettings codeInsightSettings = CodeInsightSettings.getInstance();
UISettings uiSettings = UISettings.getInstance();
// Display
editorSettings.setSmoothScrolling(myCbSmoothScrolling.isSelected());
// Brace Highlighting
codeInsightSettings.HIGHLIGHT_BRACES = myCbHighlightBraces.isSelected();
codeInsightSettings.HIGHLIGHT_SCOPE = myCbHighlightScope.isSelected();
codeInsightSettings.HIGHLIGHT_IDENTIFIER_UNDER_CARET =
myCbHighlightIdentifierUnderCaret.isSelected();
clearAllIdentifierHighlighters();
// Virtual space
editorSettings.setUseSoftWraps(
myCbUseSoftWrapsAtEditor.isSelected(), SoftWrapAppliancePlaces.MAIN_EDITOR);
editorSettings.setUseSoftWraps(
myCbUseSoftWrapsAtConsole.isSelected(), SoftWrapAppliancePlaces.CONSOLE);
editorSettings.setUseCustomSoftWrapIndent(myCbUseCustomSoftWrapIndent.isSelected());
editorSettings.setCustomSoftWrapIndent(getCustomSoftWrapIndent());
editorSettings.setAllSoftwrapsShown(myCbShowAllSoftWraps.isSelected());
editorSettings.setVirtualSpace(myCbVirtualSpace.isSelected());
editorSettings.setCaretInsideTabs(myCbCaretInsideTabs.isSelected());
editorSettings.setAdditionalPageAtBottom(myCbVirtualPageAtBottom.isSelected());
// Limits
boolean uiSettingsChanged = false;
int maxClipboardContents = getMaxClipboardContents();
if (uiSettings.MAX_CLIPBOARD_CONTENTS != maxClipboardContents) {
uiSettings.MAX_CLIPBOARD_CONTENTS = maxClipboardContents;
uiSettingsChanged = true;
}
if (uiSettingsChanged) {
uiSettings.fireUISettingsChanged();
}
// Strip trailing spaces on save
if (STRIP_NONE.equals(myStripTrailingSpacesCombo.getSelectedItem())) {
editorSettings.setStripTrailingSpaces(
EditorSettingsExternalizable.STRIP_TRAILING_SPACES_NONE);
} else if (STRIP_CHANGED.equals(myStripTrailingSpacesCombo.getSelectedItem())) {
editorSettings.setStripTrailingSpaces(
EditorSettingsExternalizable.STRIP_TRAILING_SPACES_CHANGED);
} else {
editorSettings.setStripTrailingSpaces(
EditorSettingsExternalizable.STRIP_TRAILING_SPACES_WHOLE);
}
editorSettings.setEnsureNewLineAtEOF(myCbEnsureBlankLineBeforeCheckBox.isSelected());
if (myCbShowQuickDocOnMouseMove.isSelected()
^ editorSettings.isShowQuickDocOnMouseOverElement()) {
boolean enabled = myCbShowQuickDocOnMouseMove.isSelected();
editorSettings.setShowQuickDocOnMouseOverElement(enabled);
ServiceManager.getService(QuickDocOnMouseOverManager.class).setEnabled(enabled);
}
Long quickDocDelay = getQuickDocDelayFromGui();
if (quickDocDelay != null) {
editorSettings.setQuickDocOnMouseOverElementDelayMillis(quickDocDelay);
}
editorSettings.setDndEnabled(myCbEnableDnD.isSelected());
editorSettings.setWheelFontChangeEnabled(myCbEnableWheelFontChange.isSelected());
editorSettings.setMouseClickSelectionHonorsCamelWords(
myCbHonorCamelHumpsWhenSelectingByClicking.isSelected());
editorSettings.setRefrainFromScrolling(myRbPreferMovingCaret.isSelected());
editorSettings.setVariableInplaceRenameEnabled(myCbRenameLocalVariablesInplace.isSelected());
editorSettings.setPreselectRename(myPreselectCheckBox.isSelected());
editorSettings.getOptions().SHOW_REFORMAT_DIALOG =
myShowReformatCodeDialogCheckBox.isSelected();
editorSettings.getOptions().SHOW_OPIMIZE_IMPORTS_DIALOG =
myShowOptimizeImportsDialogCheckBox.isSelected();
reinitAllEditors();
String temp = myRecentFilesLimitField.getText();
if (temp.trim().length() > 0) {
try {
int newRecentFilesLimit = Integer.parseInt(temp);
if (newRecentFilesLimit > 0 && uiSettings.RECENT_FILES_LIMIT != newRecentFilesLimit) {
uiSettings.RECENT_FILES_LIMIT = newRecentFilesLimit;
uiSettingsChanged = true;
}
} catch (NumberFormatException ignored) {
}
}
if (uiSettingsChanged) {
uiSettings.fireUISettingsChanged();
}
uiSettings.CONSOLE_COMMAND_HISTORY_LIMIT =
StringUtil.parseInt(
myCommandsHistoryLimitField.getText(), uiSettings.CONSOLE_COMMAND_HISTORY_LIMIT);
myErrorHighlightingPanel.apply();
RichCopySettings settings = RichCopySettings.getInstance();
Object item = myRichCopyColorSchemeComboBox.getSelectedItem();
if (item instanceof String) {
settings.setSchemeName(item.toString());
}
settings.setStripIndents(myRichCopyStripWhitespaceCheckBox.isSelected());
restartDaemons();
}