/**
* Creates a new look-ahead set filter. The filter will contain
* all sequences from this set, possibly left trimmed by each one
* of the sequences in the specified set.
*
* @param set the look-ahead set to trim with
*
* @return a new look-ahead set filter
*/
public LookAheadSet CreateFilter(LookAheadSet set)
{
LookAheadSet result = new LookAheadSet(maxLength);
Sequence first;
Sequence second;
// Handle special cases
if (this.Size() <= 0 || set.Size() <= 0)
{
return(this);
}
// Create combinations
for (int i = 0; i < elements.Count; i++)
{
first = (Sequence)elements[i];
for (int j = 0; j < set.elements.Count; j++)
{
second = (Sequence)set.elements[j];
if (first.StartsWith(second))
{
result.Add(first.Subsequence(second.Length()));
}
}
}
return(result);
}
/**
* Finds the look-ahead set for a production pattern element. The
* maximum look-ahead length must be specified. This method does
* NOT take the element repeat into consideration when creating
* the look-ahead set. 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 dummy a parameter to distinguish the method
* @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,
int dummy,
CallStack stack,
LookAheadSet filter)
{
LookAheadSet result;
ProductionPattern pattern;
if (elem.IsToken())
{
result = new LookAheadSet(length);
result.Add(elem.Id);
}
else
{
pattern = GetPattern(elem.Id);
result = FindLookAhead(pattern, length, stack, filter);
if (stack.Contains(pattern.Name))
{
result = result.CreateRepetitive();
}
}
return(result);
}
/**
* Creates a new identical look-ahead set, except for the
* repeat flag being set in each token sequence.
*
* @return a new repetitive look-ahead set
*/
public LookAheadSet CreateRepetitive()
{
LookAheadSet result = new LookAheadSet(maxLength);
Sequence seq;
for (int i = 0; i < elements.Count; i++)
{
seq = (Sequence)elements[i];
if (seq.IsRepetitive())
{
result.Add(seq);
}
else
{
result.Add(new Sequence(true, seq));
}
}
return(result);
}
/**
* Creates a new look-ahead set that is the intersection of
* this set with another set. The token sequences in the net
* set will only have the repeat flag set if it was set in
* both the identical token sequences.
*
* @param set the set to intersect with
*
* @return a new look-ahead set containing the intersection
*/
public LookAheadSet CreateIntersection(LookAheadSet set)
{
LookAheadSet result = new LookAheadSet(maxLength);
Sequence seq1;
Sequence seq2;
for (int i = 0; i < elements.Count; i++)
{
seq1 = (Sequence)elements[i];
seq2 = set.FindSequence(seq1);
if (seq2 != null && seq1.IsRepetitive())
{
result.Add(seq2);
}
else if (seq2 != null)
{
result.Add(seq1);
}
}
return(result);
}
/**
* Creates a new look-ahead set that is the combination of
* this set with another set. The combination is created by
* creating new token sequences that consist of appending all
* elements from the specified set onto all elements in this
* set. This is sometimes referred to as the cartesian
* product.
*
* @param set the set to combine with
*
* @return a new look-ahead set containing the combination
*/
public LookAheadSet CreateCombination(LookAheadSet set)
{
LookAheadSet result = new LookAheadSet(maxLength);
Sequence first;
Sequence second;
// Handle special cases
if (this.Size() <= 0)
{
return(set);
}
else if (set.Size() <= 0)
{
return(this);
}
// Create combinations
for (int i = 0; i < elements.Count; i++)
{
first = (Sequence)elements[i];
if (first.Length() >= maxLength)
{
result.Add(first);
}
else if (first.Length() <= 0)
{
result.AddAll(set);
}
else
{
for (int j = 0; j < set.elements.Count; j++)
{
second = (Sequence)set.elements[j];
result.Add(first.Concat(maxLength, second));
}
}
}
return(result);
}
/**
* 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;
for (int i = 0; i < elements.Count; i++)
{
seq = (Sequence)elements[i];
if (set.IsOverlap(seq))
{
result.Add(seq);
}
}
return(result);
}
/**
* Creates a new look-ahead set that is the result of reading
* the specified token. The new look-ahead set will contain
* the rest of all the token sequences that started with the
* specified token.
*
* @param token the token to read
*
* @return a new look-ahead set containing the remaining tokens
*/
public LookAheadSet CreateNextSet(int token)
{
LookAheadSet result = new LookAheadSet(maxLength - 1);
Sequence seq;
object value;
for (int i = 0; i < elements.Count; i++)
{
seq = (Sequence)elements[i];
value = seq.GetToken(0);
if (value != null && token == (int)value)
{
result.Add(seq.Subsequence(1));
}
}
return(result);
}