public override TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
int counter = (commingFrom == Parent) ? 0 : (int)rangeNodeCounters[this] + 1;
if ((counter <= max) && LeftChild.CanAccept(node, isTerminal, namedTerminals)) {
rangeNodeCounters[this] = counter;
return LeftChild.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else if (min <= counter) {
Debug.Assert(Parent != null);
return Parent.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else {
return null;
}
}
private NamedNode NewNamedTerminal(Identifier name, Member mem, TypeNode type) {
NamedNode terminal = new NamedNode(name, mem, type);
terminal.Pos = namedTerminalsArray.Count;
namedTerminalsArray.Add(terminal);
if (name != Identifier.Empty) {
NamedNodeList list = (NamedNodeList)symbols[name.UniqueKey];
if (list == null) {
list = new NamedNodeList();
symbols[name.UniqueKey] = list;
}
terminal.Symbol = symbolCount;
symbolCount += list.Add(terminal);
}
return terminal;
}
internal override bool CanAccept(NamedNode node) {
return LeftChild.CanAccept(node) || (LeftChild.IsNullable && RightChild.CanAccept(node));
}
internal override bool CanAccept(NamedNode node) {
return LeftChild.CanAccept(node) || RightChild.CanAccept(node);
}
public override TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
Debug.Assert(false);
return null;
}
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 abstract TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters);
internal override bool CanAccept(NamedNode node) {
return child.CanAccept(node);
}
public bool AddElement(NamedNode node, bool isEmptiable) {
if (elements[node.Name.UniqueKey] != null) {
return false;
}
int i = elements.Count;
elements[node.Name.UniqueKey] = i;
namedNodes.Add(node);
if (!isEmptiable) {
isRequired.Set(i);
countRequired ++;
}
return true;
}
public abstract bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard);
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;
}
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[]));
}
public ParticleContentValidator(XmlSchemaContentType contentType, NamedNode[] namedTerminals, Hashtable symbols, InternalNode contentRoot, NamedNode endMarker, int symbolCount, Member mixed) : base(contentType, mixed) {
this.namedTerminals = namedTerminals;
this.symbols = symbols;
this.contentRoot = contentRoot;
this.endMarker = endMarker;
this.symbolCount = symbolCount;
}
internal override bool CanAccept(NamedNode node) {
return wildcard.Allows(node);
}
internal abstract bool CanAccept(NamedNode node);
public override TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
return child.Accept(node, commingFrom, isTerminal, namedTerminals, rangeNodeCounters);
}
internal bool CanAccept(NamedNode node, bool isTerminal, NamedNode[] namedTerminals) {
if (isTerminal) {
for (int i = 0; i < namedTerminals.Length; i++) {
if (Firstpos[i] && node.Equals(namedTerminals[i])) {
return true;
}
}
return false;
}
else {
return CanAccept(node); // Slowly run through
}
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
return LeftChild.CheckDeterministic(context, namedTerminals, out bitset, out wildcard);
}
public override bool CheckDeterministic(ValidationState context, NamedNode[] namedTerminals, out BitSet bitset, out SchemaNamespaceList wildcard) {
bitset = Firstpos;
wildcard = null;
return true;
}
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;
}
internal override bool CanAccept(NamedNode node) {
return this.name.Equals(name.UniqueKey);
}
public override TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
if (commingFrom == Parent) {
if (LeftChild.CanAccept(node, isTerminal, namedTerminals)) {
return LeftChild.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else if (LeftChild.IsNullable) {
commingFrom = LeftChild;
}
else {
return null; // no match
}
}
if (commingFrom == LeftChild) {
if (RightChild.CanAccept(node, isTerminal, namedTerminals)) {
return RightChild.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else if (RightChild.IsNullable) {
commingFrom = RightChild;
}
else {
return null; // no match
}
}
Debug.Assert(commingFrom == RightChild);
if (Parent != null) {
return Parent.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else {
return null;
}
}
public int Add(NamedNode node) {
foreach (NamedNode n in list) {
if (n.Equals(node))
return 0;
}
list.Add(node);
return 1;
}
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 TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
Debug.Assert(wildcard.Allows(node));
return this;
}
public override TerminalNode Accept(NamedNode node, ContentNode commingFrom, bool isTerminal, NamedNode[] namedTerminals, Hashtable rangeNodeCounters) {
if (LeftChild.CanAccept(node, isTerminal, namedTerminals)) {
return LeftChild.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
else {
Debug.Assert(Parent != null);
return Parent.Accept(node, this, isTerminal, namedTerminals, rangeNodeCounters);
}
}
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 bool Allows(NamedNode node) {
// Prefix has been resolved to the Namespace URI by now.
return Allows(node.Name.Prefix != null ? node.Name.Prefix.Name : "") &&
TypeMatches(node.TypeNode);
}
public ContentValidator Finish(ValidationState context, bool compile) {
Debug.Assert(contentType == XmlSchemaContentType.ElementOnly || contentType == XmlSchemaContentType.Mixed);
if (contentNode == null) {
if (contentType == XmlSchemaContentType.Mixed) {
string ctype = IsOpen ? "Any" : "TextOnly";
return IsOpen ? ContentValidator.Any :
new ContentValidator(XmlSchemaContentType.TextOnly, this.MixedMember);
}
else {
Debug.Assert(!IsOpen);
return ContentValidator.Empty;
}
}
// add end node
contentRoot = new SequenceNode(null,null);
contentNode.Parent = contentRoot;
contentRoot.LeftChild = contentNode;
endMarker = NewNamedTerminal(Identifier.Empty, null, null);
endMarker.Parent = contentRoot;
contentRoot.RightChild = endMarker;
namedTerminals = (NamedNode[])namedTerminalsArray.ToArray(typeof(NamedNode));
namedTerminalsArray = null;
contentRoot.ConstructPos(namedTerminals.Length);
// bugbug: I need to figure out how to get the real terminals
// back out of the state machine. Currently the state machine treats all terminals
// with the same name as the same terminal, which is not what I want. I need
// the NamedNode with the right member bindings.
if (canCompile && compile) {
return new CompiledParticleContentValidator(context, this.contentRoot, this.namedTerminals,
this.symbols, this.symbolCount, this.IsOpen, this.contentType, this.MixedMember, endMarker);
}
else {
Debug.Assert(!IsOpen); // only deal with compiled XDR open content model
return new ParticleContentValidator(this.contentType, this.namedTerminals, this.symbols,
this.contentRoot, this.endMarker, this.symbolCount, this.MixedMember);
}
}
