Refine search
protected void reportMissingToken(final Parser recognizer) { if (!this.inErrorRecoveryMode(recognizer)) { this.beginErrorCondition(recognizer); final Token t = recognizer.getCurrentToken(); final IntervalSet expecting = this.getExpectedTokens(recognizer); final String msg = "missing " + expecting.toString(recognizer.getVocabulary()) + " at " + this .getTokenErrorDisplay(t); recognizer.notifyErrorListeners(t, msg, (RecognitionException) null); } } }
candidates.putAll(tokenIndex, getTokenNames(IntervalSet.of(Token.EOF))); labels = labels.complement(IntervalSet.of(Token.MIN_USER_TOKEN_TYPE, atn.maxTokenType)); if (labels.contains(currentToken)) { activeStates.add(new ParsingState(transition.target, tokenIndex + 1, caller));
Interval theirs = theirIntervals.get(j); if ( mine.startsBeforeDisjoint(theirs) ) { else if ( theirs.startsBeforeDisjoint(mine) ) { else if ( mine.properlyContains(theirs) ) { intersection = new IntervalSet(); intersection.add(mine.intersection(theirs)); j++; intersection = new IntervalSet(); intersection.add(mine.intersection(theirs)); i++; intersection = new IntervalSet(); intersection.add(mine.intersection(theirs)); return new IntervalSet();
/** Create a set with all ints within range [a..b] (inclusive) */ public static IntervalSet of(int a, int b) { IntervalSet s = new IntervalSet(); s.add(a,b); return s; }
/** combine all sets in the array returned the or'd value */ public static IntervalSet or(IntervalSet[] sets) { IntervalSet r = new IntervalSet(); for (IntervalSet s : sets) r.addAll(s); return r; }
protected int getAltThatFinishedDecisionEntryRule(ATNConfigSet configs) { IntervalSet alts = new IntervalSet(); for (ATNConfig c : configs) { if ( c.getOuterContextDepth()>0 || (c.state instanceof RuleStopState && c.context.hasEmptyPath()) ) { alts.add(c.alt); } } if ( alts.size()==0 ) return ATN.INVALID_ALT_NUMBER; return alts.getMinElement(); }
IntervalSet setTransitions = new IntervalSet(); for (int i = 0; i < decision.getNumberOfTransitions(); i++) { Transition epsTransition = decision.transition(i); || transition instanceof SetTransition) setTransitions.add(i); for (int i = setTransitions.getIntervals().size() - 1; i >= 0; i--) { Interval interval = setTransitions.getIntervals().get(i); if (interval.length() <= 1) { continue; IntervalSet matchSet = new IntervalSet(); for (int j = interval.a; j <= interval.b; j++) { Transition matchTransition = decision.transition(j).target.transition(0); throw new UnsupportedOperationException("Not yet implemented."); } else { matchSet.addAll(matchTransition.label()); if (matchSet.getIntervals().size() == 1) { if (matchSet.size() == 1) { newTransition = new AtomTransition(blockEndState, matchSet.getMinElement()); } else { Interval matchInterval = matchSet.getIntervals().get(0); newTransition = new RangeTransition(blockEndState, matchInterval.a, matchInterval.b);
/** Add interval; i.e., add all integers from a to b to set. * If b<a, do nothing. * Keep list in sorted order (by left range value). * If overlap, combine ranges. For example, * If this is {1..5, 10..20}, adding 6..7 yields * {1..5, 6..7, 10..20}. Adding 4..8 yields {1..8, 10..20}. */ public void add(int a, int b) { add(Interval.of(a, b)); }
if (left == null || left.isNil()) { return new IntervalSet(); IntervalSet result = new IntervalSet(left); if (right == null || right.isNil()) { Interval afterCurrent = null; if (rightInterval.a > resultInterval.a) { beforeCurrent = new Interval(resultInterval.a, rightInterval.a - 1); afterCurrent = new Interval(rightInterval.b + 1, resultInterval.b);
look.add(Token.EPSILON); return; look.add(Token.EOF); return; look.add(Token.EPSILON); return; look.add(Token.EOF); return; look.add(HIT_PRED); look.addAll( IntervalSet.of(Token.MIN_USER_TOKEN_TYPE, atn.maxTokenType) ); if (set != null) { if (t instanceof NotSetTransition) { set = set.complement(IntervalSet.of(Token.MIN_USER_TOKEN_TYPE, atn.maxTokenType)); look.addAll(set);
look[alt] = new IntervalSet(); Set<ATNConfig> lookBusy = new HashSet<ATNConfig>(); boolean seeThruPreds = false; // fail to get lookahead upon pred if ( look[alt].size()==0 || look[alt].contains(HIT_PRED) ) { look[alt] = null;
public IntervalSet complement(int minElement, int maxElement) { return this.complement(IntervalSet.of(minElement,maxElement)); }
IntervalSet expecting = getExpectedTokens(recognizer); int expectedTokenType = Token.INVALID_TYPE; if ( !expecting.isNil() ) { expectedTokenType = expecting.getMinElement(); // get any element
lastErrorStates.contains(recognizer.getState()) ) { if ( lastErrorStates==null ) lastErrorStates = new IntervalSet(); lastErrorStates.add(recognizer.getState()); IntervalSet followSet = getErrorRecoverySet(recognizer); consumeUntil(recognizer, followSet);
@Override public IntervalSet subtract(IntSet a) { if (a == null || a.isNil()) { return new IntervalSet(this); } if (a instanceof IntervalSet) { return subtract(this, (IntervalSet)a); } IntervalSet other = new IntervalSet(); other.addAll(a); return subtract(this, other); }
protected IntervalSet getErrorRecoverySet(Parser recognizer) { ATN atn = recognizer.getInterpreter().atn; RuleContext ctx = recognizer._ctx; IntervalSet recoverSet = new IntervalSet(); while ( ctx!=null && ctx.invokingState>=0 ) { // compute what follows who invoked us ATNState invokingState = atn.states.get(ctx.invokingState); RuleTransition rt = (RuleTransition)invokingState.transition(0); IntervalSet follow = atn.nextTokens(rt.followState); recoverSet.addAll(follow); ctx = ctx.parent; } recoverSet.remove(Token.EPSILON); // System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames())); return recoverSet; }
ATNState state = recognizer.getInterpreter().atn.states.get(recognizer.getState()); IntervalSet nextTokens = recognizer.getATN().nextTokens(state); if (nextTokens.contains(token.getType())) { nextTokensContext = null; nextTokensState = ATNState.INVALID_STATE_NUMBER; return; if (nextTokens.contains(Token.EPSILON)) { if (null == nextTokensContext) { nextTokensContext = recognizer.getContext(); if (nextTokens.contains(identifierTokenIndex)) { ((CommonToken) token).setType(identifierTokenIndex);
public SetTransition(ATNState target, IntervalSet set) { super(target); if ( set == null ) set = IntervalSet.of(Token.INVALID_TYPE); this.set = set; }
public static String getIntervalSetEscapedString(IntervalSet intervalSet) { StringBuilder buf = new StringBuilder(); Iterator<Interval> iter = intervalSet.getIntervals().iterator(); while (iter.hasNext()) { Interval interval = iter.next(); buf.append(getRangeEscapedString(interval.a, interval.b)); if (iter.hasNext()) { buf.append(" | "); } } return buf.toString(); }
boolean containsEof = set.contains(Token.EOF); if (containsEof && set.getIntervals().get(0).b == Token.EOF) { data.add(set.getIntervals().size() - 1); data.add(set.getIntervals().size()); for (Interval I : set.getIntervals()) { if (I.a == Token.EOF) { if (I.b == Token.EOF) {