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); } }