internal override BitSet Lastpos(int positions)
{
if (last == null)
{
last = new BitSet(positions);
last.Set(pos);
}
return(last);
}
internal override BitSet Firstpos(int positions)
{
if (first == null)
{
first = new BitSet(positions);
first.Set(pos);
}
return(first);
}
internal bool AddAllElement(XmlQualifiedName qname, bool required)
{
if (symbolTable[qname] == null)
{
int i = symbolTable.Count;
if (required)
{
allElementsSet.Set(i);
}
symbolTable.Add(qname, i);
symbols.Add(qname);
return(true);
}
else
{
return(false);
}
}
private BitSet[] CalculateTotalFollowposForRangeNodes(BitSet firstpos, BitSet[] followpos, out BitSet posWithRangeTerminals)
{
int count = this.positions.Count;
posWithRangeTerminals = new BitSet(count);
BitSet[] setArray = new BitSet[this.minMaxNodesCount];
int index = 0;
for (int i = count - 1; i >= 0; i--)
{
Position position = this.positions[i];
if (position.symbol == -2)
{
LeafRangeNode particle = position.particle as LeafRangeNode;
BitSet set = new BitSet(count);
set.Clear();
set.Or(followpos[i]);
if (particle.Min != particle.Max)
{
set.Or(particle.NextIteration);
}
for (int j = set.NextSet(-1); j != -1; j = set.NextSet(j))
{
if (j > i)
{
Position position2 = this.positions[j];
if (position2.symbol == -2)
{
LeafRangeNode node2 = position2.particle as LeafRangeNode;
set.Or(setArray[node2.Pos]);
}
}
}
setArray[index] = set;
particle.Pos = index++;
posWithRangeTerminals.Set(i);
}
}
return(setArray);
}
public override void ConstructPos(BitSet firstpos, BitSet lastpos, BitSet[] followpos)
{
firstpos.Set(this.pos);
lastpos.Set(this.pos);
}
private bool IsSequenceFromAll(XmlSchemaSequence derivedSequence, XmlSchemaAll baseAll)
{
if (!this.IsValidOccurrenceRangeRestriction(derivedSequence, baseAll) || (derivedSequence.Items.Count > baseAll.Items.Count))
{
return false;
}
BitSet set = new BitSet(baseAll.Items.Count);
for (int i = 0; i < derivedSequence.Items.Count; i++)
{
int mappingParticle = this.GetMappingParticle((XmlSchemaParticle) derivedSequence.Items[i], baseAll.Items);
if (mappingParticle < 0)
{
return false;
}
if (set[mappingParticle])
{
return false;
}
set.Set(mappingParticle);
}
for (int j = 0; j < baseAll.Items.Count; j++)
{
if (!set[j] && !this.IsParticleEmptiable((XmlSchemaParticle) baseAll.Items[j]))
{
return false;
}
}
return true;
}
private bool IsSequenceFromAll(XmlSchemaSequence derivedSequence, XmlSchemaAll baseAll) {
if (!IsValidOccurrenceRangeRestriction(derivedSequence, baseAll) || derivedSequence.Items.Count > baseAll.Items.Count) {
return false;
}
BitSet map = new BitSet(baseAll.Items.Count);
for (int j = 0; j < derivedSequence.Items.Count; ++j) {
int i = GetMappingParticle((XmlSchemaParticle)derivedSequence.Items[j], baseAll.Items);
if (i >= 0) {
if (map[i]) {
return false;
}
else {
map.Set(i);
}
}
else {
return false;
}
}
for (int i = 0; i < baseAll.Items.Count; i++) {
if (!map[i] && !IsParticleEmptiable((XmlSchemaParticle)baseAll.Items[i])) {
return false;
}
}
return true;
}
public override void ConstructPos(BitSet firstpos, BitSet lastpos, BitSet[] followpos) {
firstpos.Set(pos);
lastpos.Set(pos);
}
private BitSet[] CalculateTotalFollowposForRangeNodes(BitSet firstpos, BitSet[] followpos, out BitSet posWithRangeTerminals) {
int positionsCount = positions.Count; //terminals
posWithRangeTerminals = new BitSet(positionsCount);
//Compute followpos for each range node
//For any range node that is surrounded by an outer range node, its follow positions will include those of the outer range node
BitSet[] minmaxFollowPos = new BitSet[minMaxNodesCount];
int localMinMaxNodesCount = 0;
for (int i = positionsCount - 1; i >= 0; i--) {
Position p = positions[i];
if (p.symbol == -2) { //P is a LeafRangeNode
LeafRangeNode lrNode = p.particle as LeafRangeNode;
Debug.Assert(lrNode != null);
BitSet tempFollowPos = new BitSet(positionsCount);
tempFollowPos.Clear();
tempFollowPos.Or(followpos[i]); //Add the followpos of the range node
if (lrNode.Min != lrNode.Max) { //If they are the same, then followpos cannot include the firstpos
tempFollowPos.Or(lrNode.NextIteration); //Add the nextIteration of the range node (this is the firstpos of its parent's leftChild)
}
//For each position in the bitset, if it is a outer range node (pos > i), then add its followpos as well to the current node's followpos
for (int pos = tempFollowPos.NextSet(-1); pos != -1; pos = tempFollowPos.NextSet(pos)) {
if (pos > i) {
Position p1 = positions[pos];
if (p1.symbol == -2) {
LeafRangeNode lrNode1 = p1.particle as LeafRangeNode;
Debug.Assert(lrNode1 != null);
tempFollowPos.Or(minmaxFollowPos[lrNode1.Pos]);
}
}
}
//set the followpos built to the index in the BitSet[]
minmaxFollowPos[localMinMaxNodesCount] = tempFollowPos;
lrNode.Pos = localMinMaxNodesCount++;
posWithRangeTerminals.Set(i);
}
}
return minmaxFollowPos;
}
private BitSet[] CalculateTotalFollowposForRangeNodes(BitSet firstpos, BitSet[] followpos, out BitSet posWithRangeTerminals)
{
int count = this.positions.Count;
posWithRangeTerminals = new BitSet(count);
BitSet[] setArray = new BitSet[this.minMaxNodesCount];
int index = 0;
for (int i = count - 1; i >= 0; i--)
{
Position position = this.positions[i];
if (position.symbol == -2)
{
LeafRangeNode particle = position.particle as LeafRangeNode;
BitSet set = new BitSet(count);
set.Clear();
set.Or(followpos[i]);
if (particle.Min != particle.Max)
{
set.Or(particle.NextIteration);
}
for (int j = set.NextSet(-1); j != -1; j = set.NextSet(j))
{
if (j > i)
{
Position position2 = this.positions[j];
if (position2.symbol == -2)
{
LeafRangeNode node2 = position2.particle as LeafRangeNode;
set.Or(setArray[node2.Pos]);
}
}
}
setArray[index] = set;
particle.Pos = index++;
posWithRangeTerminals.Set(i);
}
}
return setArray;
}