internal SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, ref bool skip)
{
AttributeMatchState attributeMatchState;
SchemaAttDef attDef = GetAttributeXsd(ed, qname, null, out attributeMatchState);
switch (attributeMatchState)
{
case AttributeMatchState.UndeclaredAttribute:
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
case AttributeMatchState.ProhibitedAnyAttribute:
case AttributeMatchState.ProhibitedAttribute:
throw new XmlSchemaException(Res.Sch_ProhibitedAttribute, qname.ToString());
case AttributeMatchState.AttributeFound:
case AttributeMatchState.AnyIdAttributeFound:
case AttributeMatchState.AnyAttributeLax:
case AttributeMatchState.UndeclaredElementAndAttribute:
break;
case AttributeMatchState.AnyAttributeSkip:
skip = true;
break;
default:
Debug.Assert(false);
break;
}
return(attDef);
}
public static SchemaElementDecl CreateAnyTypeElementDecl() {
SchemaElementDecl anyTypeElementDecl = new SchemaElementDecl();
anyTypeElementDecl.Content = new CompiledContentModel(null);
anyTypeElementDecl.Content.ContentType = CompiledContentModel.Type.Any;
anyTypeElementDecl.Datatype = XmlSchemaDatatype.AnyType;
return anyTypeElementDecl;
}
internal SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, ref bool skip)
{
AttributeMatchState state;
SchemaAttDef def = this.GetAttributeXsd(ed, qname, null, out state);
switch (state)
{
case AttributeMatchState.AttributeFound:
case AttributeMatchState.AnyIdAttributeFound:
case AttributeMatchState.UndeclaredElementAndAttribute:
case AttributeMatchState.AnyAttributeLax:
return(def);
case AttributeMatchState.UndeclaredAttribute:
throw new XmlSchemaException("Sch_UndeclaredAttribute", qname.ToString());
case AttributeMatchState.AnyAttributeSkip:
skip = true;
return(def);
case AttributeMatchState.ProhibitedAnyAttribute:
case AttributeMatchState.ProhibitedAttribute:
throw new XmlSchemaException("Sch_ProhibitedAttribute", qname.ToString());
}
return(def);
}
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.SetQualifiedName(DatatypeImplementation.QnAnyType);
XmlSchemaAny item = new XmlSchemaAny {
MinOccurs = 0M,
MaxOccurs = 79228162514264337593543950335M,
ProcessContents = processContents
};
item.BuildNamespaceList(null);
XmlSchemaSequence sequence = new XmlSchemaSequence();
sequence.Items.Add(item);
type.SetContentTypeParticle(sequence);
type.SetContentType(XmlSchemaContentType.Mixed);
type.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
type.ElementDecl.SchemaType = type;
ParticleContentValidator validator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
validator.Start();
validator.OpenGroup();
validator.AddNamespaceList(item.NamespaceList, item);
validator.AddStar();
validator.CloseGroup();
ContentValidator validator2 = validator.Finish(true);
type.ElementDecl.ContentValidator = validator2;
XmlSchemaAnyAttribute attribute = new XmlSchemaAnyAttribute {
ProcessContents = processContents
};
attribute.BuildNamespaceList(null);
type.SetAttributeWildcard(attribute);
type.ElementDecl.AnyAttribute = attribute;
return type;
}
private SchemaElementDecl ThoroughGetElementDecl()
{
if (base.reader.Depth == 0)
{
this.LoadSchema(string.Empty);
}
if (base.reader.MoveToFirstAttribute())
{
do
{
string namespaceURI = base.reader.NamespaceURI;
string localName = base.reader.LocalName;
if (Ref.Equal(namespaceURI, base.SchemaNames.NsXmlNs))
{
this.LoadSchema(base.reader.Value);
if (this.isProcessContents)
{
this.nsManager.AddNamespace((base.reader.Prefix.Length == 0) ? string.Empty : base.reader.LocalName, base.reader.Value);
}
}
if (Ref.Equal(namespaceURI, base.SchemaNames.QnDtDt.Namespace) && Ref.Equal(localName, base.SchemaNames.QnDtDt.Name))
{
base.reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(base.reader.Value);
}
}while (base.reader.MoveToNextAttribute());
base.reader.MoveToElement();
}
SchemaElementDecl elementDecl = base.schemaInfo.GetElementDecl(base.elementName);
if ((elementDecl == null) && base.schemaInfo.TargetNamespaces.ContainsKey(base.context.Namespace))
{
base.SendValidationEvent("Sch_UndeclaredElement", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
return(elementDecl);
}
internal static SchemaElementDecl CreateAnyTypeElementDecl()
{
SchemaElementDecl anyTypeElementDecl = new SchemaElementDecl();
anyTypeElementDecl.Datatype = DatatypeImplementation.AnySimpleType.Datatype !;
return(anyTypeElementDecl);
}
public static SchemaElementDecl CreateAnyTypeElementDecl()
{
SchemaElementDecl anyTypeElementDecl = new SchemaElementDecl();
anyTypeElementDecl.Content = new CompiledContentModel(null);
anyTypeElementDecl.Content.ContentType = CompiledContentModel.Type.Any;
anyTypeElementDecl.Datatype = XmlSchemaDatatype.AnyType;
return(anyTypeElementDecl);
}
internal XmlSchemaElement GetType(XmlQualifiedName qname)
{
SchemaElementDecl ed = GetElementDecl(qname);
if (ed != null)
{
return(ed.SchemaElement);
}
return(null);
}
internal XmlSchemaElement GetType(XmlQualifiedName qname)
{
SchemaElementDecl elementDecl = this.GetElementDecl(qname);
if (elementDecl != null)
{
return(elementDecl.SchemaElement);
}
return(null);
}
static XmlSchemaComplexType()
{
untypedAnyType.SetQualifiedName(new XmlQualifiedName("untypedAny", "http://www.w3.org/2003/11/xpath-datatypes"));
untypedAnyType.IsMixed = true;
untypedAnyType.SetContentTypeParticle(anyTypeLax.ContentTypeParticle);
untypedAnyType.SetContentType(XmlSchemaContentType.Mixed);
untypedAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
untypedAnyType.ElementDecl.SchemaType = untypedAnyType;
untypedAnyType.ElementDecl.ContentValidator = AnyTypeContentValidator;
}
public XmlSchemaElement GetElement(XmlQualifiedName qname)
{
SchemaElementDecl ed = GetElementDecl(qname);
if (ed != null)
{
return(ed.SchemaElement);
}
return(null);
}
static XmlSchemaComplexType()
{
anyType = new XmlSchemaComplexType();
anyType.SetContentType(XmlSchemaContentType.Mixed);
anyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
anyAttribute.BuildNamespaceList(null);
anyType.SetAttributeWildcard(anyAttribute);
anyType.ElementDecl.AnyAttribute = anyAttribute;
}
internal SchemaElementDecl GetElementDecl(XmlQualifiedName qname, SchemaElementDecl ed)
{
SchemaElementDecl ed1 = null;
if ((ed != null) && (ed.LocalElements != null))
{
ed1 = (SchemaElementDecl)ed.LocalElements[qname];
}
if (ed1 == null && elementDecls != null)
{
ed1 = (SchemaElementDecl)elementDecls[qname];
}
return(ed1);
}
internal void Reset() {
_Name = XmlQualifiedName.Empty;
_Prefix = null;
_TypeName = XmlQualifiedName.Empty;
_TypePrefix = null;
_Default = null;
_Revises = null;
_MaxOccurs = 1;
_MinOccurs = 1;
_Checking = false;
_ElementDecl = null;
_Next = null;
_Attdef = null;
}
//const byte dupDeclMask = 0x08;
private static XmlSchemaComplexType CreateUntypedAnyType()
{
// Create xdt:untypedAny
var untypedAny = new XmlSchemaComplexType();
untypedAny.SetQualifiedName(new XmlQualifiedName("untypedAny", XmlReservedNs.NsXQueryDataType));
untypedAny.IsMixed = true;
untypedAny.SetContentTypeParticle(s_anyTypeLax.ContentTypeParticle);
untypedAny.SetContentType(XmlSchemaContentType.Mixed);
untypedAny.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
untypedAny.ElementDecl.SchemaType = untypedAny;
untypedAny.ElementDecl.ContentValidator = AnyTypeContentValidator;
return(untypedAny);
}
//const byte dupDeclMask = 0x08;
static XmlSchemaComplexType()
{
anyTypeLax = CreateAnyType(XmlSchemaContentProcessing.Lax);
anyTypeSkip = CreateAnyType(XmlSchemaContentProcessing.Skip);
// Create xdt:untypedAny
untypedAnyType = new XmlSchemaComplexType();
untypedAnyType.SetQualifiedName(new XmlQualifiedName("untypedAny", XmlReservedNs.NsXQueryDataType));
untypedAnyType.IsMixed = true;
untypedAnyType.SetContentTypeParticle(anyTypeLax.ContentTypeParticle);
untypedAnyType.SetContentType(XmlSchemaContentType.Mixed);
untypedAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
untypedAnyType.ElementDecl.SchemaType = untypedAnyType;
untypedAnyType.ElementDecl.ContentValidator = AnyTypeContentValidator;
}
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents)
{
XmlSchemaComplexType localAnyType = new XmlSchemaComplexType();
localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType);
XmlSchemaAny anyElement = new XmlSchemaAny();
anyElement.MinOccurs = decimal.Zero;
anyElement.MaxOccurs = decimal.MaxValue;
anyElement.ProcessContents = processContents;
anyElement.BuildNamespaceList(null);
XmlSchemaSequence seq = new XmlSchemaSequence();
seq.Items.Add(anyElement);
localAnyType.SetContentTypeParticle(seq);
localAnyType.SetContentType(XmlSchemaContentType.Mixed);
localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
localAnyType.ElementDecl.SchemaType = localAnyType;
//Create contentValidator for Any
ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
contentValidator.Start();
contentValidator.OpenGroup();
contentValidator.AddNamespaceList(anyElement.NamespaceList !, anyElement);
contentValidator.AddStar();
contentValidator.CloseGroup();
ContentValidator anyContentValidator = contentValidator.Finish(true);
localAnyType.ElementDecl.ContentValidator = anyContentValidator;
XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
anyAttribute.ProcessContents = processContents;
anyAttribute.BuildNamespaceList(null);
localAnyType.SetAttributeWildcard(anyAttribute);
localAnyType.ElementDecl.AnyAttribute = anyAttribute;
return(localAnyType);
}
private SchemaElementDecl FastGetElementDecl(object particle)
{
SchemaElementDecl elementDecl = null;
if (particle != null)
{
XmlSchemaElement element = particle as XmlSchemaElement;
if (element != null)
{
elementDecl = element.ElementDecl;
}
else
{
XmlSchemaAny any = (XmlSchemaAny)particle;
processContents = any.ProcessContentsCorrect;
}
}
return(elementDecl);
}
private void ProcessElement()
{
SchemaElementDecl elementDecl = base.schemaInfo.GetElementDecl(base.elementName);
this.Push(base.elementName);
if (elementDecl != null)
{
base.context.ElementDecl = elementDecl;
this.ValidateStartElement();
this.ValidateEndStartElement();
base.context.NeedValidateChildren = true;
elementDecl.ContentValidator.InitValidation(base.context);
}
else
{
base.SendValidationEvent("Sch_UndeclaredElement", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
base.context.ElementDecl = null;
}
}
private void ProcessElement()
{
SchemaElementDecl elementDecl = schemaInfo.GetElementDecl(elementName);
Push(elementName);
if (elementDecl != null)
{
context.ElementDecl = elementDecl;
ValidateStartElement();
ValidateEndStartElement();
context.NeedValidateChildren = true;
elementDecl.ContentValidator.InitValidation(context);
}
else
{
SendValidationEvent(Res.Sch_UndeclaredElement, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
context.ElementDecl = null;
}
}
// SxS: This method processes resource names read from the source document and does not expose
// any resources to the caller. It is fine to suppress the SxS warning.
private SchemaElementDecl ThoroughGetElementDecl()
{
if (reader.Depth == 0)
{
LoadSchema(string.Empty);
}
if (reader.MoveToFirstAttribute())
{
do
{
string objectNs = reader.NamespaceURI;
string objectName = reader.LocalName;
if (Ref.Equal(objectNs, SchemaNames.NsXmlNs))
{
LoadSchema(reader.Value);
if (_isProcessContents)
{
_nsManager.AddNamespace(reader.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value);
}
}
if (
Ref.Equal(objectNs, SchemaNames.QnDtDt.Namespace) &&
Ref.Equal(objectName, SchemaNames.QnDtDt.Name)
)
{
reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(reader.Value);
}
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
SchemaElementDecl elementDecl = schemaInfo.GetElementDecl(elementName);
if (elementDecl == null)
{
if (schemaInfo.TargetNamespaces.ContainsKey(context.Namespace))
{
SendValidationEvent(SR.Sch_UndeclaredElement, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
}
return(elementDecl);
}
private void ProcessElement(object particle)
{
XmlQualifiedName xsiType;
string xsiNil;
SchemaElementDecl elementDecl = FastGetElementDecl(particle);
Push(elementName);
if (bManageNamespaces)
{
nsManager.PushScope();
}
ProcessXsiAttributes(out xsiType, out xsiNil);
if (processContents != XmlSchemaContentProcessing.Skip)
{
if (elementDecl == null || !xsiType.IsEmpty || xsiNil != null)
{
elementDecl = ThoroughGetElementDecl(elementDecl, xsiType, xsiNil);
}
if (elementDecl == null)
{
if (HasSchema && processContents == XmlSchemaContentProcessing.Strict)
{
SendValidationEvent(Res.Sch_UndeclaredElement, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
else
{
SendValidationEvent(Res.Sch_NoElementSchemaFound, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace), XmlSeverityType.Warning);
}
}
}
context.ElementDecl = elementDecl;
ValidateStartElementIdentityConstraints();
ValidateStartElement();
if (context.ElementDecl != null)
{
ValidateEndStartElement();
context.NeedValidateChildren = processContents != XmlSchemaContentProcessing.Skip;
context.ElementDecl.ContentValidator.InitValidation(context);
}
}
internal SchemaAttDef GetAttributeXdr(SchemaElementDecl ed, XmlQualifiedName qname)
{
SchemaAttDef attdef = null;
if (ed != null)
{
attdef = ed.GetAttDef(qname);;
if (attdef == null)
{
if (!ed.ContentValidator.IsOpen || qname.Namespace.Length == 0)
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
if (!attributeDecls.TryGetValue(qname, out attdef) && targetNamespaces.ContainsKey(qname.Namespace))
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
}
return(attdef);
}
private void ProcessElement(object particle)
{
XmlQualifiedName name;
string str;
SchemaElementDecl elementDecl = this.FastGetElementDecl(particle);
this.Push(base.elementName);
if (this.bManageNamespaces)
{
this.nsManager.PushScope();
}
this.ProcessXsiAttributes(out name, out str);
if (this.processContents != XmlSchemaContentProcessing.Skip)
{
if (((elementDecl == null) || !name.IsEmpty) || (str != null))
{
elementDecl = this.ThoroughGetElementDecl(elementDecl, name, str);
}
if (elementDecl == null)
{
if (this.HasSchema && (this.processContents == XmlSchemaContentProcessing.Strict))
{
base.SendValidationEvent("Sch_UndeclaredElement", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
else
{
base.SendValidationEvent("Sch_NoElementSchemaFound", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace), XmlSeverityType.Warning);
}
}
}
base.context.ElementDecl = elementDecl;
this.ValidateStartElementIdentityConstraints();
this.ValidateStartElement();
if (base.context.ElementDecl != null)
{
this.ValidateEndStartElement();
base.context.NeedValidateChildren = this.processContents != XmlSchemaContentProcessing.Skip;
base.context.ElementDecl.ContentValidator.InitValidation(base.context);
}
}
private static void XDR_BuildElement_Type(XdrBuilder builder, object obj, string prefix)
{
XmlQualifiedName qname = (XmlQualifiedName)obj;
if (!builder._SchemaInfo.ElementDecls.ContainsKey(qname))
{
SchemaElementDecl ed = (SchemaElementDecl)builder._UndeclaredElements[qname];
if (ed == null)
{
ed = new SchemaElementDecl(qname, prefix);
builder._UndeclaredElements.Add(qname, ed);
}
}
builder._ElementDef._HasType = true;
if (builder._ElementDef._ExistTerminal)
builder.AddOrder();
else
builder._ElementDef._ExistTerminal = true;
builder._contentValidator.AddName(qname, null);
}
private void CheckRequiredAttributes(SchemaElementDecl currentElementDecl)
{
foreach (SchemaAttDef def in currentElementDecl.AttDefs.Values)
{
if ((this.attPresence[def.Name] == null) && ((def.Presence == SchemaDeclBase.Use.Required) || (def.Presence == SchemaDeclBase.Use.RequiredFixed)))
{
this.SendValidationEvent("Sch_MissRequiredAttribute", def.Name.ToString());
}
}
}
private void CompileSimpleType(XmlSchemaSimpleType simpleType) {
if (simpleType.IsProcessing) {
throw new XmlSchemaException(Res.Sch_TypeCircularRef, simpleType);
}
if (simpleType.ElementDecl != null) { // already compiled
return;
}
simpleType.IsProcessing = true;
try {
if (simpleType.Content is XmlSchemaSimpleTypeList) {
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)simpleType.Content;
XmlSchemaDatatype datatype;
simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
if (list.ItemTypeName.IsEmpty) {
CompileSimpleType(list.ItemType);
list.BaseItemType = list.ItemType;
datatype = list.ItemType.Datatype;
}
else {
XmlSchemaSimpleType type = GetSimpleType(list.ItemTypeName);
if (type != null) {
if ((type.FinalResolved & XmlSchemaDerivationMethod.List) != 0) {
SendValidationEvent(Res.Sch_BaseFinalList, simpleType);
}
list.BaseItemType = type;
datatype = type.Datatype;
}
else {
throw new XmlSchemaException(Res.Sch_UndeclaredSimpleType, list.ItemTypeName.ToString(), list);
}
}
simpleType.SetDatatype(datatype.DeriveByList(simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.List);
}
else if (simpleType.Content is XmlSchemaSimpleTypeRestriction) {
XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)simpleType.Content;
XmlSchemaDatatype datatype;
if (restriction.BaseTypeName.IsEmpty) {
CompileSimpleType(restriction.BaseType);
simpleType.SetBaseSchemaType(restriction.BaseType);
datatype = restriction.BaseType.Datatype;
}
else if (simpleType.Redefined != null && restriction.BaseTypeName == simpleType.Redefined.QualifiedName) {
CompileSimpleType((XmlSchemaSimpleType)simpleType.Redefined);
simpleType.SetBaseSchemaType(simpleType.Redefined.BaseXmlSchemaType);
datatype = simpleType.Redefined.Datatype;
}
else {
if (restriction.BaseTypeName.Equals(DatatypeImplementation.QnAnySimpleType)) {
XmlSchema parentSchema = Preprocessor.GetParentSchema(simpleType);
if (parentSchema.TargetNamespace != XmlSchema.Namespace) { //If it is not SForS, then error
throw new XmlSchemaException(Res.Sch_InvalidSimpleTypeRestriction, restriction.BaseTypeName.ToString(), simpleType);
}
}
XmlSchemaSimpleType type = GetSimpleType(restriction.BaseTypeName);
if (type != null) {
if ((type.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0) {
SendValidationEvent(Res.Sch_BaseFinalRestriction, simpleType);
}
simpleType.SetBaseSchemaType(type);
datatype = type.Datatype;
}
else {
throw new XmlSchemaException(Res.Sch_UndeclaredSimpleType, restriction.BaseTypeName.ToString(), restriction);
}
}
simpleType.SetDatatype(datatype.DeriveByRestriction(restriction.Facets, NameTable, simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
}
else { //simpleType.Content is XmlSchemaSimpleTypeUnion
XmlSchemaSimpleType[] baseTypes = CompileBaseMemberTypes(simpleType);
simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
simpleType.SetDatatype(XmlSchemaDatatype.DeriveByUnion(baseTypes, simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Union);
}
}
catch (XmlSchemaException e) {
if (e.SourceSchemaObject == null) {
e.SetSource(simpleType);
}
SendValidationEvent(e);
simpleType.SetDatatype(DatatypeImplementation.AnySimpleType.Datatype);
}
finally {
SchemaElementDecl decl = new SchemaElementDecl();
decl.ContentValidator = ContentValidator.TextOnly;
decl.SchemaType = simpleType;
decl.Datatype = simpleType.Datatype;
simpleType.ElementDecl = decl;
simpleType.IsProcessing = false;
}
}
private void ParseAttlistType( SchemaAttDef attrDef, SchemaElementDecl elementDecl ) {
Token token = GetToken( true );
if ( token != Token.CDATA ) {
elementDecl.HasNonCDataAttribute = true;
}
if ( IsAttributeValueType( token ) ) {
attrDef.Datatype = XmlSchemaDatatype.FromXmlTokenizedType( (XmlTokenizedType)(int)token );
attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType( attrDef.Datatype.TypeCode );
switch ( token ) {
case Token.NOTATION:
break;
case Token.ID:
if ( validate && elementDecl.IsIdDeclared ) {
SchemaAttDef idAttrDef = elementDecl.GetAttDef( attrDef.Name );
if ( idAttrDef == null || idAttrDef.Datatype.TokenizedType != XmlTokenizedType.ID ) {
SendValidationEvent( XmlSeverityType.Error, Res.Sch_IdAttrDeclared, elementDecl.Name.ToString() );
}
}
elementDecl.IsIdDeclared = true;
return;
default:
return;
}
// check notation constrains
if ( validate ) {
if ( elementDecl.IsNotationDeclared ) {
SendValidationEvent( curPos - 8, XmlSeverityType.Error, Res.Sch_DupNotationAttribute, elementDecl.Name.ToString() ); // 8 == strlen("NOTATION")
}
else {
if ( elementDecl.ContentValidator != null &&
elementDecl.ContentValidator.ContentType == XmlSchemaContentType.Empty ) {
SendValidationEvent( curPos - 8, XmlSeverityType.Error, Res.Sch_NotationAttributeOnEmptyElement, elementDecl.Name.ToString() );// 8 == strlen("NOTATION")
}
elementDecl.IsNotationDeclared = true;
}
}
if ( GetToken( true ) != Token.LeftParen ) {
goto UnexpectedError;
}
// parse notation list
if ( GetToken( false ) != Token.Name ) {
goto UnexpectedError;
}
for (;;) {
string notationName = GetNameString();
if ( schemaInfo.Notations[notationName] == null ) {
if ( undeclaredNotations == null ) {
undeclaredNotations = new Hashtable();
}
UndeclaredNotation un = new UndeclaredNotation( notationName, LineNo, LinePos - notationName.Length );
UndeclaredNotation loggedUn = (UndeclaredNotation)undeclaredNotations[notationName];
if ( loggedUn != null ) {
un.next = loggedUn.next;
loggedUn.next = un;
}
else {
undeclaredNotations.Add( notationName, un );
}
}
if ( validate && !v1Compat && attrDef.Values != null && attrDef.Values.Contains( notationName ) ) {
SendValidationEvent( XmlSeverityType.Error, new XmlSchemaException( Res.Xml_AttlistDuplNotationValue, notationName, BaseUriStr, (int)LineNo, (int)LinePos ) );
}
attrDef.AddValue( notationName );
switch ( GetToken( false ) ) {
case Token.Or:
if ( GetToken( false ) != Token.Name ) {
goto UnexpectedError;
}
continue;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else if ( token == Token.LeftParen ) {
attrDef.Datatype = XmlSchemaDatatype.FromXmlTokenizedType( XmlTokenizedType.ENUMERATION );
attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType( attrDef.Datatype.TypeCode );
// parse nmtoken list
if ( GetToken( false ) != Token.Nmtoken )
goto UnexpectedError;
attrDef.AddValue( GetNameString() );
for (;;) {
switch ( GetToken( false ) ) {
case Token.Or:
if ( GetToken( false ) != Token.Nmtoken )
goto UnexpectedError;
string nmtoken = GetNmtokenString();
if ( validate && !v1Compat && attrDef.Values != null && attrDef.Values.Contains( nmtoken ) ) {
SendValidationEvent( XmlSeverityType.Error, new XmlSchemaException( Res.Xml_AttlistDuplEnumValue, nmtoken, BaseUriStr, (int)LineNo, (int)LinePos ) );
}
attrDef.AddValue( nmtoken );
break;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else {
goto UnexpectedError;
}
UnexpectedError:
OnUnexpectedError();
}
private SchemaElementDecl ThoroughGetElementDecl(SchemaElementDecl elementDecl, XmlQualifiedName xsiType, string xsiNil)
{
if (elementDecl == null)
{
elementDecl = base.schemaInfo.GetElementDecl(base.elementName);
}
if (elementDecl != null)
{
if (xsiType.IsEmpty)
{
if (elementDecl.IsAbstract)
{
base.SendValidationEvent("Sch_AbstractElement", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
elementDecl = null;
}
}
else if ((xsiNil != null) && xsiNil.Equals("true"))
{
base.SendValidationEvent("Sch_XsiNilAndType");
}
else
{
SchemaElementDecl decl;
if (!base.schemaInfo.ElementDeclsByType.TryGetValue(xsiType, out decl) && (xsiType.Namespace == this.NsXs))
{
XmlSchemaSimpleType simpleTypeFromXsdType = DatatypeImplementation.GetSimpleTypeFromXsdType(new XmlQualifiedName(xsiType.Name, this.NsXs));
if (simpleTypeFromXsdType != null)
{
decl = simpleTypeFromXsdType.ElementDecl;
}
}
if (decl == null)
{
base.SendValidationEvent("Sch_XsiTypeNotFound", xsiType.ToString());
elementDecl = null;
}
else if (!XmlSchemaType.IsDerivedFrom(decl.SchemaType, elementDecl.SchemaType, elementDecl.Block))
{
base.SendValidationEvent("Sch_XsiTypeBlockedEx", new string[] { xsiType.ToString(), XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace) });
elementDecl = null;
}
else
{
elementDecl = decl;
}
}
if ((elementDecl != null) && elementDecl.IsNillable)
{
if (xsiNil != null)
{
base.context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (base.context.IsNill && (elementDecl.DefaultValueTyped != null))
{
base.SendValidationEvent("Sch_XsiNilAndFixed");
}
}
return(elementDecl);
}
if (xsiNil != null)
{
base.SendValidationEvent("Sch_InvalidXsiNill");
}
}
return(elementDecl);
}
private void CompileElement(XmlSchemaElement xe) {
if (xe.Validating) {
SendValidationEvent(Res.Sch_ElementCircularRef, xe);
return;
}
if (xe.ElementDecl != null) {
return;
}
xe.Validating = true;
SchemaElementDecl decl = null;
try {
if (!xe.RefName.IsEmpty) {
XmlSchemaElement e = (XmlSchemaElement)this.schema.Elements[xe.RefName];
if (e == null) {
throw new XmlSchemaException(Res.Sch_UndeclaredElement, xe.RefName.ToString(), xe);
}
CompileElement(e);
if (e.ElementDecl == null) {
throw new XmlSchemaException(Res.Sch_RefInvalidElement, xe.RefName.ToString(), xe);
}
xe.SetElementType(e.ElementType);
decl = e.ElementDecl.Clone();
}
else {
if (xe.SchemaType != null) {
xe.SetElementType(xe.SchemaType);
}
else if (!xe.SchemaTypeName.IsEmpty) {
XmlSchemaDatatype datatype;
xe.SetElementType(GetAnySchemaType(xe.SchemaTypeName, out datatype));
if (xe.ElementType == null) {
throw new XmlSchemaException(Res.Sch_UndeclaredType, xe.SchemaTypeName.ToString(), xe);
}
}
else if (!xe.SubstitutionGroup.IsEmpty) {
XmlSchemaElement examplar = (XmlSchemaElement)this.schema.Elements[xe.SubstitutionGroup];
if (examplar == null) {
throw new XmlSchemaException(Res.Sch_UndeclaredEquivClass, xe.SubstitutionGroup.Name.ToString(), xe);
}
CompileElement(examplar);
xe.SetElementType(examplar.ElementType);
decl = examplar.ElementDecl.Clone();
}
else {
xe.SetElementType(XmlSchemaDatatype.AnyType);
decl = SchemaElementDecl.CreateAnyTypeElementDecl();
}
if (decl == null) {
Debug.Assert(xe.ElementType != null);
if (xe.ElementType is XmlSchemaComplexType) {
XmlSchemaComplexType complexType = (XmlSchemaComplexType)xe.ElementType;
CompileComplexType(complexType);
if (complexType.ElementDecl != null) {
decl = complexType.ElementDecl.Clone();
decl.LocalElements = complexType.LocalElementDecls;
}
}
else if (xe.ElementType is XmlSchemaSimpleType) {
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)xe.ElementType;
CompileSimpleType(simpleType);
if (simpleType.ElementDecl != null) {
decl = simpleType.ElementDecl.Clone();
}
}
else {
decl = new SchemaElementDecl((XmlSchemaDatatype)xe.ElementType, this.schemaNames);
}
}
decl.Name = xe.QualifiedName;
decl.IsAbstract = xe.IsAbstract;
XmlSchemaComplexType ct = xe.ElementType as XmlSchemaComplexType;
if (ct != null) {
decl.IsAbstract |= ct.IsAbstract;
}
decl.IsNillable = xe.IsNillable;
decl.Block |= xe.BlockResolved;
}
if (decl.Datatype != null) {
decl.Datatype.VerifySchemaValid(this.schema, xe);
}
if (xe.DefaultValue != null || xe.FixedValue != null) {
if (decl.Content.ContentType == CompiledContentModel.Type.Text) {
if (xe.DefaultValue != null) {
decl.Presence = SchemaDeclBase.Use.Default;
decl.DefaultValueTyped = decl.Datatype.ParseValue(xe.DefaultValue, this.nameTable, this.namespaceManager);
}
else {
decl.Presence = SchemaDeclBase.Use.Fixed;
decl.DefaultValueTyped = decl.Datatype.ParseValue(xe.FixedValue, this.nameTable, this.namespaceManager);
}
}
else if (decl.Content.ContentType != CompiledContentModel.Type.Mixed || !decl.Content.IsEmptiable) {
throw new XmlSchemaException(Res.Sch_ElementCannotHaveValue, xe);
}
}
if (xe.HasConstraints) {
XmlSchemaObjectCollection constraints = xe.Constraints;
CompiledIdentityConstraint[] compiledConstraints = new CompiledIdentityConstraint[constraints.Count];
int idx = 0;
foreach(XmlSchemaIdentityConstraint constraint in constraints) {
CompileIdentityConstraint (constraint);
compiledConstraints[idx ++] = constraint.CompiledConstraint;
}
decl.Constraints = compiledConstraints;
}
xe.ElementDecl = decl;
}
catch (XmlSchemaException e) {
if (e.SourceSchemaObject == null) {
e.SetSource(xe);
}
SendValidationEvent(e);
xe.ElementDecl = SchemaElementDecl.Empty;
}
finally {
xe.Validating = false;
}
}
private void CompileComplexType(XmlSchemaComplexType complexType)
{
if (complexType.ElementDecl == null)
{
if (complexType.IsProcessing)
{
base.SendValidationEvent("Sch_TypeCircularRef", complexType);
}
else
{
complexType.IsProcessing = true;
if (complexType.ContentModel != null)
{
if (complexType.ContentModel is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent contentModel = (XmlSchemaSimpleContent) complexType.ContentModel;
complexType.SetContentType(XmlSchemaContentType.TextOnly);
if (contentModel.Content is XmlSchemaSimpleContentExtension)
{
this.CompileSimpleContentExtension(complexType, (XmlSchemaSimpleContentExtension) contentModel.Content);
}
else
{
this.CompileSimpleContentRestriction(complexType, (XmlSchemaSimpleContentRestriction) contentModel.Content);
}
}
else
{
XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent) complexType.ContentModel;
if (complexContent.Content is XmlSchemaComplexContentExtension)
{
this.CompileComplexContentExtension(complexType, complexContent, (XmlSchemaComplexContentExtension) complexContent.Content);
}
else
{
this.CompileComplexContentRestriction(complexType, complexContent, (XmlSchemaComplexContentRestriction) complexContent.Content);
}
}
}
else
{
complexType.SetBaseSchemaType(XmlSchemaComplexType.AnyType);
this.CompileLocalAttributes(XmlSchemaComplexType.AnyType, complexType, complexType.Attributes, complexType.AnyAttribute, XmlSchemaDerivationMethod.Restriction);
complexType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
complexType.SetContentTypeParticle(this.CompileContentTypeParticle(complexType.Particle, true));
complexType.SetContentType(this.GetSchemaContentType(complexType, null, complexType.ContentTypeParticle));
}
bool flag = false;
foreach (XmlSchemaAttribute attribute in complexType.AttributeUses.Values)
{
if (attribute.Use != XmlSchemaUse.Prohibited)
{
XmlSchemaDatatype datatype = attribute.Datatype;
if ((datatype != null) && (datatype.TokenizedType == XmlTokenizedType.ID))
{
if (flag)
{
base.SendValidationEvent("Sch_TwoIdAttrUses", complexType);
}
else
{
flag = true;
}
}
}
}
SchemaElementDecl decl = new SchemaElementDecl {
ContentValidator = this.CompileComplexContent(complexType),
SchemaType = complexType,
IsAbstract = complexType.IsAbstract,
Datatype = complexType.Datatype,
Block = complexType.BlockResolved,
AnyAttribute = complexType.AttributeWildcard
};
foreach (XmlSchemaAttribute attribute2 in complexType.AttributeUses.Values)
{
if (attribute2.Use == XmlSchemaUse.Prohibited)
{
if (!decl.ProhibitedAttributes.ContainsKey(attribute2.QualifiedName))
{
decl.ProhibitedAttributes.Add(attribute2.QualifiedName, attribute2.QualifiedName);
}
}
else if ((!decl.AttDefs.ContainsKey(attribute2.QualifiedName) && (attribute2.AttDef != null)) && ((attribute2.AttDef.Name != XmlQualifiedName.Empty) && (attribute2.AttDef != SchemaAttDef.Empty)))
{
decl.AddAttDef(attribute2.AttDef);
}
}
complexType.ElementDecl = decl;
complexType.IsProcessing = false;
}
}
}
internal void Reset()
{
this._Name = XmlQualifiedName.Empty;
this._Prefix = null;
this._TypeName = XmlQualifiedName.Empty;
this._TypePrefix = null;
this._Default = null;
this._Revises = null;
this._MaxOccurs = 1;
this._MinOccurs = 1;
this._Checking = false;
this._ElementDecl = null;
this._Next = null;
this._Attdef = null;
}
private static void XDR_BuildElement_Type(XdrBuilder builder, object obj, string prefix)
{
XmlQualifiedName key = (XmlQualifiedName) obj;
if (!builder._SchemaInfo.ElementDecls.ContainsKey(key) && (((SchemaElementDecl) builder._UndeclaredElements[key]) == null))
{
SchemaElementDecl decl = new SchemaElementDecl(key, prefix);
builder._UndeclaredElements.Add(key, decl);
}
builder._ElementDef._HasType = true;
if (builder._ElementDef._ExistTerminal)
{
builder.AddOrder();
}
else
{
builder._ElementDef._ExistTerminal = true;
}
builder._contentValidator.AddName(key, null);
}
private async Task ParseAttlistDeclAsync() {
if (await GetTokenAsync(true).ConfigureAwait(false) != Token.QName) {
goto UnexpectedError;
}
// element name
XmlQualifiedName elementName = GetNameQualified(true);
SchemaElementDecl elementDecl;
if (!schemaInfo.ElementDecls.TryGetValue(elementName, out elementDecl)) {
if (!schemaInfo.UndeclaredElementDecls.TryGetValue(elementName, out elementDecl)) {
elementDecl = new SchemaElementDecl(elementName, elementName.Namespace);
schemaInfo.UndeclaredElementDecls.Add(elementName, elementDecl);
}
}
SchemaAttDef attrDef = null;
for (; ; ) {
switch (await GetTokenAsync(false).ConfigureAwait(false)) {
case Token.QName:
XmlQualifiedName attrName = GetNameQualified(true);
attrDef = new SchemaAttDef(attrName, attrName.Namespace);
attrDef.IsDeclaredInExternal = !ParsingInternalSubset;
attrDef.LineNumber = (int)LineNo;
attrDef.LinePosition = (int)LinePos - (curPos - tokenStartPos);
break;
case Token.GreaterThan:
#if !SILVERLIGHT
if ( v1Compat ) {
// check xml:space and xml:lang
//
if ( attrDef != null && attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals( "xml" ) && attrDef.Name.Name == "space" ) {
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
if ( attrDef.Datatype.TokenizedType != XmlTokenizedType.ENUMERATION ) {
Throw( Res.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition );
}
if ( validate ) {
attrDef.CheckXmlSpace( readerAdapterWithValidation.ValidationEventHandling );
}
}
}
#endif
return;
default:
goto UnexpectedError;
}
bool attrDefAlreadyExists = (elementDecl.GetAttDef(attrDef.Name) != null);
await ParseAttlistTypeAsync(attrDef, elementDecl, attrDefAlreadyExists).ConfigureAwait(false);
await ParseAttlistDefaultAsync(attrDef, attrDefAlreadyExists).ConfigureAwait(false);
// check xml:space and xml:lang
if (attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml")) {
if ( attrDef.Name.Name == "space" ) {
#if !SILVERLIGHT
if ( v1Compat ) {
//
string val = attrDef.DefaultValueExpanded.Trim();
if ( val.Equals( "preserve" ) || val.Equals( "default" ) ) {
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
}
}
else {
#endif
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
if ( attrDef.TokenizedType != XmlTokenizedType.ENUMERATION ) {
Throw( Res.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition );
}
#if !SILVERLIGHT
if ( validate ) {
attrDef.CheckXmlSpace( readerAdapterWithValidation.ValidationEventHandling );
}
}
#endif
}
else if ( attrDef.Name.Name == "lang" ) {
attrDef.Reserved = SchemaAttDef.Reserve.XmlLang;
}
}
// add attribute to element decl
if (!attrDefAlreadyExists) {
elementDecl.AddAttDef(attrDef);
}
}
UnexpectedError:
OnUnexpectedError();
}
private void ParseAttlistDecl()
{
if (GetToken(true) != Token.QName)
{
goto UnexpectedError;
}
// element name
XmlQualifiedName elementName = GetNameQualified(true);
SchemaElementDecl elementDecl;
if (!_schemaInfo.ElementDecls.TryGetValue(elementName, out elementDecl))
{
if (!_schemaInfo.UndeclaredElementDecls.TryGetValue(elementName, out elementDecl))
{
elementDecl = new SchemaElementDecl(elementName, elementName.Namespace);
_schemaInfo.UndeclaredElementDecls.Add(elementName, elementDecl);
}
}
SchemaAttDef attrDef = null;
for (; ;)
{
switch (GetToken(false))
{
case Token.QName:
XmlQualifiedName attrName = GetNameQualified(true);
attrDef = new SchemaAttDef(attrName, attrName.Namespace);
attrDef.IsDeclaredInExternal = !ParsingInternalSubset;
attrDef.LineNumber = (int)LineNo;
attrDef.LinePosition = (int)LinePos - (_curPos - _tokenStartPos);
break;
case Token.GreaterThan:
return;
default:
goto UnexpectedError;
}
bool attrDefAlreadyExists = (elementDecl.GetAttDef(attrDef.Name) != null);
ParseAttlistType(attrDef, elementDecl, attrDefAlreadyExists);
ParseAttlistDefault(attrDef, attrDefAlreadyExists);
// check xml:space and xml:lang
if (attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml"))
{
if (attrDef.Name.Name == "space")
{
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
if (attrDef.TokenizedType != XmlTokenizedType.ENUMERATION)
{
Throw(SR.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition);
}
}
else if (attrDef.Name.Name == "lang")
{
attrDef.Reserved = SchemaAttDef.Reserve.XmlLang;
}
}
// add attribute to element decl
if (!attrDefAlreadyExists)
{
elementDecl.AddAttDef(attrDef);
}
}
UnexpectedError:
OnUnexpectedError();
}
private void ParseAttlistType(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
{
Token token = GetToken(true);
if (token != Token.CDATA)
{
elementDecl.HasNonCDataAttribute = true;
}
if (IsAttributeValueType(token))
{
attrDef.TokenizedType = (XmlTokenizedType)(int)token;
#if !SILVERLIGHT
attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
#endif
switch (token)
{
case Token.NOTATION:
break;
case Token.ID:
#if !SILVERLIGHT
if (_validate && elementDecl.IsIdDeclared)
{
SchemaAttDef idAttrDef = elementDecl.GetAttDef(attrDef.Name);
if ((idAttrDef == null || idAttrDef.Datatype.TokenizedType != XmlTokenizedType.ID) && !ignoreErrors)
{
SendValidationEvent(XmlSeverityType.Error, SR.Sch_IdAttrDeclared, elementDecl.Name.ToString());
}
}
#endif
elementDecl.IsIdDeclared = true;
return;
default:
return;
}
#if !SILVERLIGHT
// check notation constrains
if (_validate)
{
if (elementDecl.IsNotationDeclared && !ignoreErrors)
{
SendValidationEvent(_curPos - 8, XmlSeverityType.Error, SR.Sch_DupNotationAttribute, elementDecl.Name.ToString()); // 8 == strlen("NOTATION")
}
else
{
if (elementDecl.ContentValidator != null &&
elementDecl.ContentValidator.ContentType == XmlSchemaContentType.Empty &&
!ignoreErrors)
{
SendValidationEvent(_curPos - 8, XmlSeverityType.Error, SR.Sch_NotationAttributeOnEmptyElement, elementDecl.Name.ToString());// 8 == strlen("NOTATION")
}
elementDecl.IsNotationDeclared = true;
}
}
#endif
if (GetToken(true) != Token.LeftParen)
{
goto UnexpectedError;
}
// parse notation list
if (GetToken(false) != Token.Name)
{
goto UnexpectedError;
}
for (;;)
{
string notationName = GetNameString();
#if !SILVERLIGHT
if (!_schemaInfo.Notations.ContainsKey(notationName))
{
AddUndeclaredNotation(notationName);
}
if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(notationName) && !ignoreErrors)
{
SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(SR.Xml_AttlistDuplNotationValue, notationName, BaseUriStr, (int)LineNo, (int)LinePos));
}
attrDef.AddValue(notationName);
#endif
switch (GetToken(false))
{
case Token.Or:
if (GetToken(false) != Token.Name)
{
goto UnexpectedError;
}
continue;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else if (token == Token.LeftParen)
{
attrDef.TokenizedType = XmlTokenizedType.ENUMERATION;
#if !SILVERLIGHT
attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
#endif
// parse nmtoken list
if (GetToken(false) != Token.Nmtoken)
goto UnexpectedError;
#if !SILVERLIGHT
attrDef.AddValue(GetNameString());
#endif
for (;;)
{
switch (GetToken(false))
{
case Token.Or:
if (GetToken(false) != Token.Nmtoken)
goto UnexpectedError;
string nmtoken = GetNmtokenString();
#if !SILVERLIGHT
if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(nmtoken) && !ignoreErrors)
{
SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(SR.Xml_AttlistDuplEnumValue, nmtoken, BaseUriStr, (int)LineNo, (int)LinePos));
}
attrDef.AddValue(nmtoken);
#endif
break;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else
{
goto UnexpectedError;
}
UnexpectedError:
OnUnexpectedError();
}
private void ParseElementDecl()
{
// element name
if (GetToken(true) != Token.QName)
{
goto UnexpectedError;
}
// get schema decl for element
SchemaElementDecl elementDecl = null;
XmlQualifiedName name = GetNameQualified(true);
if (_schemaInfo.ElementDecls.TryGetValue(name, out elementDecl))
{
}
else
{
if (_schemaInfo.UndeclaredElementDecls.TryGetValue(name, out elementDecl))
{
_schemaInfo.UndeclaredElementDecls.Remove(name);
}
else
{
elementDecl = new SchemaElementDecl(name, name.Namespace);
}
_schemaInfo.ElementDecls.Add(name, elementDecl);
}
elementDecl.IsDeclaredInExternal = !ParsingInternalSubset;
// content spec
switch (GetToken(true))
{
case Token.EMPTY:
case Token.ANY:
break;
case Token.LeftParen:
switch (GetToken(false))
{
case Token.PCDATA:
ParseElementMixedContentNoValidation();
break;
case Token.None:
ParseElementOnlyContentNoValidation();
break;
default:
goto UnexpectedError;
}
break;
default:
goto UnexpectedError;
}
if (GetToken(false) != Token.GreaterThan)
{
ThrowUnexpectedToken(_curPos, ">");
}
return;
UnexpectedError:
OnUnexpectedError();
}
internal SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, XmlSchemaObject partialValidationType, out AttributeMatchState attributeMatchState) {
SchemaAttDef attdef = null;
attributeMatchState = AttributeMatchState.UndeclaredAttribute;
if (ed != null) {
attdef = ed.GetAttDef(qname);
if (attdef != null) {
attributeMatchState = AttributeMatchState.AttributeFound;
return attdef;
}
XmlSchemaAnyAttribute any = ed.AnyAttribute;
if (any != null) {
if (!any.NamespaceList.Allows(qname)) {
attributeMatchState = AttributeMatchState.ProhibitedAnyAttribute;
}
else if (any.ProcessContentsCorrect != XmlSchemaContentProcessing.Skip) {
if (attributeDecls.TryGetValue(qname, out attdef)) {
if (attdef.Datatype.TypeCode == XmlTypeCode.Id) { //anyAttribute match whose type is ID
attributeMatchState = AttributeMatchState.AnyIdAttributeFound;
}
else {
attributeMatchState = AttributeMatchState.AttributeFound;
}
}
else if (any.ProcessContentsCorrect == XmlSchemaContentProcessing.Lax) {
attributeMatchState = AttributeMatchState.AnyAttributeLax;
}
}
else {
attributeMatchState = AttributeMatchState.AnyAttributeSkip;
}
}
else if (ed.ProhibitedAttributes.ContainsKey(qname)) {
attributeMatchState = AttributeMatchState.ProhibitedAttribute;
}
}
else if (partialValidationType != null) {
XmlSchemaAttribute attr = partialValidationType as XmlSchemaAttribute;
if (attr != null) {
if (qname.Equals(attr.QualifiedName)) {
attdef = attr.AttDef;
attributeMatchState = AttributeMatchState.AttributeFound;
}
else {
attributeMatchState = AttributeMatchState.AttributeNameMismatch;
}
}
else {
attributeMatchState = AttributeMatchState.ValidateAttributeInvalidCall;
}
}
else {
if (attributeDecls.TryGetValue(qname, out attdef)) {
attributeMatchState = AttributeMatchState.AttributeFound;
}
else {
attributeMatchState = AttributeMatchState.UndeclaredElementAndAttribute;
}
}
return attdef;
}
internal SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, XmlSchemaObject partialValidationType, out AttributeMatchState attributeMatchState)
{
SchemaAttDef attdef = null;
attributeMatchState = AttributeMatchState.UndeclaredAttribute;
if (ed != null)
{
attdef = ed.GetAttDef(qname);
if (attdef != null)
{
attributeMatchState = AttributeMatchState.AttributeFound;
return(attdef);
}
XmlSchemaAnyAttribute any = ed.AnyAttribute;
if (any != null)
{
if (!any.NamespaceList.Allows(qname))
{
attributeMatchState = AttributeMatchState.ProhibitedAnyAttribute;
}
else if (any.ProcessContentsCorrect != XmlSchemaContentProcessing.Skip)
{
if (attributeDecls.TryGetValue(qname, out attdef))
{
if (attdef.Datatype.TypeCode == XmlTypeCode.Id) //anyAttribute match whose type is ID
{
attributeMatchState = AttributeMatchState.AnyIdAttributeFound;
}
else
{
attributeMatchState = AttributeMatchState.AttributeFound;
}
}
else if (any.ProcessContentsCorrect == XmlSchemaContentProcessing.Lax)
{
attributeMatchState = AttributeMatchState.AnyAttributeLax;
}
}
else
{
attributeMatchState = AttributeMatchState.AnyAttributeSkip;
}
}
else if (ed.ProhibitedAttributes.ContainsKey(qname))
{
attributeMatchState = AttributeMatchState.ProhibitedAttribute;
}
}
else if (partialValidationType != null)
{
XmlSchemaAttribute attr = partialValidationType as XmlSchemaAttribute;
if (attr != null)
{
if (qname.Equals(attr.QualifiedName))
{
attdef = attr.AttDef;
attributeMatchState = AttributeMatchState.AttributeFound;
}
else
{
attributeMatchState = AttributeMatchState.AttributeNameMismatch;
}
}
else
{
attributeMatchState = AttributeMatchState.ValidateAttributeInvalidCall;
}
}
else
{
if (attributeDecls.TryGetValue(qname, out attdef))
{
attributeMatchState = AttributeMatchState.AttributeFound;
}
else
{
attributeMatchState = AttributeMatchState.UndeclaredElementAndAttribute;
}
}
return(attdef);
}
internal SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, ref bool skip) {
AttributeMatchState attributeMatchState;
SchemaAttDef attDef = GetAttributeXsd(ed, qname, null, out attributeMatchState);
switch(attributeMatchState) {
case AttributeMatchState.UndeclaredAttribute:
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
case AttributeMatchState.ProhibitedAnyAttribute:
case AttributeMatchState.ProhibitedAttribute:
throw new XmlSchemaException(Res.Sch_ProhibitedAttribute, qname.ToString());
case AttributeMatchState.AttributeFound:
case AttributeMatchState.AnyIdAttributeFound:
case AttributeMatchState.AnyAttributeLax:
case AttributeMatchState.UndeclaredElementAndAttribute:
break;
case AttributeMatchState.AnyAttributeSkip:
skip = true;
break;
default:
Debug.Assert(false);
break;
}
return attDef;
}
internal SchemaAttDef GetAttribute(SchemaElementDecl ed, XmlQualifiedName qname, ref bool skip)
{
SchemaAttDef attdef = null;
if (ed != null) // local attribute or XSD
{
skip = false;
attdef = ed.GetAttDef(qname);
if (attdef == null)
{
// In DTD, every attribute must be declared.
if (schemaType == SchemaType.DTD)
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
else if (schemaType == SchemaType.XDR)
{
if (ed.Content.IsOpen)
{
attdef = (SchemaAttDef)attributeDecls[qname];
if ((attdef == null) && ((qname.Namespace == String.Empty) || HasSchema(qname.Namespace)))
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
else
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
else //XML Schema
{
XmlSchemaAnyAttribute any = ed.AnyAttribute;
if (any != null)
{
if (any.NamespaceList.Allows(qname))
{
if (any.ProcessContentsCorrect != XmlSchemaContentProcessing.Skip)
{
attdef = (SchemaAttDef)attributeDecls[qname];
if (attdef == null && any.ProcessContentsCorrect == XmlSchemaContentProcessing.Strict)
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
else
{
skip = true;
}
}
else
{
throw new XmlSchemaException(Res.Sch_ProhibitedAttribute, qname.ToString());
}
}
else if (ed.ProhibitedAttributes[qname] != null)
{
throw new XmlSchemaException(Res.Sch_ProhibitedAttribute, qname.ToString());
}
else
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
}
}
else // global attribute
{
if (!skip)
{
attdef = (SchemaAttDef)attributeDecls[qname];
if ((attdef == null) && HasSchema(qname.Namespace))
{
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
}
return(attdef);
}
private void ProcessElement() {
int count = reader.AttributeCount;
XmlQualifiedName xsiType = XmlQualifiedName.Empty;
if (reader.Depth == 0 && SchemaInfo.SchemaType != SchemaType.DTD && validationFlag != ValidationType.DTD && validationFlag != ValidationType.None) {
LoadSchema(string.Empty, null);
}
string[] xsiSchemaLocation = null;
string xsiNoNamespaceSchemaLocation = null;
string xsiNil = null;
if (SchemaInfo.SchemaType != SchemaType.DTD && validationFlag != ValidationType.DTD && validationFlag != ValidationType.None) {
for (int i = 0; i < count ; i++) {
reader.MoveToAttribute(i);
string objectNs = reader.NamespaceURI;
string objectName = reader.LocalName;
if (Ref.Equal(objectNs, schemaNames.NsXmlNs)) {
LoadSchema(reader.Value, null);
if (isProcessContents) {
nsManager.AddNamespace(reader.Prefix == string.Empty ? string.Empty : reader.LocalName, reader.Value);
}
}
else if ((validationFlag != ValidationType.XDR) && Ref.Equal(objectNs, schemaNames.NsXsi)) {
if (Ref.Equal(objectName, schemaNames.XsiSchemaLocation)) {
xsiSchemaLocation = (string[])dtStringArray.ParseValue(reader.Value, nameTable, nsManager);
}
else if (Ref.Equal(objectName, schemaNames.XsiNoNamespaceSchemaLocation)) {
xsiNoNamespaceSchemaLocation = reader.Value;
}
else if (Ref.Equal(objectName, schemaNames.XsiType)) {
xsiType = (XmlQualifiedName)dtQName.ParseValue(reader.Value, nameTable, nsManager);
}
else if (Ref.Equal(objectName, schemaNames.XsiNil)) {
xsiNil = reader.Value;
}
SchemaInfo.SchemaType = SchemaType.XSD;
}
else if (
SchemaInfo.SchemaType != SchemaType.XSD &&
Ref.Equal(objectNs, schemaNames.QnDtDt.Namespace) &&
Ref.Equal(objectName, schemaNames.QnDtDt.Name)
) {
reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(reader.Value);
SchemaInfo.SchemaType = SchemaType.XDR;
}
}
}
if (count > 0) {
reader.MoveToElement();
}
if (xsiNoNamespaceSchemaLocation != null) {
LoadSchema(string.Empty, xsiNoNamespaceSchemaLocation);
}
if (xsiSchemaLocation != null) {
for (int i = 0; i < xsiSchemaLocation.Length - 1; i += 2) {
LoadSchema((string)xsiSchemaLocation[i], (string)xsiSchemaLocation[i + 1]);
}
}
if (HasSchema) {
if (processContents == XmlSchemaContentProcessing.Skip) {
nextElement = null;
}
else {
nextElement = SchemaInfo.GetElementDecl(this.name, (context != null) ? context.ElementDecl : null);
if (nextElement != null) {
if (xsiType.IsEmpty) {
if (nextElement.IsAbstract) {
SendValidationEvent(Res.Sch_AbstractElement, this.name.ToString());
nextElement = null;
}
}
else if(xsiNil != null && xsiNil.Equals("true")) {
SendValidationEvent(Res.Sch_XsiNilAndType);
}
else {
SchemaElementDecl nextElementXsi = (SchemaElementDecl)SchemaInfo.ElementDeclsByType[xsiType];
if (nextElementXsi == null && xsiType.Namespace == schemaNames.NsXsd) {
XmlSchemaDatatype datatype = XmlSchemaDatatype.FromTypeName(xsiType.Name);
if (datatype != null) {
nextElementXsi = new SchemaElementDecl(datatype, this.schemaNames);
}
}
if (nextElementXsi == null) {
SendValidationEvent(Res.Sch_XsiTypeNotFound, xsiType.ToString());
nextElement = null;
}
else if (!XmlSchemaType.IsDerivedFrom(
(nextElementXsi.SchemaType == null ? (object)nextElementXsi.Datatype : (object)nextElementXsi.SchemaType),
(nextElement.SchemaType == null ? (object)nextElement.Datatype : (object)nextElement.SchemaType),
nextElement.Block
)) {
SendValidationEvent(Res.Sch_XsiTypeBlocked, this.name.ToString());
nextElement = null;
}
else {
nextElement = nextElementXsi;
}
}
}
}
PushElementDecl(this.name.Namespace, reader.Prefix, reader.Depth);
if (context.ElementDecl != null || SchemaInfo.SchemaType == SchemaType.XSD) {
if (context.ElementDecl != null && context.ElementDecl.IsNillable) {
if (xsiNil != null) {
context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (context.IsNill && context.ElementDecl.DefaultValueTyped != null) {
SendValidationEvent(Res.Sch_XsiNilAndFixed);
}
}
}
else if (xsiNil != null) {
SendValidationEvent(Res.Sch_InvalidXsiNill);
}
if (context.ElementDecl != null) {
if (context.ElementDecl.SchemaType != null) {
reader.SchemaTypeObject = context.ElementDecl.SchemaType;
}
else {
reader.SchemaTypeObject = context.ElementDecl.Datatype;
}
if (reader.IsEmptyElement && !context.IsNill && context.ElementDecl.DefaultValueTyped != null) {
reader.TypedValueObject = context.ElementDecl.DefaultValueTyped;
context.IsNill = true; // reusing IsNill
}
if (this.context.ElementDecl.HasRequiredAttribute || this.startIDConstraint != -1) {
attPresence.Clear();
}
}
//foreach constraint in stack (including the current one)
if (this.startIDConstraint != -1) {
for (int i = this.startIDConstraint; i < this.validationStack.Length; i ++) {
// no constraint for this level
if (((ValidationState)(this.validationStack[i])).Constr == null) {
continue;
}
// else
foreach (ConstraintStruct conuct in ((ValidationState)(this.validationStack[i])).Constr) {
// check selector from here
if (conuct.axisSelector.MoveToStartElement(reader.LocalName, reader.NamespaceURI)) {
// selector selects new node, activate a new set of fields
Debug.WriteLine("Selector Match!");
Debug.WriteLine("Name: " + reader.LocalName + "\t|\tURI: " + reader.NamespaceURI + "\n");
KeySequence ks = new KeySequence (conuct.TableDim, positionInfo.LineNumber, positionInfo.LinePosition);
int row = conuct.AddToTable (ks); // new line in table assigned to this set of fields
int column = 0;
foreach (Asttree field in conuct.constraint.Fields) {
LocatedActiveAxis laxis = new LocatedActiveAxis (field, row, column ++);
conuct.axisFields.Add (laxis);
}
}
// axisFields is not null, but may be empty
foreach (LocatedActiveAxis laxis in conuct.axisFields) {
// check field from here
if (laxis.MoveToStartElement(reader.LocalName, reader.NamespaceURI)) {
Debug.WriteLine("Element Field Match!");
// checking simpleType / simpleContent
if (nextElement != null) { // nextElement can be null when xml/xsd are not valid
if (nextElement.Datatype == null) {
SendValidationEvent (Res.Sch_FieldSimpleTypeExpected, reader.LocalName);
}
else {
// can't fill value here, wait till later....
// fill type : xsdType
laxis.isMatched = true;
// since it's simpletyped element, the endchildren will come consequently... don't worry
}
}
}
}
}
}
}
for (int i = 0; i < count ; i++) {
reader.MoveToAttribute(i);
if ((SchemaInfo.SchemaType == SchemaType.XSD || SchemaInfo.SchemaType == SchemaType.XDR) && (object)reader.NamespaceURI == (object)schemaNames.NsXmlNs) {
continue;
}
if (SchemaInfo.SchemaType == SchemaType.XSD && (object)reader.NamespaceURI == (object)schemaNames.NsXsi) {
continue;
}
this.name = QualifiedName(reader.Prefix, reader.LocalName, reader.NamespaceURI);
try {
bool skip;
attnDef = SchemaInfo.GetAttribute(context.ElementDecl, this.name, out skip);
if (attnDef != null) {
if (context.ElementDecl != null && (context.ElementDecl.HasRequiredAttribute || this.startIDConstraint != -1)) {
attPresence.Add(attnDef.Name, attnDef);
}
reader.SchemaTypeObject = (attnDef.SchemaType != null) ? (object)attnDef.SchemaType : (object)attnDef.Datatype;
if (attnDef.Datatype != null) {
// VC constraint:
// The standalone document declaration must have the value "no" if any external markup declarations
// contain declarations of attributes with values subject to normalization, where the attribute appears in
// the document with a value which will change as a result of normalization,
string attributeValue = reader.Value;
if (reader.StandAlone && attnDef.IsDeclaredInExternal && attributeValue != reader.RawValue) {
SendValidationEvent(Res.Sch_StandAloneNormalization, reader.Name);
}
// need to check the contents of this attribute to make sure
// it is valid according to the specified attribute type.
CheckValue(attributeValue, attnDef);
}
}
else if (ValidationFlag == ValidationType.Schema && !skip) {
SendValidationEvent(Res.Sch_NoAttributeSchemaFound, this.name.ToString(), XmlSeverityType.Warning);
}
}
catch (XmlSchemaException e) {
e.SetSource(reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition);
SendValidationEvent(e);
}
// for all constraint in the stack, i have to check this thing
IDCCheckAttr(reader.LocalName, reader.NamespaceURI, reader.TypedValueObject, reader.Value, attnDef);
}
if (count > 0) {
reader.MoveToElement();
}
// Add default attributes
if ( nextElement != null) {
foreach (SchemaAttDef attdef in nextElement.AttDefs.Values) {
if (attdef.Presence == SchemaDeclBase.Use.Default ||
attdef.Presence == SchemaDeclBase.Use.Fixed) {
// VC constraint:
// Standalone must be = "no" when any external markup declarations contain declarations of attributes
// with default values, if elements to which these attributes apply appear in the document without
// specifications of values for these attributes
// for default attribute i have to check too...
if (reader.AddDefaultAttribute(attdef) && reader.StandAlone && attdef.IsDeclaredInExternal) {
SendValidationEvent(Res.Sch_UnSpecifiedDefaultAttributeInExternalStandalone, attdef.Name.Name);
}
// even default attribute i have to move to... but can't exist
if (! attPresence.Contains(attdef.Name)) {
IDCCheckAttr(attdef.Name.Name, attdef.Name.Namespace, attdef.DefaultValueTyped, attdef.DefaultValueRaw, attdef);
}
}
}
}
}
BeginChildren();
if (reader.IsEmptyElement) {
EndChildren();
}
}
else {
//couldnt find any schema for this element
if( ValidationFlag == ValidationType.DTD && 0 == reader.Depth) {
// this warning only needs to be on the documentElement
SendValidationEvent(Res.Xml_NoDTDPresent, this.name.ToString(), XmlSeverityType.Warning);
}
else if(ValidationFlag == ValidationType.Schema) {
SendValidationEvent(Res.Sch_NoElementSchemaFound, this.name.ToString(),XmlSeverityType.Warning);
for (int i = 0; i < count ; i++) {
reader.MoveToAttribute(i);
if ((object)reader.NamespaceURI == (object)schemaNames.NsXmlNs
||(ValidationType.Schema == ValidationFlag && (object)reader.NamespaceURI == (object)schemaNames.NsXsi)) {
continue;
}
this.name = QualifiedName(reader.Prefix, reader.LocalName, reader.NamespaceURI);
SendValidationEvent(Res.Sch_NoAttributeSchemaFound, this.name.ToString(), XmlSeverityType.Warning);
}
reader.MoveToElement();
}
}
}
private SchemaElementDecl ThoroughGetElementDecl(SchemaElementDecl elementDecl, XmlQualifiedName xsiType, string xsiNil)
{
if (elementDecl == null)
{
elementDecl = schemaInfo.GetElementDecl(elementName);
}
if (elementDecl != null)
{
if (xsiType.IsEmpty)
{
if (elementDecl.IsAbstract)
{
SendValidationEvent(Res.Sch_AbstractElement, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
elementDecl = null;
}
}
else if (xsiNil != null && xsiNil.Equals("true"))
{
SendValidationEvent(Res.Sch_XsiNilAndType);
}
else
{
SchemaElementDecl elementDeclXsi;
if (!schemaInfo.ElementDeclsByType.TryGetValue(xsiType, out elementDeclXsi) && xsiType.Namespace == NsXs)
{
XmlSchemaSimpleType simpleType = DatatypeImplementation.GetSimpleTypeFromXsdType(new XmlQualifiedName(xsiType.Name, NsXs));
if (simpleType != null)
{
elementDeclXsi = simpleType.ElementDecl;
}
}
if (elementDeclXsi == null)
{
SendValidationEvent(Res.Sch_XsiTypeNotFound, xsiType.ToString());
elementDecl = null;
}
else if (!XmlSchemaType.IsDerivedFrom(elementDeclXsi.SchemaType, elementDecl.SchemaType, elementDecl.Block))
{
SendValidationEvent(Res.Sch_XsiTypeBlockedEx, new string[] { xsiType.ToString(), XmlSchemaValidator.QNameString(context.LocalName, context.Namespace) });
elementDecl = null;
}
else
{
elementDecl = elementDeclXsi;
}
}
if (elementDecl != null && elementDecl.IsNillable)
{
if (xsiNil != null)
{
context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (context.IsNill && elementDecl.DefaultValueTyped != null)
{
SendValidationEvent(Res.Sch_XsiNilAndFixed);
}
}
}
else if (xsiNil != null)
{
SendValidationEvent(Res.Sch_InvalidXsiNill);
}
}
return(elementDecl);
}
internal void Validate(ValidationType valType) {
if (ValidationType.None != valType) {
Validate();
return;
}
if (XmlNodeType.Element == reader.NodeType) {
this.name = QualifiedName(reader.Prefix, reader.LocalName, reader.NamespaceURI);
nextElement = SchemaInfo.GetElementDecl(this.name, (context != null) ? context.ElementDecl : null);
if (null == nextElement) {
//this could be an undeclared element
nextElement = (SchemaElementDecl)(SchemaInfo.UndeclaredElementDecls[this.name]);
if (nextElement != null) {
//add default attributes
foreach (SchemaAttDef attdef in nextElement.AttDefs.Values) {
if (attdef.Presence == SchemaDeclBase.Use.Default ||
attdef.Presence == SchemaDeclBase.Use.Fixed) {
reader.AddDefaultAttribute(attdef);
}
}
return;
}
return;
}
int count = reader.AttributeCount;
for (int i = 0; i < count ; i++) {
reader.MoveToAttribute(i);
this.name = QualifiedName(reader.Prefix, reader.LocalName, reader.NamespaceURI);
attnDef = nextElement.GetAttDef(this.name);
if (attnDef != null) {
reader.SchemaTypeObject = (attnDef.SchemaType != null) ? (object)attnDef.SchemaType : (object)attnDef.Datatype;
}
else {
reader.SchemaTypeObject = dtCDATA;
}
}
reader.MoveToElement();
// Add default attributes
foreach (SchemaAttDef attdef in nextElement.AttDefs.Values) {
if (attdef.Presence == SchemaDeclBase.Use.Default ||
attdef.Presence == SchemaDeclBase.Use.Fixed) {
reader.AddDefaultAttribute(attdef);
}
}
}
}
private void ParseElementDecl() {
// element name
if ( GetToken( true ) != Token.QName ) {
goto UnexpectedError;
}
// get schema decl for element
SchemaElementDecl elementDecl = null;
XmlQualifiedName name = GetNameQualified( true );
elementDecl = (SchemaElementDecl)schemaInfo.ElementDecls[name];
if ( elementDecl != null ) {
if ( validate ) {
SendValidationEvent( curPos - name.Name.Length, XmlSeverityType.Error, Res.Sch_DupElementDecl, GetNameString() );
}
}
else {
if ( ( elementDecl = (SchemaElementDecl)schemaInfo.UndeclaredElementDecls[name] ) != null ) {
schemaInfo.UndeclaredElementDecls.Remove( name );
}
else {
elementDecl = new SchemaElementDecl( name, name.Namespace, SchemaType.DTD );
}
schemaInfo.ElementDecls.Add( name, elementDecl );
}
elementDecl.IsDeclaredInExternal = !ParsingInternalSubset;
// content spec
switch ( GetToken( true ) ) {
case Token.EMPTY:
elementDecl.ContentValidator = ContentValidator.Empty;
goto End;
case Token.ANY:
elementDecl.ContentValidator = ContentValidator.Any;
goto End;
case Token.LeftParen:
int startParenEntityId = currentEntityId;
switch ( GetToken( false ) ) {
case Token.PCDATA:
{
ParticleContentValidator pcv = new ParticleContentValidator( XmlSchemaContentType.Mixed );
pcv.Start();
pcv.OpenGroup();
ParseElementMixedContent( pcv, startParenEntityId );
elementDecl.ContentValidator = pcv.Finish( true );
goto End;
}
case Token.None:
{
ParticleContentValidator pcv = null;
pcv = new ParticleContentValidator( XmlSchemaContentType.ElementOnly );
pcv.Start();
pcv.OpenGroup();
ParseElementOnlyContent( pcv, startParenEntityId );
elementDecl.ContentValidator = pcv.Finish( true );
goto End;
}
default:
goto UnexpectedError;
}
default:
goto UnexpectedError;
}
End:
if ( GetToken( false ) != Token.GreaterThan ) {
ThrowUnexpectedToken( curPos, ">" );
}
return;
UnexpectedError:
OnUnexpectedError();
}
private SchemaElementDecl CheckXsiTypeAndNil(SchemaElementDecl elementDecl, string xsiType, string xsiNil, ref bool declFound) {
XmlQualifiedName xsiTypeName = XmlQualifiedName.Empty;
if (xsiType != null) {
object typedVal = null;
Exception exception = dtQName.TryParseValue(xsiType, nameTable, nsResolver, out typedVal);
if (exception != null) {
SendValidationEvent(Res.Sch_InvalidValueDetailedAttribute, new string[] { "type", xsiType, dtQName.TypeCodeString, exception.Message }, exception);
}
else {
xsiTypeName = typedVal as XmlQualifiedName;
}
}
if (elementDecl != null) { //nillable is not dependent on xsi:type.
if (elementDecl.IsNillable) {
if (xsiNil != null) {
context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (context.IsNill && elementDecl.Presence == SchemaDeclBase.Use.Fixed) {
Debug.Assert(elementDecl.DefaultValueTyped != null);
SendValidationEvent(Res.Sch_XsiNilAndFixed);
}
}
}
else if (xsiNil != null) {
SendValidationEvent(Res.Sch_InvalidXsiNill);
}
}
if (xsiTypeName.IsEmpty) {
if (elementDecl != null && elementDecl.IsAbstract) {
SendValidationEvent(Res.Sch_AbstractElement, QNameString(context.LocalName, context.Namespace));
elementDecl = null;
}
}
else {
SchemaElementDecl elementDeclXsi = compiledSchemaInfo.GetTypeDecl(xsiTypeName);
XmlSeverityType severity = XmlSeverityType.Warning;
if (HasSchema && processContents == XmlSchemaContentProcessing.Strict) {
severity = XmlSeverityType.Error;
}
if (elementDeclXsi == null && xsiTypeName.Namespace == NsXs) {
XmlSchemaType schemaType = DatatypeImplementation.GetSimpleTypeFromXsdType(xsiTypeName);
if (schemaType == null) { //try getting complexType - xs:anyType
schemaType = XmlSchemaType.GetBuiltInComplexType(xsiTypeName);
}
if (schemaType != null) {
elementDeclXsi = schemaType.ElementDecl;
}
}
if (elementDeclXsi == null) {
SendValidationEvent(Res.Sch_XsiTypeNotFound, xsiTypeName.ToString(), severity);
elementDecl = null;
}
else {
declFound = true;
if (elementDeclXsi.IsAbstract) {
SendValidationEvent(Res.Sch_XsiTypeAbstract, xsiTypeName.ToString(), severity);
elementDecl = null;
}
else if (elementDecl != null && !XmlSchemaType.IsDerivedFrom(elementDeclXsi.SchemaType,elementDecl.SchemaType,elementDecl.Block)) {
SendValidationEvent(Res.Sch_XsiTypeBlockedEx, new string[] { xsiTypeName.ToString(), QNameString(context.LocalName, context.Namespace) });
elementDecl = null;
}
else {
if (elementDecl != null) { //Get all element decl properties before assigning xsi:type decl; nillable already checked
elementDeclXsi = elementDeclXsi.Clone(); //Before updating properties onto xsi:type decl, clone it
elementDeclXsi.Constraints = elementDecl.Constraints;
elementDeclXsi.DefaultValueRaw = elementDecl.DefaultValueRaw;
elementDeclXsi.DefaultValueTyped = elementDecl.DefaultValueTyped;
elementDeclXsi.Block = elementDecl.Block;
}
context.ElementDeclBeforeXsi = elementDecl;
elementDecl = elementDeclXsi;
}
}
}
return elementDecl;
}
private void CompileComplexType(XmlSchemaComplexType complexType) {
if (complexType.ElementDecl != null) { //already compiled
return;
}
if (complexType.IsProcessing) {
SendValidationEvent(Res.Sch_TypeCircularRef, complexType);
return;
}
complexType.IsProcessing = true;
try {
if (complexType.ContentModel != null) { //simpleContent or complexContent
if (complexType.ContentModel is XmlSchemaSimpleContent) {
XmlSchemaSimpleContent simpleContent = (XmlSchemaSimpleContent)complexType.ContentModel;
complexType.SetContentType(XmlSchemaContentType.TextOnly);
if (simpleContent.Content is XmlSchemaSimpleContentExtension) {
CompileSimpleContentExtension(complexType, (XmlSchemaSimpleContentExtension)simpleContent.Content);
}
else { //simpleContent.Content is XmlSchemaSimpleContentRestriction
CompileSimpleContentRestriction(complexType, (XmlSchemaSimpleContentRestriction)simpleContent.Content);
}
}
else { // complexType.ContentModel is XmlSchemaComplexContent
XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel;
if (complexContent.Content is XmlSchemaComplexContentExtension) {
CompileComplexContentExtension(complexType, complexContent, (XmlSchemaComplexContentExtension)complexContent.Content);
}
else { // complexContent.Content is XmlSchemaComplexContentRestriction
CompileComplexContentRestriction(complexType, complexContent, (XmlSchemaComplexContentRestriction)complexContent.Content);
}
}
}
else { //equals XmlSchemaComplexContent with baseType is anyType
complexType.SetBaseSchemaType(XmlSchemaComplexType.AnyType);
CompileLocalAttributes(XmlSchemaComplexType.AnyType, complexType, complexType.Attributes, complexType.AnyAttribute, XmlSchemaDerivationMethod.Restriction);
complexType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
complexType.SetContentTypeParticle(CompileContentTypeParticle(complexType.Particle));
complexType.SetContentType(GetSchemaContentType(complexType, null, complexType.ContentTypeParticle));
}
if (complexType.ContainsIdAttribute(true)) {
SendValidationEvent(Res.Sch_TwoIdAttrUses, complexType);
}
SchemaElementDecl decl = new SchemaElementDecl();
decl.ContentValidator = CompileComplexContent(complexType);
decl.SchemaType = complexType;
decl.IsAbstract = complexType.IsAbstract;
decl.Datatype = complexType.Datatype;
decl.Block = complexType.BlockResolved;
decl.AnyAttribute = complexType.AttributeWildcard;
foreach(XmlSchemaAttribute attribute in complexType.AttributeUses.Values) {
if (attribute.Use == XmlSchemaUse.Prohibited) {
if (!decl.ProhibitedAttributes.ContainsKey(attribute.QualifiedName)) {
decl.ProhibitedAttributes.Add(attribute.QualifiedName, attribute.QualifiedName);
}
}
else {
if (!decl.AttDefs.ContainsKey(attribute.QualifiedName) && attribute.AttDef != null && attribute.AttDef.Name != XmlQualifiedName.Empty && attribute.AttDef != SchemaAttDef.Empty) {
decl.AddAttDef(attribute.AttDef);
}
}
}
complexType.ElementDecl = decl;
}
finally {
complexType.IsProcessing = false;
}
}
private void CheckRequiredAttributes(SchemaElementDecl currentElementDecl) {
Debug.Assert(currentElementDecl != null);
Dictionary<XmlQualifiedName, SchemaAttDef> attributeDefs = currentElementDecl.AttDefs;
foreach(SchemaAttDef attdef in attributeDefs.Values) {
if (attPresence[attdef.Name] == null) {
if (attdef.Presence == SchemaDeclBase.Use.Required || attdef.Presence == SchemaDeclBase.Use.RequiredFixed) {
SendValidationEvent(Res.Sch_MissRequiredAttribute, attdef.Name.ToString());
}
}
}
}
private SchemaElementDecl CheckXsiTypeAndNil(SchemaElementDecl elementDecl, string xsiType, string xsiNil, ref bool declFound)
{
XmlQualifiedName empty = XmlQualifiedName.Empty;
if (xsiType != null)
{
object typedValue = null;
Exception innerException = dtQName.TryParseValue(xsiType, this.nameTable, this.nsResolver, out typedValue);
if (innerException != null)
{
this.SendValidationEvent("Sch_InvalidValueDetailedAttribute", new string[] { "type", xsiType, dtQName.TypeCodeString, innerException.Message }, innerException);
}
else
{
empty = typedValue as XmlQualifiedName;
}
}
if (elementDecl != null)
{
if (elementDecl.IsNillable)
{
if (xsiNil != null)
{
this.context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (this.context.IsNill && (elementDecl.Presence == SchemaDeclBase.Use.Fixed))
{
this.SendValidationEvent("Sch_XsiNilAndFixed");
}
}
}
else if (xsiNil != null)
{
this.SendValidationEvent("Sch_InvalidXsiNill");
}
}
if (empty.IsEmpty)
{
if ((elementDecl != null) && elementDecl.IsAbstract)
{
this.SendValidationEvent("Sch_AbstractElement", QNameString(this.context.LocalName, this.context.Namespace));
elementDecl = null;
}
return elementDecl;
}
SchemaElementDecl typeDecl = this.compiledSchemaInfo.GetTypeDecl(empty);
XmlSeverityType warning = XmlSeverityType.Warning;
if (this.HasSchema && (this.processContents == XmlSchemaContentProcessing.Strict))
{
warning = XmlSeverityType.Error;
}
if ((typeDecl == null) && (empty.Namespace == this.NsXs))
{
XmlSchemaType simpleTypeFromXsdType = DatatypeImplementation.GetSimpleTypeFromXsdType(empty);
if (simpleTypeFromXsdType == null)
{
simpleTypeFromXsdType = XmlSchemaType.GetBuiltInComplexType(empty);
}
if (simpleTypeFromXsdType != null)
{
typeDecl = simpleTypeFromXsdType.ElementDecl;
}
}
if (typeDecl == null)
{
this.SendValidationEvent("Sch_XsiTypeNotFound", empty.ToString(), warning);
elementDecl = null;
return elementDecl;
}
declFound = true;
if (typeDecl.IsAbstract)
{
this.SendValidationEvent("Sch_XsiTypeAbstract", empty.ToString(), warning);
elementDecl = null;
return elementDecl;
}
if ((elementDecl != null) && !XmlSchemaType.IsDerivedFrom(typeDecl.SchemaType, elementDecl.SchemaType, elementDecl.Block))
{
this.SendValidationEvent("Sch_XsiTypeBlockedEx", new string[] { empty.ToString(), QNameString(this.context.LocalName, this.context.Namespace) });
elementDecl = null;
return elementDecl;
}
if (elementDecl != null)
{
typeDecl = typeDecl.Clone();
typeDecl.Constraints = elementDecl.Constraints;
typeDecl.DefaultValueRaw = elementDecl.DefaultValueRaw;
typeDecl.DefaultValueTyped = elementDecl.DefaultValueTyped;
typeDecl.Block = elementDecl.Block;
}
this.context.ElementDeclBeforeXsi = elementDecl;
elementDecl = typeDecl;
return elementDecl;
}
//
// Static methods
//
#if !SILVERLIGHT
internal static SchemaElementDecl CreateAnyTypeElementDecl()
{
SchemaElementDecl anyTypeElementDecl = new SchemaElementDecl();
anyTypeElementDecl.Datatype = DatatypeImplementation.AnySimpleType.Datatype;
return anyTypeElementDecl;
}
private void ParseAttlistDecl()
{
if (GetToken(true) != Token.QName)
{
goto UnexpectedError;
}
// element name
XmlQualifiedName elementName = GetNameQualified(true);
SchemaElementDecl elementDecl;
if (!_schemaInfo.ElementDecls.TryGetValue(elementName, out elementDecl))
{
if (!_schemaInfo.UndeclaredElementDecls.TryGetValue(elementName, out elementDecl))
{
elementDecl = new SchemaElementDecl(elementName, elementName.Namespace);
_schemaInfo.UndeclaredElementDecls.Add(elementName, elementDecl);
}
}
SchemaAttDef attrDef = null;
for (;;)
{
switch (GetToken(false))
{
case Token.QName:
XmlQualifiedName attrName = GetNameQualified(true);
attrDef = new SchemaAttDef(attrName, attrName.Namespace);
attrDef.IsDeclaredInExternal = !ParsingInternalSubset;
attrDef.LineNumber = (int)LineNo;
attrDef.LinePosition = (int)LinePos - (_curPos - _tokenStartPos);
break;
case Token.GreaterThan:
#if !SILVERLIGHT
if (_v1Compat)
{
// check xml:space and xml:lang
// BUG BUG: For backward compatibility, we check the correct type and values of the
// xml:space attribute only on the last attribute in the list.
// See Webdata bugs #97457 and #93935.
if (attrDef != null && attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml") && attrDef.Name.Name == "space")
{
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
if (attrDef.Datatype.TokenizedType != XmlTokenizedType.ENUMERATION)
{
Throw(SR.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition);
}
if (_validate)
{
attrDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
}
}
}
#endif
return;
default:
goto UnexpectedError;
}
bool attrDefAlreadyExists = (elementDecl.GetAttDef(attrDef.Name) != null);
ParseAttlistType(attrDef, elementDecl, attrDefAlreadyExists);
ParseAttlistDefault(attrDef, attrDefAlreadyExists);
// check xml:space and xml:lang
if (attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml"))
{
if (attrDef.Name.Name == "space")
{
#if !SILVERLIGHT
if (_v1Compat)
{
// BUG BUG: For backward compatibility, we check the correct type and values of the
// xml:space attribute only on the last attribute in the list, and mark it as reserved
// only its value is correct (=prevent XmlTextReader from fhrowing on invalid value).
// See Webdata bugs #98168, #97457 and #93935.
string val = attrDef.DefaultValueExpanded.Trim();
if (val.Equals("preserve") || val.Equals("default"))
{
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
}
}
else
{
#endif
attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
if (attrDef.TokenizedType != XmlTokenizedType.ENUMERATION)
{
Throw(SR.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition);
}
#if !SILVERLIGHT
if (_validate)
{
attrDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
}
}
#endif
}
else if (attrDef.Name.Name == "lang")
{
attrDef.Reserved = SchemaAttDef.Reserve.XmlLang;
}
}
// add attribute to element decl
if (!attrDefAlreadyExists)
{
elementDecl.AddAttDef(attrDef);
}
}
UnexpectedError:
OnUnexpectedError();
}
private SchemaElementDecl ThoroughGetElementDecl(SchemaElementDecl elementDecl, XmlQualifiedName xsiType, string xsiNil)
{
if (elementDecl == null)
{
elementDecl = base.schemaInfo.GetElementDecl(base.elementName);
}
if (elementDecl != null)
{
if (xsiType.IsEmpty)
{
if (elementDecl.IsAbstract)
{
base.SendValidationEvent("Sch_AbstractElement", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
elementDecl = null;
}
}
else if ((xsiNil != null) && xsiNil.Equals("true"))
{
base.SendValidationEvent("Sch_XsiNilAndType");
}
else
{
SchemaElementDecl decl;
if (!base.schemaInfo.ElementDeclsByType.TryGetValue(xsiType, out decl) && (xsiType.Namespace == this.NsXs))
{
XmlSchemaSimpleType simpleTypeFromXsdType = DatatypeImplementation.GetSimpleTypeFromXsdType(new XmlQualifiedName(xsiType.Name, this.NsXs));
if (simpleTypeFromXsdType != null)
{
decl = simpleTypeFromXsdType.ElementDecl;
}
}
if (decl == null)
{
base.SendValidationEvent("Sch_XsiTypeNotFound", xsiType.ToString());
elementDecl = null;
}
else if (!XmlSchemaType.IsDerivedFrom(decl.SchemaType, elementDecl.SchemaType, elementDecl.Block))
{
base.SendValidationEvent("Sch_XsiTypeBlockedEx", new string[] { xsiType.ToString(), XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace) });
elementDecl = null;
}
else
{
elementDecl = decl;
}
}
if ((elementDecl != null) && elementDecl.IsNillable)
{
if (xsiNil != null)
{
base.context.IsNill = XmlConvert.ToBoolean(xsiNil);
if (base.context.IsNill && (elementDecl.DefaultValueTyped != null))
{
base.SendValidationEvent("Sch_XsiNilAndFixed");
}
}
return elementDecl;
}
if (xsiNil != null)
{
base.SendValidationEvent("Sch_InvalidXsiNill");
}
}
return elementDecl;
}
private void ParseElementDecl()
{
// element name
if (GetToken(true) != Token.QName)
{
goto UnexpectedError;
}
// get schema decl for element
SchemaElementDecl elementDecl = null;
XmlQualifiedName name = GetNameQualified(true);
if (_schemaInfo.ElementDecls.TryGetValue(name, out elementDecl))
{
#if !SILVERLIGHT
if (_validate)
{
SendValidationEvent(_curPos - name.Name.Length, XmlSeverityType.Error, SR.Sch_DupElementDecl, GetNameString());
}
#endif
}
else
{
if (_schemaInfo.UndeclaredElementDecls.TryGetValue(name, out elementDecl))
{
_schemaInfo.UndeclaredElementDecls.Remove(name);
}
else
{
elementDecl = new SchemaElementDecl(name, name.Namespace);
}
_schemaInfo.ElementDecls.Add(name, elementDecl);
}
elementDecl.IsDeclaredInExternal = !ParsingInternalSubset;
// content spec
#if SILVERLIGHT
switch ( GetToken( true ) ) {
case Token.EMPTY:
case Token.ANY:
break;
case Token.LeftParen:
switch ( GetToken( false ) ) {
case Token.PCDATA:
ParseElementMixedContentNoValidation();
break;
case Token.None:
ParseElementOnlyContentNoValidation();
break;
default:
goto UnexpectedError;
}
break;
default:
goto UnexpectedError;
}
#else
switch (GetToken(true))
{
case Token.EMPTY:
elementDecl.ContentValidator = ContentValidator.Empty;
break;
case Token.ANY:
elementDecl.ContentValidator = ContentValidator.Any;
break;
case Token.LeftParen:
int startParenEntityId = _currentEntityId;
switch (GetToken(false))
{
case Token.PCDATA:
{
ParticleContentValidator pcv = new ParticleContentValidator(XmlSchemaContentType.Mixed);
pcv.Start();
pcv.OpenGroup();
ParseElementMixedContent(pcv, startParenEntityId);
elementDecl.ContentValidator = pcv.Finish(true);
break;
}
case Token.None:
{
ParticleContentValidator pcv = null;
pcv = new ParticleContentValidator(XmlSchemaContentType.ElementOnly);
pcv.Start();
pcv.OpenGroup();
ParseElementOnlyContent(pcv, startParenEntityId);
elementDecl.ContentValidator = pcv.Finish(true);
break;
}
default:
goto UnexpectedError;
}
break;
default:
goto UnexpectedError;
}
#endif
if (GetToken(false) != Token.GreaterThan)
{
ThrowUnexpectedToken(_curPos, ">");
}
return;
UnexpectedError:
OnUnexpectedError();
}
private void ParseAttlistType(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
{
Token token = GetToken(true);
if (token != Token.CDATA)
{
elementDecl.HasNonCDataAttribute = true;
}
if (IsAttributeValueType(token))
{
attrDef.TokenizedType = (XmlTokenizedType)(int)token;
switch (token)
{
case Token.NOTATION:
break;
case Token.ID:
elementDecl.IsIdDeclared = true;
return;
default:
return;
}
if (GetToken(true) != Token.LeftParen)
{
goto UnexpectedError;
}
// parse notation list
if (GetToken(false) != Token.Name)
{
goto UnexpectedError;
}
for (; ;)
{
string notationName = GetNameString();
switch (GetToken(false))
{
case Token.Or:
if (GetToken(false) != Token.Name)
{
goto UnexpectedError;
}
continue;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else if (token == Token.LeftParen)
{
attrDef.TokenizedType = XmlTokenizedType.ENUMERATION;
// parse nmtoken list
if (GetToken(false) != Token.Nmtoken)
goto UnexpectedError;
for (; ;)
{
switch (GetToken(false))
{
case Token.Or:
if (GetToken(false) != Token.Nmtoken)
goto UnexpectedError;
string nmtoken = GetNmtokenString();
break;
case Token.RightParen:
return;
default:
goto UnexpectedError;
}
}
}
else
{
goto UnexpectedError;
}
UnexpectedError:
OnUnexpectedError();
}
private void CompileSimpleType(XmlSchemaSimpleType simpleType)
{
if (simpleType.IsProcessing)
{
throw new XmlSchemaException("Sch_TypeCircularRef", simpleType);
}
if (simpleType.ElementDecl == null)
{
simpleType.IsProcessing = true;
try
{
if (simpleType.Content is XmlSchemaSimpleTypeList)
{
XmlSchemaDatatype datatype;
XmlSchemaSimpleTypeList content = (XmlSchemaSimpleTypeList) simpleType.Content;
simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
if (content.ItemTypeName.IsEmpty)
{
this.CompileSimpleType(content.ItemType);
content.BaseItemType = content.ItemType;
datatype = content.ItemType.Datatype;
}
else
{
XmlSchemaSimpleType type = this.GetSimpleType(content.ItemTypeName);
if (type == null)
{
throw new XmlSchemaException("Sch_UndeclaredSimpleType", content.ItemTypeName.ToString(), simpleType);
}
if ((type.FinalResolved & XmlSchemaDerivationMethod.List) != XmlSchemaDerivationMethod.Empty)
{
base.SendValidationEvent("Sch_BaseFinalList", simpleType);
}
content.BaseItemType = type;
datatype = type.Datatype;
}
simpleType.SetDatatype(datatype.DeriveByList(simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.List);
}
else if (simpleType.Content is XmlSchemaSimpleTypeRestriction)
{
XmlSchemaDatatype datatype2;
XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) simpleType.Content;
if (restriction.BaseTypeName.IsEmpty)
{
this.CompileSimpleType(restriction.BaseType);
simpleType.SetBaseSchemaType(restriction.BaseType);
datatype2 = restriction.BaseType.Datatype;
}
else if ((simpleType.Redefined != null) && (restriction.BaseTypeName == simpleType.Redefined.QualifiedName))
{
this.CompileSimpleType((XmlSchemaSimpleType) simpleType.Redefined);
simpleType.SetBaseSchemaType(simpleType.Redefined.BaseXmlSchemaType);
datatype2 = simpleType.Redefined.Datatype;
}
else
{
if (restriction.BaseTypeName.Equals(DatatypeImplementation.QnAnySimpleType))
{
throw new XmlSchemaException("Sch_InvalidSimpleTypeRestriction", restriction.BaseTypeName.ToString(), simpleType);
}
XmlSchemaSimpleType type2 = this.GetSimpleType(restriction.BaseTypeName);
if (type2 == null)
{
throw new XmlSchemaException("Sch_UndeclaredSimpleType", restriction.BaseTypeName.ToString(), simpleType);
}
if ((type2.FinalResolved & XmlSchemaDerivationMethod.Restriction) != XmlSchemaDerivationMethod.Empty)
{
base.SendValidationEvent("Sch_BaseFinalRestriction", simpleType);
}
simpleType.SetBaseSchemaType(type2);
datatype2 = type2.Datatype;
}
simpleType.SetDatatype(datatype2.DeriveByRestriction(restriction.Facets, base.NameTable, simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
}
else
{
XmlSchemaSimpleType[] types = this.CompileBaseMemberTypes(simpleType);
simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
simpleType.SetDatatype(XmlSchemaDatatype.DeriveByUnion(types, simpleType));
simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Union);
}
}
catch (XmlSchemaException exception)
{
if (exception.SourceSchemaObject == null)
{
exception.SetSource(simpleType);
}
base.SendValidationEvent(exception);
simpleType.SetDatatype(DatatypeImplementation.AnySimpleType.Datatype);
}
finally
{
SchemaElementDecl decl = new SchemaElementDecl {
ContentValidator = ContentValidator.TextOnly,
SchemaType = simpleType,
Datatype = simpleType.Datatype
};
simpleType.ElementDecl = decl;
simpleType.IsProcessing = false;
}
}
}
internal SchemaAttDef GetAttributeXdr(SchemaElementDecl ed, XmlQualifiedName qname) {
SchemaAttDef attdef = null;
if (ed != null) {
attdef = ed.GetAttDef(qname);;
if (attdef == null) {
if (!ed.ContentValidator.IsOpen || qname.Namespace.Length == 0) {
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
if (!attributeDecls.TryGetValue(qname, out attdef) && targetNamespaces.ContainsKey(qname.Namespace)) {
throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
}
}
}
return attdef;
}
