java类org.antlr.v4.runtime.misc.Interval的实例源码

private void updateVersionNumber(TerminalNode currentVersionToken, final int newVersion) {
    Interval sourceInterval = ParseTrees.getSourceInterval(currentVersionToken);
    OffsetRegion region = OffsetRegion.fromBounds(sourceInterval.a, sourceInterval.b + 1);
    TrackingPositionRegion trackingRegion = _snapshot.createTrackingRegion(region, TrackingPositionRegion.Bias.Forward);
    final SnapshotPositionRegion currentRegion = trackingRegion.getRegion(_snapshot.getVersionedDocument().getCurrentSnapshot());
    final BaseDocument baseDocument = (BaseDocument)_snapshot.getVersionedDocument().getDocument();
    if (baseDocument == null) {
        throw new UnsupportedOperationException("No document available");
    }

    baseDocument.runAtomicAsUser(new Runnable() {

        @Override
        public void run() {
            try {
                baseDocument.remove(currentRegion.getStart().getOffset(), currentRegion.getLength());
                baseDocument.insertString(currentRegion.getStart().getOffset(), Integer.toString(newVersion), null);
            } catch (BadLocationException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    });
}

@CheckForNull
@RuleDependency(recognizer=GrammarParser.class, rule=GrammarParser.RULE_parserRuleSpec, version=0, dependents=Dependents.SELF)
private static ParserRuleSpecContext findRuleForDescription(@NonNull Map<ParserRuleSpecContext, String> rules, @NonNull Description description) {
    for (Map.Entry<ParserRuleSpecContext, String> entry : rules.entrySet()) {
        if (!description.getName().equals(entry.getValue())) {
            continue;
        }

        Interval sourceInterval = ParseTrees.getSourceInterval(entry.getKey());
        if (sourceInterval.a <= description.getOffset() && sourceInterval.b >= description.getOffset()) {
            return entry.getKey();
        }
    }

    return null;
}

@Override
public String getText(Interval interval) {
    int startIndex = interval.a;
    int endIndexInclusive = interval.b;
    if (currentSnapshotLine != null) {
        if (startIndex >= currentSnapshotLineStartIndex && (endIndexInclusive + 1) <= currentSnapshotLineStartIndex + currentSnapshotLine.length()) {
            return currentSnapshotLine.substring(startIndex - currentSnapshotLineStartIndex, endIndexInclusive - currentSnapshotLineStartIndex + 1);
        }
    }
    try {
        return document.getText(startIndex, endIndexInclusive - startIndex + 1).toString();
    } catch (BadLocationException ex) {
        LOGGER.log(Level.WARNING, ex.getMessage(), ex);
        return null;
    }
}

@Override
public String getText(Interval interval) {
    int start = interval.a;
    int stop = interval.b;
    if (currentSnapshotLine != null) {
        if (start >= currentSnapshotLineStartIndex && stop < currentSnapshotLineStartIndex + currentSnapshotLine.length()) {
            return currentSnapshotLine.substring(start - currentSnapshotLineStartIndex, stop + 1 - currentSnapshotLineStartIndex);
        }
    }

    // HACK: special handling due to Lexer passing invalid indexes.
    if (stop >= size()) {
        stop = size() - 1;
    }

    return getSnapshot().subSequence(start, stop + 1).toString();
}

public static Interval getSourceInterval(@NonNull ParserRuleContext context) {
    Parameters.notNull("context", context);
    int startIndex = context.start.getStartIndex();
    Token stopSymbol = getStopSymbol(context);
    if (stopSymbol == null) {
        return new Interval(startIndex, startIndex - 1);
    }

    int stopIndex;
    if (stopSymbol.getType() != Token.EOF) {
        stopIndex = stopSymbol.getStopIndex();
    } else {
        TokenSource tokenSource = context.getStart().getTokenSource();
        CharStream inputStream = tokenSource != null ? tokenSource.getInputStream() : null;
        if (inputStream != null) {
            stopIndex = inputStream.size() - 1;
        } else {
            stopIndex = context.start.getStartIndex() - 1;
        }
    }

    stopIndex = Math.max(stopIndex, startIndex - 1);
    return new Interval(startIndex, stopIndex);
}

public static Interval getSourceInterval(@NonNull ParseTree context) {
    Parameters.notNull("context", context);

    if (context instanceof TerminalNode) {
        TerminalNode terminalNode = (TerminalNode)context;
        Token token = terminalNode.getSymbol();
        return new Interval(token.getStartIndex(), token.getStopIndex());
    } else if (context instanceof RuleNode) {
        RuleNode ruleNode = (RuleNode)context;
        RuleContext ruleContext = ruleNode.getRuleContext();
        if (ruleContext instanceof ParserRuleContext) {
            return getSourceInterval((ParserRuleContext)ruleContext);
        } else {
            Token startSymbol = getStartSymbol(context);
            Token stopSymbol = getStopSymbol(context);
            if (startSymbol == null || stopSymbol == null) {
                return Interval.INVALID;
            }

            return new Interval(startSymbol.getStartIndex(), stopSymbol.getStopIndex());
        }
    } else {
        return Interval.INVALID;
    }
}

/**
 * Gets whether or not {@code a} starts after the start of {@code b}.
 *
 * @param a The first tree.
 * @param b The second tree.
 * @return {@code true} if {@code a} starts after the start of {@code b}, otherwise {@code false}.
 */
public static boolean startsAfterStartOf(@NonNull ParseTree a, @NonNull ParseTree b) {
    //TerminalNode<? extends Token> startNodeA = getStartNode(a);
    //TerminalNode<? extends Token> startNodeB = getStartNode(b);
    //if (startNodeA == null || startNodeB == null) {
    //    throw new NotImplementedException();
    //}

    Interval sourceIntervalA = a.getSourceInterval();
    Interval sourceIntervalB = b.getSourceInterval();

    //if (sourceIntervalA.a == sourceIntervalB.a) {
    //    if (isAncestorOf(a, b)) {
    //        return true;
    //    }
    //
    //    if (isEpsilon(a) || isEpsilon(b)) {
    //        // b could be a child of a later sibling of some ancestor of a
    //        throw new NotImplementedException();
    //    }
    //}

    return sourceIntervalA.a > sourceIntervalB.a;
}

@Override
public Object visitProcedureConst(ProcedureConstContext ctx) {

    Token startToken = ctx.getStart();
    Token stopToken = ctx.getStop();

    // we need skipped token, such as WhiteSpace
    String rawText = stopToken
            .getTokenSource()
            .getInputStream()
            .getText(
                    Interval.of(startToken.getStartIndex(),
                            stopToken.getStopIndex()));

    CreateObject ins = new CreateObject(ctx.start.getLine());

    ins.varName = getNextTempVar("link");
    ins.objType = ObjectType.PROCEDURE;
    ins.value = rawText;

    addInstruction(ins);
    return ins.varName;

}

public static boolean isOpNext(TokenStream tokens) {
    int start = tokens.index();
    Token lt = tokens.get(start);
    int stop = getLastOpTokenIndex(tokens);
    if ( stop==-1 ) return false;
    System.out.printf("isOpNext: i=%d t='%s'", start, lt.getText());
    System.out.printf(", op='%s'\n", tokens.getText(Interval.of(start,stop)));
    return true;
}

/**
 "If an operator has whitespace around both sides or around neither side,
 it is treated as a binary operator. As an example, the + operator in a+b
 and a + b is treated as a binary operator."
 */
public static boolean isBinaryOp(TokenStream tokens) {
    int stop = getLastOpTokenIndex(tokens);
    if ( stop==-1 ) return false;

    int start = tokens.index();
    Token prevToken = tokens.get(start-1); // includes hidden-channel tokens
    Token nextToken = tokens.get(stop+1);
    boolean prevIsWS = isLeftOperatorWS(prevToken);
    boolean nextIsWS = isRightOperatorWS(nextToken);
    boolean result = prevIsWS && nextIsWS || (!prevIsWS && !nextIsWS);
    String text = tokens.getText(Interval.of(start, stop));
    //System.out.println("isBinaryOp: '"+prevToken+"','"+text+"','"+nextToken+"' is "+result);
    return result;
}