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 String text = completionState.convertItem(o); int length = text == null? 0 : text.length(); boolean add = length != 0 && completionState.prefixMatches(builder, text); 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 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 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; }
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; }
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; }
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; } }
public boolean prefixMatches(@NotNull PsiBuilder builder, @NotNull String text) { int builderOffset = builder.getCurrentOffset(); int diff = offset - builderOffset; int length = text.length();
@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; } };
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 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 String text = completionState.convertItem(o); int length = text == null ? 0 : text.length(); boolean add = length != 0 && completionState.prefixMatches(builder, text); 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); } }
@SuppressWarnings({"StringConcatenationInsideStringBufferAppend", "UnusedDeclaration"}) private void logPos() { StringBuilder sb = new StringBuilder(); sb.append("\nmyLexPosition=" + myLexPosition + "/" + myShrunkSequenceSize); if (myLexPosition < myShrunkSequenceSize) { final MyShiftedToken token = myShrunkSequence.get(myLexPosition); sb.append("\nshrunk:" + token.shrunkStart + "," + token.shrunkEnd); sb.append("\nreal:" + token.realStart + "," + token.realEnd); sb.append("\nTT:" + getTokenText()); } sb.append("\ndelegate:"); sb.append("eof=" + myDelegate.eof()); if (!myDelegate.eof()) { //noinspection ConstantConditions sb.append("\nposition:" + myDelegate.getCurrentOffset() + "," + (myDelegate.getCurrentOffset() + myDelegate.getTokenText().length())); sb.append("\nTT:" + myDelegate.getTokenText()); } LOG.info(sb.toString()); }
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; }
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; lastVariantAt = -1; leftMarker = null; return this; }
protected void visitTerminalImpl(TerminalNode node) { if (node.getSymbol().getType() == Token.EOF) { return; } // properly recovers from parse tree alterations due to error recovery efforts while (builder.getCurrentOffset() <= node.getSymbol().getStartIndex()) { PsiBuilder.Marker errorMarker = null; if (nextSyntaxError < syntaxErrors.size() && builder.getCurrentOffset() >= getStart(syntaxErrors.get(nextSyntaxError))) { errorMarker = builder.mark(); } builder.advanceLexer(); if (errorMarker != null) { StringBuilder message = new StringBuilder(); while (nextSyntaxError < syntaxErrors.size() && builder.getCurrentOffset() >= getStart(syntaxErrors.get(nextSyntaxError))) { message.append(String.format("%s%n", syntaxErrors.get(nextSyntaxError).getMessage())); nextSyntaxError++; } errorMarker.error(message.toString()); } } }
@Override protected boolean generateNodeCall(PsiBuilder builder, int level, BnfRule rule, @Nullable BnfExpression node, String nextName, Map<String, GeneratedParserUtilBase.Parser> externalArguments) { int tokenStartOffset = builder.getCurrentOffset(); int initialOffset = builder.rawLookup(-1) == TokenType.WHITE_SPACE ? builder.rawTokenTypeStart(-1) : builder.getCurrentOffset(); String tokenText = builder.getTokenText(); int tokenEndOffset = tokenText == null? tokenStartOffset : tokenStartOffset + tokenText.length(); boolean result = super.generateNodeCall(builder, level, rule, node, nextName, externalArguments); builder.getCurrentOffset(); // advance to the next token first int finalOffset = builder.rawLookup(-1) == TokenType.WHITE_SPACE ? builder.rawTokenTypeStart(-1) : builder.getCurrentOffset(); if (node != null) { if (result && initialOffset <= caretOffset && finalOffset > caretOffset || !result && initialOffset <= caretOffset && tokenEndOffset > caretOffset) { boolean inWhitespace = isTokenExpression(node) && initialOffset <= caretOffset && tokenStartOffset > caretOffset; if (!processor.process(node, result && !inWhitespace)) { throw new ProcessCanceledException(); } } } return result; }
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; }
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; } }
/** * @param exact if true then positions should be equal; * else delegate should be behind, not including exactly all foreign (skipped) or whitespace tokens */ private void synchronizePositions(boolean exact) { final PsiBuilder delegate = getDelegate(); if (myLexPosition >= myShrunkSequenceSize || delegate.eof()) { myLexPosition = myShrunkSequenceSize; while (!delegate.eof()) { delegate.advanceLexer(); } return; } if (delegate.getCurrentOffset() > myShrunkSequence.get(myLexPosition).realStart) { LOG.debug("delegate is ahead of my builder!"); return; } final int keepUpPosition = getKeepUpPosition(exact); while (!delegate.eof()) { final int delegatePosition = delegate.getCurrentOffset(); if (delegatePosition < keepUpPosition) { delegate.advanceLexer(); } else { break; } } }
@Override public Token nextToken() { TokenIElementType ideaTType = (TokenIElementType)builder.getTokenType(); int type; if ( ideaTType==null ) { type = Token.EOF; } else { type = ideaTType.getType(); } int channel = Token.DEFAULT_CHANNEL; Pair<TokenSource, CharStream> source = new Pair<TokenSource, CharStream>(this, null); String text = builder.getTokenText(); int start = builder.getCurrentOffset(); int length = text != null ? text.length() : 0; int stop = start + length - 1; // PsiBuilder doesn't provide line, column info int line = 0; int charPositionInLine = 0; Token t = factory.create(source, type, text, channel, start, stop, line, charPositionInLine); builder.advanceLexer(); // System.out.println("TOKEN: "+t); return t; }
Pair<TokenSource, CharStream> source = new Pair<TokenSource, CharStream>(this, null); String text = builder.getTokenText(); int start = builder.getCurrentOffset(); int length = text != null ? text.length() : 0; int stop = start + length - 1;