/*Make sure current lookahead symbol matches the given set * Throw an exception upon mismatch, which is catch by either the * error handler or by the syntactic predicate. */ public virtual void match(AST t, BitSet b) { if (t == null || t == ASTNULL || !b.member(t.Type)) { throw new MismatchedTokenException(getTokenNames(), t, b, false); } }
/*Consume tokens until one matches the given token set */ public virtual void consumeUntil(BitSet bset) { while (LA(1) != Token.EOF_TYPE && !bset.member(LA(1))) { consume(); } }
/*Consume chars until one matches the given set */ public virtual void consumeUntil(BitSet bset) { while (cached_LA1 != EOF_CHAR && !bset.member(cached_LA1)) { consume(); } }
public virtual void match(BitSet b) { if (!b.member(cached_LA1)) { throw new MismatchedCharException(cached_LA1, b, false, this); } consume(); }
// Expected BitSet / not BitSet public MismatchedCharException(char c, BitSet set_, bool matchNot, CharScanner scanner_) : base("Mismatched char", scanner_.getFilename(), scanner_.getLine(), scanner_.getColumn()) { mismatchType = matchNot ? CharTypeEnum.NotSetType : CharTypeEnum.SetType; foundChar = c; bset = set_; scanner = scanner_; }
// Expected BitSet / not BitSet public MismatchedTokenException(string[] tokenNames_, IToken token_, BitSet set_, bool matchNot, string fileName_) : base("Mismatched Token", fileName_, token_.getLine(), token_.getColumn()) { tokenNames = tokenNames_; token = token_; tokenText = token_.getText(); mismatchType = matchNot ? TokenTypeEnum.NotSetType : TokenTypeEnum.SetType; bset = set_; }
/*Make sure current lookahead symbol matches the given set * Throw an exception upon mismatch, which is catch by either the * error handler or by the syntactic predicate. */ public virtual void match(BitSet b) { if (!b.member(LA(1))) { throw new MismatchedTokenException(tokenNames, LT(1), b, false, getFilename()); } else { consume(); } }
// Expected BitSet / not BitSet public MismatchedTokenException(string[] tokenNames_, AST node_, BitSet set_, bool matchNot) : base("Mismatched Token", "<AST>", -1, -1) { tokenNames = tokenNames_; node = node_; if (node_ == null) { tokenText = "<empty tree>"; } else { tokenText = node_.ToString(); } mismatchType = matchNot ? TokenTypeEnum.NotSetType : TokenTypeEnum.SetType; bset = set_; }
public virtual object Clone() { BitSet s; try { s = new BitSet(); s.dataBits = new long[dataBits.Length]; Array.Copy(dataBits, 0, s.dataBits, 0, dataBits.Length); } catch //(System.Exception e) { throw new System.ApplicationException(); } return s; }
public virtual void recover(RecognitionException ex, BitSet tokenSet) { consume(); consumeUntil(tokenSet); }
/*Make sure current lookahead symbol matches the given set * Throw an exception upon mismatch, which is catch by either the * error handler or by the syntactic predicate. */ public virtual void match(BitSet b) { if (!b.member(LA(1))) throw new MismatchedTokenException(tokenNames, LT(1), b, false, getFilename()); else consume(); }
public TokenStreamBasicFilter(TokenStream input) { this.input = input; discardMask = new BitSet(); }
public virtual void hide(BitSet mask) { hideMask = mask; }
// Expected BitSet / not BitSet public MismatchedTokenException(string[] tokenNames_, AST node_, BitSet set_, bool matchNot) : base("Mismatched Token", "<AST>", - 1, - 1) { tokenNames = tokenNames_; node = node_; if (node_ == null) { tokenText = "<empty tree>"; } else { tokenText = node_.ToString(); } mismatchType = matchNot ? TokenTypeEnum.NotSetType : TokenTypeEnum.SetType; bset = set_; }
public virtual void discard(BitSet mask) { discardMask = mask; }
public TokenStreamHiddenTokenFilter(TokenStream input) : base(input) { hideMask = new BitSet(); }
public static BitSet of(int el) { BitSet s = new BitSet(el + 1); s.add(el); return s; }
/*return this | a in a new set */ public virtual BitSet or(BitSet a) { BitSet s = (BitSet) this.Clone(); s.orInPlace(a); return s; }
public virtual void orInPlace(BitSet a) { // If this is smaller than a, grow this first if (a.dataBits.Length > dataBits.Length) { setSize((int) (a.dataBits.Length)); } int min = (int) (System.Math.Min(dataBits.Length, a.dataBits.Length)); for (int i = min - 1; i >= 0; i--) { dataBits[i] |= a.dataBits[i]; } }
/*Is this contained within a? */ public virtual bool subset(BitSet a) { if (a == null) //(a == null || !(a is BitSet)) return false; return this.and(a).Equals(this); }
/*Subtract the elements of 'a' from 'this' in-place. * Basically, just turn off all bits of 'this' that are in 'a'. */ public virtual void subtractInPlace(BitSet a) { if (a == null) return ; // for all words of 'a', turn off corresponding bits of 'this' for (int i = 0; i < dataBits.Length && i < a.dataBits.Length; i++) { dataBits[i] &= ~ a.dataBits[i]; } }
public virtual BitSet and(BitSet a) { BitSet s = (BitSet) this.Clone(); s.andInPlace(a); return s; }
public virtual void andInPlace(BitSet a) { int min = (int) (Math.Min(dataBits.Length, a.dataBits.Length)); for (int i = min - 1; i >= 0; i--) { dataBits[i] &= a.dataBits[i]; } // clear all bits in this not present in a (if this bigger than a). for (int i = min; i < dataBits.Length; i++) { dataBits[i] = 0; } }