internal bool FindInvalidType (RdpNameClass nc, bool allowNsName)
{
RdpNameClassChoice choice = nc as RdpNameClassChoice;
if (choice != null)
return FindInvalidType (choice.LValue, allowNsName)
|| FindInvalidType (choice.RValue, allowNsName);
else if (nc is RdpAnyName)
return true;
else if (nc is RdpNsName && !allowNsName)
return true;
else
return false;
}
static void GetNameClassRepresentatives(
RdpNameClass n, Hashtable names)
{
if (n is RdpAnyName)
{
names [illegalQName] = illegalQName;
return;
}
RdpAnyNameExcept exc = n as RdpAnyNameExcept;
if (exc != null)
{
GetNameClassRepresentatives(exc.ExceptNameClass, names);
names [illegalQName] = illegalQName;
return;
}
RdpNsName ns = n as RdpNsName;
if (ns != null)
{
QName nn = new QName(String.Empty, ns.NamespaceURI);
names [nn] = nn;
return;
}
RdpNsNameExcept nse = n as RdpNsNameExcept;
if (nse != null)
{
GetNameClassRepresentatives(nse.ExceptNameClass, names);
QName nn = new QName(String.Empty, nse.NamespaceURI);
names [nn] = nn;
return;
}
RdpName name = n as RdpName;
if (name != null)
{
QName qname = new QName(name.LocalName, name.NamespaceURI);
names [qname] = qname;
return;
}
else
{
RdpNameClassChoice c = (RdpNameClassChoice)n;
GetNameClassRepresentatives(c.LValue, names);
GetNameClassRepresentatives(c.RValue, names);
return;
}
}
internal static bool NameClassOverlap(RdpNameClass n1, RdpNameClass n2)
{
Hashtable names = new Hashtable();
GetNameClassRepresentatives(n1, names);
GetNameClassRepresentatives(n2, names);
foreach (QName qn in names.Keys)
{
if (NameClassBothContain(n1, n2, qn))
{
return(true);
}
}
return(false);
}
internal static bool NameClassOverlap(RdpNameClass n1, RdpNameClass n2)
{
var names = new List <XmlQualifiedName> ();
GetNameClassRepresentatives(n1, names);
GetNameClassRepresentatives(n2, names);
foreach (QName qn in names)
{
if (NameClassBothContain(n1, n2, qn))
{
return(true);
}
}
return(false);
}
// Generating simplified pattern status (similar to XML representation).
#region Debug
private static string DebugNameClass (RdpNameClass n)
{
switch (n.NameClassType) {
case RdpNameClassType.Name:
RdpName nm = (RdpName)n;
return "<name ns='" + nm.NamespaceURI + "'>"
+ nm.LocalName + "</name>\n";
case RdpNameClassType.NsName:
return "<nsName ns='" + ((RdpNsName)n).NamespaceURI + "'/>\n";
case RdpNameClassType.NameClassChoice:
RdpNameClassChoice nc = (RdpNameClassChoice) n;
return "<choice>" + DebugNameClass (nc.LValue) + DebugNameClass (nc.RValue) + "</choice>";
default:
return "<" + n.NameClassType.ToString () + "/>\n";
}
}
// Generating simplified pattern status (similar to XML representation).
#region Debug
private static string DebugNameClass(RdpNameClass n)
{
switch (n.NameClassType)
{
case RdpNameClassType.Name:
RdpName nm = (RdpName)n;
return("<name ns='" + nm.NamespaceURI + "'>"
+ nm.LocalName + "</name>\n");
case RdpNameClassType.NsName:
return("<nsName ns='" + ((RdpNsName)n).NamespaceURI + "'/>\n");
case RdpNameClassType.NameClassChoice:
RdpNameClassChoice nc = (RdpNameClassChoice)n;
return("<choice>" + DebugNameClass(nc.LValue) + DebugNameClass(nc.RValue) + "</choice>");
default:
return("<" + n.NameClassType.ToString() + "/>\n");
}
}
// Name class analysis
static bool NamesOverlap(RdpPattern p1,
RdpNameClass n, bool checkElements)
{
RdpAbstractBinary bp1 = p1 as RdpAbstractBinary;
if (bp1 != null)
{
return(NamesOverlap(bp1.LValue, n, checkElements) ||
NamesOverlap(bp1.RValue, n, checkElements));
}
RdpOneOrMore rp1 = p1 as RdpOneOrMore;
if (rp1 != null)
{
return(NamesOverlap(rp1.Child, n, checkElements));
}
RdpAttribute ap1 = p1 as RdpAttribute;
if (ap1 != null)
{
return(NameClassOverlap(ap1.NameClass, n));
}
if (!checkElements)
{
return(false);
}
RdpElement ep1 = p1 as RdpElement;
if (ep1 != null)
{
return(NameClassOverlap(ep1.NameClass, n));
}
return(false);
}
static bool NameClassBothContain(
RdpNameClass n1, RdpNameClass n2, QName qn)
{
return(Contains(n1, qn.Name, qn.Namespace) &&
Contains(n2, qn.Name, qn.Namespace));
}
static void GetNameClassRepresentatives(
RdpNameClass n, IList <QName> names)
{
if (n is RdpAnyName)
{
if (!names.Contains(illegalQName))
{
names.Add(illegalQName);
}
return;
}
RdpAnyNameExcept exc = n as RdpAnyNameExcept;
if (exc != null)
{
GetNameClassRepresentatives(exc.ExceptNameClass, names);
if (!names.Contains(illegalQName))
{
names.Add(illegalQName);
}
return;
}
RdpNsName ns = n as RdpNsName;
if (ns != null)
{
QName nn = new QName(String.Empty, ns.NamespaceURI);
if (!names.Contains(nn))
{
names.Add(nn);
}
return;
}
RdpNsNameExcept nse = n as RdpNsNameExcept;
if (nse != null)
{
GetNameClassRepresentatives(nse.ExceptNameClass, names);
QName nn = new QName(String.Empty, nse.NamespaceURI);
if (!names.Contains(nn))
{
names.Add(nn);
}
return;
}
RdpName name = n as RdpName;
if (name != null)
{
QName qname = new QName(name.LocalName, name.NamespaceURI);
if (!names.Contains(qname))
{
names.Add(qname);
}
return;
}
else
{
RdpNameClassChoice c = (RdpNameClassChoice)n;
GetNameClassRepresentatives(c.LValue, names);
GetNameClassRepresentatives(c.RValue, names);
return;
}
}
public RdpNameClassChoice(RdpNameClass l, RdpNameClass r)
{
this.l = l;
this.r = r;
}
internal void AddNameLabel (LabelList names, RdpNameClass nc)
{
RdpName name = nc as RdpName;
if (name != null) {
XmlQualifiedName qname = new XmlQualifiedName (
name.LocalName, name.NamespaceURI);
names [qname] = qname;
return;
}
RdpNameClassChoice choice = nc as RdpNameClassChoice;
if (choice != null) {
AddNameLabel (names, choice.LValue);
AddNameLabel (names, choice.RValue);
return;
}
// For NsName and AnyName, do nothing.
}
public RdpAttribute (RdpNameClass nameClass, RdpPattern p)
{
this.nameClass = nameClass;
this.children = p;
}
static bool NameClassBothContain (
RdpNameClass n1, RdpNameClass n2, QName qn)
{
return Contains (n1, qn.Name, qn.Namespace) &&
Contains (n2, qn.Name, qn.Namespace);
}
static void GetNameClassRepresentatives (
RdpNameClass n, Hashtable names)
{
if (n is RdpAnyName) {
names [illegalQName] = illegalQName;
return;
}
RdpAnyNameExcept exc = n as RdpAnyNameExcept;
if (exc != null) {
GetNameClassRepresentatives (exc.ExceptNameClass, names);
names [illegalQName] = illegalQName;
return;
}
RdpNsName ns = n as RdpNsName;
if (ns != null) {
QName nn = new QName (String.Empty, ns.NamespaceURI);
names [nn] = nn;
return;
}
RdpNsNameExcept nse = n as RdpNsNameExcept;
if (nse != null) {
GetNameClassRepresentatives (nse.ExceptNameClass, names);
QName nn = new QName (String.Empty, nse.NamespaceURI);
names [nn] = nn;
return;
}
RdpName name = n as RdpName;
if (name != null) {
QName qname = new QName (name.LocalName, name.NamespaceURI);
names [qname] = qname;
return;
}
else {
RdpNameClassChoice c = (RdpNameClassChoice) n;
GetNameClassRepresentatives (c.LValue, names);
GetNameClassRepresentatives (c.RValue, names);
return;
}
}
internal static bool NameClassOverlap (RdpNameClass n1, RdpNameClass n2)
{
Hashtable names = new Hashtable ();
GetNameClassRepresentatives (n1, names);
GetNameClassRepresentatives (n2, names);
foreach (QName qn in names.Keys)
if (NameClassBothContain (n1, n2, qn))
return true;
return false;
}
// Name class analysis
static bool NamesOverlap (RdpPattern p1,
RdpNameClass n, bool checkElements)
{
RdpAbstractBinary bp1 = p1 as RdpAbstractBinary;
if (bp1 != null)
return NamesOverlap (bp1.LValue, n, checkElements)
|| NamesOverlap (bp1.RValue, n, checkElements);
RdpOneOrMore rp1 = p1 as RdpOneOrMore;
if (rp1 != null)
return NamesOverlap (rp1.Child, n, checkElements);
RdpAttribute ap1 = p1 as RdpAttribute;
if (ap1 != null)
return NameClassOverlap (ap1.NameClass, n);
if (!checkElements)
return false;
RdpElement ep1 = p1 as RdpElement;
if (ep1 != null)
return NameClassOverlap (ep1.NameClass, n);
return false;
}
// contains :: NameClass -> QName -> Bool
internal static bool Contains (RdpNameClass nc, string name, string ns)
{
return nc.Contains (name, ns);
}
public RdpAnyNameExcept(RdpNameClass except)
{
this.except = except;
}
public RdpNameClassChoice (RdpNameClass l, RdpNameClass r)
{
this.l = l;
this.r = r;
}
private void checkInvalidAttrNameClass (RdpNameClass nc)
{
string xmlnsNS = "http://www.w3.org/2000/xmlns";
RdpNameClassChoice choice = nc as RdpNameClassChoice;
if (choice != null) {
checkInvalidAttrNameClass (choice.LValue);
checkInvalidAttrNameClass (choice.RValue);
return;
}
RdpAnyNameExcept except = nc as RdpAnyNameExcept;
if (except != null) {
checkInvalidAttrNameClass (except.ExceptNameClass);
return;
}
if (nc is RdpAnyName)
return;
RdpName n = nc as RdpName;
if (n != null) {
if (n.NamespaceURI == xmlnsNS)
throw new RelaxngException (this, "cannot specify \"" + xmlnsNS + "\" for name of attribute.");
if (n.LocalName == "xmlns" && n.NamespaceURI == "")
throw new RelaxngException (this, "cannot specify \"xmlns\" inside empty ns context.");
} else {
RdpNsName nn = nc as RdpNsName;
if (nn.NamespaceURI == "http://www.w3.org/2000/xmlns")
throw new RelaxngException (this, "cannot specify \"" + xmlnsNS + "\" for name of attribute.");
RdpNsNameExcept x = nc as RdpNsNameExcept;
if (x != null)
checkInvalidAttrNameClass (x.ExceptNameClass);
}
}
public RdpAnyNameExcept (RdpNameClass except)
{
this.except = except;
}
public RdpElement (RdpNameClass nameClass, RdpPattern p)
{
this.nameClass = nameClass;
this.children = p;
}
// contains :: NameClass -> QName -> Bool
internal static bool Contains(RdpNameClass nc, string name, string ns)
{
return(nc.Contains(name, ns));
}
public RdpNsNameExcept (string ns, RdpNameClass except)
: base (ns)
{
this.ns = ns;
this.except = except;
}
public RdpNsNameExcept(string ns, RdpNameClass except)
: base(ns)
{
this.ns = ns;
this.except = except;
}
