public override void CalcFollowpos(BitSet[] followpos) {
LeftChild.CalcFollowpos(followpos);
int length = followpos.Length;
for (int i = length - 1; i >= 0; i--) {
if (Lastpos.Get(i)) {
followpos[i].Or(Firstpos);
}
}
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
BitSet lset = null, rset = null; bitset = null; wildcard = null;
SchemaNamespaceList lany = null, rany = null;
if (!LeftChild.CheckDeterministic(context, namedTerminals, out lset, out lany))
return false;
if (!RightChild.CheckDeterministic(context, namedTerminals, out rset, out rany))
return false;
return Join(context, namedTerminals, lset, lany, rset, rany, out bitset, out wildcard);
}
public override void CalcFollowpos(BitSet[] followpos) {
LeftChild.CalcFollowpos(followpos);
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
bitset = null; BitSet lset = null, rset = null; wildcard = null;
SchemaNamespaceList lany = null, rany = null;
if (!LeftChild.CheckDeterministic(context, namedTerminals, out lset, out lany))
return false;
if (!RightChild.CheckDeterministic(context, namedTerminals, out rset, out rany))
return false;
if (LeftChild.HasRange || LeftChild.IsNullable) {
return Join(context, namedTerminals, lset, lany, rset, rany, out bitset, out wildcard);
}
else {
bitset = lset;
wildcard = lany;
}
return true;
}
public override void CalcFollowpos(BitSet[] followpos) {
LeftChild.CalcFollowpos(followpos);
RightChild.CalcFollowpos(followpos);
int length = followpos.Length;
BitSet Lastpos = LeftChild.Lastpos;
BitSet Firstpos = RightChild.Firstpos;
for (int i = length - 1; i >= 0; i--) {
if (Lastpos[i]) {
followpos[i].Or(Firstpos);
}
}
}
public void Or(BitSet other) {
if (this == other) {
return;
}
int setLength = other.bits.Length;
EnsureLength(setLength);
for (int i = setLength; i-- > 0 ;) {
bits[i] |= other.bits[i];
}
}
private bool CheckDeterministic(BitSet bitset, NamedNode[] namedTerminals, ValidationState context) {
TrivialHashtable nodeTable = new TrivialHashtable();
for (int i = 0; i < namedTerminals.Length; i++) {
if (bitset[i]) {
NamedNode node = namedTerminals[i];
Identifier n = node.Name;
if (n != Identifier.Empty) {
if (nodeTable[n.UniqueKey] == null) {
nodeTable[n.UniqueKey] = n;
}
else {
Node offendingNode = (node.Member is Method) ? node.Name : node.Member.Name;
context.HandleError(this.RootNode, offendingNode, Error.NonDeterministic, context.Name.ToString(), n.Name.ToString());
return false;
}
}
}
}
return true;
}
public override void ConstructPos(int terminalsCount) {
Firstpos = new BitSet(terminalsCount);
Lastpos = new BitSet(terminalsCount);
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
bitset = null;
wildcard = this.wildcard;
wildcard.AddType(this.TypeNode);
return true;
}
public override void CalcFollowpos(BitSet[] followpos) {
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
bitset = Firstpos;
wildcard = null;
return true;
}
public abstract bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard);
public abstract void CalcFollowpos(BitSet[] followpos);
public AllElementsContentValidator(Member mixed, int size, bool isEmptiable) : base(mixed == null ? XmlSchemaContentType.ElementOnly : XmlSchemaContentType.Mixed, mixed) {
elements = new TrivialHashtable(size);
isRequired = new BitSet(size);
namedNodes = new ArrayList();
this.isEmptiable = isEmptiable;
}
public override void CalcFollowpos(BitSet[] followpos) {
// todo: error handling
throw new Exception("Res.Xml_InternalError, string.Empty");
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
return LeftChild.CheckDeterministic(context, namedTerminals, out bitset, out wildcard);
}
public void And(BitSet other) {
/*
* Need to synchronize both this and other->
* This might lead to deadlock if one thread grabs them in one order
* while another thread grabs them the other order.
* Use a trick from Doug Lea's book on concurrency,
* somewhat complicated because BitSet overrides hashCode().
*/
if (this == other) {
return;
}
int bitsLength = bits.Length;
int setLength = other.bits.Length;
int n = (bitsLength > setLength) ? setLength : bitsLength;
for (int i = n ; i-- > 0 ;) {
bits[i] &= other.bits[i];
}
for (; n < bitsLength ; n++) {
bits[n] = 0;
}
}
protected bool Join(ValidationState context, NamedNode[] namedTerminals, BitSet lset, SchemaNamespaceList lany, BitSet rset, SchemaNamespaceList rany, out BitSet bitset, out SchemaNamespaceList wildcard) {
wildcard = null;
if (lset != null) {
if (rset != null) {
bitset = lset.Clone();
bitset.And(rset);
if (!bitset.IsEmpty) {
Identifier id = (context.Name == null) ? Identifier.Empty : context.Name;
context.HandleError(this, id, Error.NonDeterministicAny, id.ToString());
return false;
}
bitset.Or(lset);
bitset.Or(rset);
}
else {
bitset = lset;
}
}
else {
bitset = rset;
}
if (lany != null) {
if (rany != null) {
SchemaNamespaceList list = SchemaNamespaceList.Intersection(rany, lany);
if (list == null || list.IsEmpty()) {
wildcard = SchemaNamespaceList.Union(rany, lany);
}
else {
Identifier id = (context.Name == null) ? Identifier.Empty : context.Name;
context.HandleError(this, id, Error.NonDeterministicAny, id.ToString());
return false;
}
}
else {
wildcard = lany;
}
}
else {
wildcard = rany;
}
if (wildcard != null && bitset != null) {
for (int i = 0; i < bitset.Count; i++) {
NamedNode node = namedTerminals[i];
if (bitset.Get(i) && wildcard.Allows(node)) {
Identifier id = (context.Name == null ? node.Name : context.Name);
context.HandleError(this, id, Error.NonDeterministicAny, id.ToString());
return false;
}
}
}
return true;
}
public BitSet Clone() {
BitSet newset = new BitSet();
newset.count = count;
newset.bits = (int[])bits.Clone();
return newset;
}
internal CompiledParticleContentValidator(ValidationState context, InternalNode contentRoot, NamedNode[] namedTerminals, Hashtable symbols, int symCount, bool isOpen, XmlSchemaContentType contentType, Member mixed, NamedNode endMarker)
: base(contentType, namedTerminals, symbols, contentRoot, endMarker, symCount, mixed) {
// keep these
this.isOpen = isOpen;
this.isEmptiable = contentRoot.LeftChild.IsNullable;
int terminalsCount = namedTerminals.Length;
int endMarkerPos = terminalsCount - 1;
// calculate followpos
BitSet[] followpos = new BitSet[terminalsCount];
for (int i = 0; i < terminalsCount; i++) {
followpos[i] = new BitSet(terminalsCount);
}
contentRoot.CalcFollowpos(followpos);
// transition table
ArrayList transitionTable = new ArrayList();
// state lookup table
Hashtable stateTable = new Hashtable();
// lists unmarked states
ArrayList unmarked = new ArrayList();
stateTable.Add(new BitSet(terminalsCount), -1); // add empty
// start with firstpos at the root
BitSet firstpos = contentRoot.Firstpos;
stateTable.Add(firstpos, 0);
unmarked.Add(firstpos);
int[] a = new int[symbolCount + 1];
transitionTable.Add(a);
if (firstpos[endMarkerPos]) {
a[symbolCount] = 1; // accepting
}
// current state processed
int state = 0;
// check all unmarked states
while (unmarked.Count > 0) {
int[] t = (int[])transitionTable[state];
firstpos = (BitSet)unmarked[0];
if (!isNonDeterministic && !CheckDeterministic(firstpos, namedTerminals, context)) {
isNonDeterministic = true;
}
unmarked.RemoveAt(0);
// check all input symbols
foreach (NamedNodeList list in symbols.Values){
foreach (NamedNode node in list) {
BitSet newset = new BitSet(terminalsCount);
// if symbol is in the set add followpos to new set
for (int i = 0; i < terminalsCount; i++) {
if (firstpos[i] && node == namedTerminals[i]) {
newset.Or(followpos[i]);
}
}
object lookup = stateTable[newset];
// this state will transition to
int transitionTo;
// if new set is not in states add it
if (lookup == null) {
transitionTo = stateTable.Count - 1;
stateTable.Add(newset, transitionTo);
unmarked.Add(newset);
a = new int[symbolCount + 1];
transitionTable.Add(a);
if (newset[endMarkerPos]) {
a[symbolCount] = 1; // accepting
}
}
else {
transitionTo = (int)lookup;
}
// set the transition for the symbol
t[node.Symbol] = transitionTo;
}
}
state++;
}
// now convert transition table to array
this.transitionTable = (int[][])transitionTable.ToArray(typeof(int[]));
}
