//* // * Checks if another look-ahead set has an overlapping token // * sequence. An overlapping token sequence is a token sequence // * that is identical to another sequence, but for the length. // * I.e. one of the two sequences may be longer than the other. // * // * @param set the look-ahead set to check // * // * @return true if there is some token sequence that overlaps, or // * false otherwise // public bool IsOverlap(LookAheadSet @set) { for (int i = 0; i <= elements.Count - 1; i++) { if (@set.IsOverlap((Sequence)elements[i])) { return(true); } } return(false); }
//* // * Creates a new look-ahead set with overlaps from another. All // * token sequences in this set that overlaps with the other set // * will be added to the new look-ahead set. // * // * @param set the look-ahead set to check with // * // * @return a new look-ahead set containing the overlaps // public LookAheadSet CreateOverlaps(LookAheadSet @set) { LookAheadSet result = new LookAheadSet(maxLength); Sequence seq = default(Sequence); for (int i = 0; i <= elements.Count - 1; i++) { seq = (Sequence)elements[i]; if (@set.IsOverlap(seq)) { result.Add(seq); } } return(result); }
//* // * Finds the look-ahead set for a production pattern alternative. // * The pattern position and maximum look-ahead length must be // * specified. It is also possible to specify a look-ahead set // * filter, which will make sure that unnecessary token sequences // * will be avoided. // * // * @param alt the production pattern alternative // * @param length the maximum look-ahead length // * @param pos the pattern element position // * @param stack the call stack used for loop detection // * @param filter the look-ahead set filter // * // * @return the look-ahead set for the pattern alternative // * // * @throws ParserCreationException if an infinite loop was found // * in the grammar // private LookAheadSet FindLookAhead(ProductionPatternAlternative alt, int length, int pos, CallStack stack, LookAheadSet filter) { LookAheadSet first = default(LookAheadSet); LookAheadSet follow = default(LookAheadSet); LookAheadSet overlaps = default(LookAheadSet); // Check trivial cases if (length <= 0 || pos >= alt.Count) { return(new LookAheadSet(0)); } // Find look-ahead for this element first = FindLookAhead(alt[pos], length, stack, filter); if (alt[pos].MinCount == 0) { first.AddEmpty(); } // Find remaining look-ahead if (filter == null) { length -= first.GetMinLength(); if (length > 0) { follow = FindLookAhead(alt, length, pos + 1, stack, null); first = first.CreateCombination(follow); } } else if (filter.IsOverlap(first)) { overlaps = first.CreateOverlaps(filter); length -= overlaps.GetMinLength(); filter = filter.CreateFilter(overlaps); follow = FindLookAhead(alt, length, pos + 1, stack, filter); first.RemoveAll(overlaps); first.AddAll(overlaps.CreateCombination(follow)); } return(first); }
//* // * Finds the look-ahead set for a production pattern element. The // * maximum look-ahead length must be specified. This method takes // * the element repeats into consideration when creating the // * look-ahead set, but does NOT include an empty sequence even if // * the minimum count is zero (0). It is also possible to specify a // * look-ahead set filter, which will make sure that unnecessary // * token sequences will be avoided. // * // * @param elem the production pattern element // * @param length the maximum look-ahead length // * @param stack the call stack used for loop detection // * @param filter the look-ahead set filter // * // * @return the look-ahead set for the pattern element // * // * @throws ParserCreationException if an infinite loop was found // * in the grammar // private LookAheadSet FindLookAhead(ProductionPatternElement elem, int length, CallStack stack, LookAheadSet filter) { LookAheadSet result = default(LookAheadSet); LookAheadSet first = default(LookAheadSet); LookAheadSet follow = default(LookAheadSet); int max = 0; // Find initial element look-ahead first = FindLookAhead(elem, length, 0, stack, filter); result = new LookAheadSet(length); result.AddAll(first); if (filter == null || !filter.IsOverlap(result)) { return(result); } // Handle element repetitions if (elem.MaxCount == Int32.MaxValue) { first = first.CreateRepetitive(); } max = elem.MaxCount; if (length < max) { max = length; } for (int i = 1; i <= max - 1; i++) { first = first.CreateOverlaps(filter); if (first.Size() <= 0 || first.GetMinLength() >= length) { break; // TODO: might not be correct. Was : Exit For } follow = FindLookAhead(elem, length, 0, stack, filter.CreateFilter(first)); first = first.CreateCombination(follow); result.AddAll(first); } return(result); }