Java IntSet类代码示例

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** Make a set label */
  public Label(IntSet labelSet) {
if ( labelSet==null ) {
	this.label = SET;
	this.labelSet = IntervalSet.of(INVALID);
	return;
}
int singleAtom = labelSet.getSingleElement();
      if ( singleAtom!=INVALID ) {
          // convert back to a single atomic element if |labelSet|==1
          label = singleAtom;
          return;
      }
      this.label = SET;
      this.labelSet = labelSet;
  }
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** From set build single edge graph o->o-set->o.  To conform to
    *  what an alt block looks like, must have extra state on left.
    */
public StateCluster build_Set(IntSet set) {
       //NFAState start = newState();
       NFAState left = newState();
       //transitionBetweenStates(start, left, Label.EPSILON);
       NFAState right = newState();
       Transition e = new Transition(new Label(set),right);
       left.addTransition(e);
	StateCluster g = new StateCluster(left, right);
       return g;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** Given a collapsed block of alts (a set of atoms), pull out
 *  the set and return it.
 */
protected IntSet getCollapsedBlockAsSet(State blk) {
    State s0 = blk;
    if ( s0!=null && s0.transition(0)!=null ) {
        State s1 = s0.transition(0).target;
        if ( s1!=null && s1.transition(0)!=null ) {
            Label label = s1.transition(0).label;
            if ( label.isSet() ) {
                return label.getSet();
            }
        }
    }
    return null;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
protected static Integer getTokenType(Label label) {
	if ( label.isSet() ) {
		// pick random element of set
		IntSet typeSet = label.getSet();
		List typeList = typeSet.toList();
		int randomIndex = random.nextInt(typeList.size());
		return (Integer)typeList.get(randomIndex);
	}
	else {
		return Utils.integer(label.getAtom());
	}
	//System.out.println(t0.label.toString(g));
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** Return a set of all possible token or char types for this grammar */
public IntSet getTokenTypes() {
	if ( type==LEXER ) {
		return getAllCharValues();
	}
	return IntervalSet.of(Label.MIN_TOKEN_TYPE, getMaxTokenType());
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** If there is a char vocabulary, use it; else return min to max char
 *  as defined by the target.  If no target, use max unicode char value.
 */
public IntSet getAllCharValues() {
	if ( charVocabulary!=null ) {
		return charVocabulary;
	}
	IntSet allChar = IntervalSet.of(Label.MIN_CHAR_VALUE, getMaxCharValue());
	return allChar;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** For lexer grammars, return everything in unicode not in set.
 *  For parser and tree grammars, return everything in token space
 *  from MIN_TOKEN_TYPE to last valid token type or char value.
 */
public IntSet complement(IntSet set) {
    //System.out.println("complement "+set.toString(this));
    //System.out.println("vocabulary "+getTokenTypes().toString(this));
    IntSet c = set.complement(getTokenTypes());
    //System.out.println("result="+c.toString(this));
    return c;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** Get the set equivalent (if any) of the indicated rule from this
 *  grammar.  Mostly used in the lexer to do ~T for some fragment rule
 *  T.  If the rule AST has a SET use that.  If the rule is a single char
 *  convert it to a set and return.  If rule is not a simple set (w/o actions)
 *  then return null.
 *  Rules have AST form:
 *
 *		^( RULE ID modifier ARG RET SCOPE block EOR )
 */
public IntSet getSetFromRule(TreeToNFAConverter nfabuilder, String ruleName)
	throws RecognitionException
{
	Rule r = getRule(ruleName);
	if ( r==null ) {
		return null;
	}
	IntSet elements = null;
	//System.out.println("parsed tree: "+r.tree.toStringTree());
    elements = nfabuilder.setRule(r.tree);
	//System.out.println("elements="+elements);
	return elements;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
public IntSet getSet() {
    if ( label!=SET ) {
        // convert single element to a set if they ask for it.
        return IntervalSet.of(label);
    }
    return labelSet;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
public boolean matches(IntSet set) {
	if ( isAtom() ) {
		return set.member(getAtom());
	}
	if ( isSet() ) {
		// matches if intersection non-nil
		return !getSet().and(set).isNil();
	}
	return false;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
/** From set build single edge graph o->o-set->o.  To conform to
    *  what an alt block looks like, must have extra state on left.
    */
public StateCluster build_Set(IntSet set, GrammarAST associatedAST) {
       NFAState left = newState();
       NFAState right = newState();
	left.associatedASTNode = associatedAST;
	right.associatedASTNode = associatedAST;
	Label label = new Label(set);
	Transition e = new Transition(label,right);
       left.addTransition(e);
	StateCluster g = new StateCluster(left, right);
       return g;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
public IntSet getSetValue() {
    return setValue;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
public void setSetValue(IntSet setValue) {
    this.setValue = setValue;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
protected LookaheadSet _LOOK(NFAState s) {
	if ( s.isAcceptState() ) {
		return new LookaheadSet(Label.EOR_TOKEN_TYPE);
	}

	if ( lookBusy.contains(s) ) {
		// return a copy of an empty set; we may modify set inline
		return new LookaheadSet();
	}
	lookBusy.add(s);
	Transition transition0 = s.transition(0);
	if ( transition0==null ) {
		return null;
	}

	if ( transition0.label.isAtom() ) {
		int atom = transition0.label.getAtom();
		if ( atom==Label.EOF ) {
			return LookaheadSet.EOF();
		}
		return new LookaheadSet(atom);
	}
	if ( transition0.label.isSet() ) {
		IntSet sl = transition0.label.getSet();
		LookaheadSet laSet = new LookaheadSet(sl);
		if ( laSet.member(Label.EOF) ) {
			laSet.remove(Label.EOF);
			laSet.hasEOF = true;
		}
		return laSet;
	}
       LookaheadSet tset = _LOOK((NFAState)transition0.target);
	if ( tset.member(Label.EOR_TOKEN_TYPE) ) {
		if ( transition0 instanceof RuleClosureTransition ) {
			// we called a rule that found the end of the rule.
			// That means the rule is nullable and we need to
			// keep looking at what follows the rule ref.  E.g.,
			// a : b A ; where b is nullable means that LOOK(a)
			// should include A.
			RuleClosureTransition ruleInvocationTrans =
				(RuleClosureTransition)transition0;
			// remove the EOR and get what follows
			tset.remove(Label.EOR_TOKEN_TYPE);
			LookaheadSet fset =
				_LOOK((NFAState)ruleInvocationTrans.getFollowState());
			tset.orInPlace(fset);
		}
	}

	Transition transition1 = s.transition(1);
	if ( transition1!=null ) {
		LookaheadSet tset1 = _LOOK((NFAState)transition1.target);
		tset.orInPlace(tset1);
	}
	return tset;
}
 

import org.antlr.misc.IntSet; //导入依赖的package包/类
public LookaheadSet(IntSet s) {
	this();
	tokenTypeSet.addAll(s);
}