internal void CheckXmlSpace(IValidationEventHandling validationEventHandling)
{
if (((base.datatype.TokenizedType == XmlTokenizedType.ENUMERATION) && (base.values != null)) && (base.values.Count <= 2))
{
string str = base.values[0].ToString();
if (base.values.Count == 2)
{
string str2 = base.values[1].ToString();
if (((str == "default") || (str2 == "default")) && ((str == "preserve") || (str2 == "preserve")))
{
return;
}
}
else
{
switch (str)
{
case "default":
case "preserve":
return;
}
}
}
validationEventHandling.SendEvent(new XmlSchemaException("Sch_XmlSpace", string.Empty), XmlSeverityType.Error);
}
public static void SetDefaultTypedValue(SchemaAttDef attdef, IDtdParserAdapter readerAdapter)
{
try
{
string defaultValueExpanded = attdef.DefaultValueExpanded;
XmlSchemaDatatype datatype = attdef.Datatype;
if (datatype != null)
{
if (datatype.TokenizedType != XmlTokenizedType.CDATA)
{
defaultValueExpanded = defaultValueExpanded.Trim();
}
attdef.DefaultValueTyped = datatype.ParseValue(defaultValueExpanded, readerAdapter.NameTable, readerAdapter.NamespaceResolver);
}
}
catch (Exception)
{
IValidationEventHandling validationEventHandling = ((IDtdParserAdapterWithValidation)readerAdapter).ValidationEventHandling;
if (validationEventHandling != null)
{
XmlSchemaException exception = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString());
validationEventHandling.SendEvent(exception, XmlSeverityType.Error);
}
}
}
public static void SetDefaultTypedValue(
SchemaAttDef attdef,
IDtdParserAdapter readerAdapter
)
{
try {
string value = attdef.DefaultValueExpanded;
XmlSchemaDatatype dtype = attdef.Datatype;
if (dtype == null)
{
return; // no reason to check
}
if (dtype.TokenizedType != XmlTokenizedType.CDATA)
{
value = value.Trim();
}
attdef.DefaultValueTyped = dtype.ParseValue(value, readerAdapter.NameTable, readerAdapter.NamespaceResolver);
}
#if DEBUG
catch (XmlSchemaException ex) {
Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message);
#else
catch (Exception) {
#endif
IValidationEventHandling eventHandling = ((IDtdParserAdapterWithValidation)readerAdapter).ValidationEventHandling;
if (eventHandling != null)
{
XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString());
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
}
}
protected static void ProcessEntity(SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition)
{
SchemaEntity en;
string errorResId = null;
if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en))
{
// validation error, see xml spec [68]
errorResId = SR.Sch_UndeclaredEntity;
}
else if (en.NData.IsEmpty)
{
errorResId = SR.Sch_UnparsedEntityRef;
}
if (errorResId != null)
{
XmlSchemaException e = new XmlSchemaException(errorResId, name, baseUriStr, lineNumber, linePosition);
if (eventHandling != null)
{
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
else
{
throw e;
}
}
}
internal void CheckXmlSpace(IValidationEventHandling validationEventHandling)
{
if (((base.datatype.TokenizedType == XmlTokenizedType.ENUMERATION) && (base.values != null)) && (base.values.Count <= 2))
{
string str = base.values[0].ToString();
if (base.values.Count == 2)
{
string str2 = base.values[1].ToString();
if (((str == "default") || (str2 == "default")) && ((str == "preserve") || (str2 == "preserve")))
{
return;
}
}
else
{
switch (str)
{
case "default":
case "preserve":
return;
}
}
}
validationEventHandling.SendEvent(new XmlSchemaException("Sch_XmlSpace", string.Empty), XmlSeverityType.Error);
}
internal void CheckXmlSpace(IValidationEventHandling validationEventHandling)
{
if (datatype.TokenizedType == XmlTokenizedType.ENUMERATION &&
(values != null) &&
(values.Count <= 2))
{
string s1 = values[0].ToString();
if (values.Count == 2)
{
string s2 = values[1].ToString();
if ((s1 == "default" || s2 == "default") &&
(s1 == "preserve" || s2 == "preserve"))
{
return;
}
}
else
{
if (s1 == "default" || s1 == "preserve")
{
return;
}
}
}
validationEventHandling.SendEvent(new XmlSchemaException(SR.Sch_XmlSpace, string.Empty), XmlSeverityType.Error);
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling)
{
this.reader = reader;
this.schemaCollection = schemaCollection;
this.eventHandling = eventHandling;
this.nameTable = reader.NameTable;
this.positionInfo = System.Xml.PositionInfo.GetPositionInfo(reader);
this.elementName = new XmlQualifiedName();
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling)
{
this.reader = reader;
this.schemaCollection = schemaCollection;
this.eventHandling = eventHandling;
this.nameTable = reader.NameTable;
this.positionInfo = System.Xml.PositionInfo.GetPositionInfo(reader);
this.elementName = new XmlQualifiedName();
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) {
Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
this.reader = reader;
this.schemaCollection = schemaCollection;
this.eventHandling = eventHandling;
nameTable = reader.NameTable;
positionInfo = PositionInfo.GetPositionInfo(reader);
elementName = new XmlQualifiedName();
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling)
{
Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
this.reader = reader;
_schemaCollection = schemaCollection;
_eventHandling = eventHandling;
_nameTable = reader.NameTable;
_positionInfo = PositionInfo.GetPositionInfo(reader);
elementName = new XmlQualifiedName();
}
public BaseValidator(BaseValidator other) {
reader = other.reader;
schemaCollection = other.schemaCollection;
eventHandling = other.eventHandling;
nameTable = other.nameTable;
schemaNames = other.schemaNames;
positionInfo = other.positionInfo;
xmlResolver = other.xmlResolver;
baseUri = other.baseUri;
elementName = other.elementName;
}
public BaseValidator(BaseValidator other)
{
this.reader = other.reader;
this.schemaCollection = other.schemaCollection;
this.eventHandling = other.eventHandling;
this.nameTable = other.nameTable;
this.schemaNames = other.schemaNames;
this.positionInfo = other.positionInfo;
this.xmlResolver = other.xmlResolver;
this.baseUri = other.baseUri;
this.elementName = other.elementName;
}
public BaseValidator(BaseValidator other)
{
reader = other.reader;
_schemaCollection = other._schemaCollection;
_eventHandling = other._eventHandling;
_nameTable = other._nameTable;
_schemaNames = other._schemaNames;
_positionInfo = other._positionInfo;
_xmlResolver = other._xmlResolver;
_baseUri = other._baseUri;
elementName = other.elementName;
}
public BaseValidator(BaseValidator other)
{
this.reader = other.reader;
this.schemaCollection = other.schemaCollection;
this.eventHandling = other.eventHandling;
this.nameTable = other.nameTable;
this.schemaNames = other.schemaNames;
this.positionInfo = other.positionInfo;
this.xmlResolver = other.xmlResolver;
this.baseUri = other.baseUri;
this.elementName = other.elementName;
}
public BaseValidator(BaseValidator other)
{
reader = other.reader;
_schemaCollection = other._schemaCollection;
_eventHandling = other._eventHandling;
_nameTable = other._nameTable;
_schemaNames = other._schemaNames;
_positionInfo = other._positionInfo;
_xmlResolver = other._xmlResolver;
_baseUri = other._baseUri;
elementName = other.elementName;
}
public BaseValidator(BaseValidator other)
{
reader = other.reader;
schemaCollection = other.schemaCollection;
eventHandling = other.eventHandling;
nameTable = other.nameTable;
schemaNames = other.schemaNames;
positionInfo = other.positionInfo;
xmlResolver = other.xmlResolver;
baseUri = other.baseUri;
elementName = other.elementName;
}
public static void CheckDefaultValue(SchemaAttDef attdef, SchemaInfo sinfo, IValidationEventHandling eventHandling, string baseUriStr)
{
try
{
if (baseUriStr == null)
{
baseUriStr = string.Empty;
}
XmlSchemaDatatype datatype = attdef.Datatype;
if (datatype != null)
{
object defaultValueTyped = attdef.DefaultValueTyped;
XmlTokenizedType tokenizedType = datatype.TokenizedType;
if (tokenizedType == XmlTokenizedType.ENTITY)
{
if (datatype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] strArray = (string[]) defaultValueTyped;
for (int i = 0; i < strArray.Length; i++)
{
BaseValidator.ProcessEntity(sinfo, strArray[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else
{
BaseValidator.ProcessEntity(sinfo, (string) defaultValueTyped, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else if (((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(defaultValueTyped)) && (eventHandling != null))
{
XmlSchemaException exception = new XmlSchemaException("Sch_EnumerationValue", defaultValueTyped.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
eventHandling.SendEvent(exception, XmlSeverityType.Error);
}
}
}
catch (Exception)
{
if (eventHandling != null)
{
XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString());
eventHandling.SendEvent(exception2, XmlSeverityType.Error);
}
}
}
public static void CheckDefaultValue(SchemaAttDef attdef, SchemaInfo sinfo, IValidationEventHandling eventHandling, string baseUriStr)
{
try
{
if (baseUriStr == null)
{
baseUriStr = string.Empty;
}
XmlSchemaDatatype datatype = attdef.Datatype;
if (datatype != null)
{
object defaultValueTyped = attdef.DefaultValueTyped;
XmlTokenizedType tokenizedType = datatype.TokenizedType;
if (tokenizedType == XmlTokenizedType.ENTITY)
{
if (datatype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] strArray = (string[])defaultValueTyped;
for (int i = 0; i < strArray.Length; i++)
{
BaseValidator.ProcessEntity(sinfo, strArray[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else
{
BaseValidator.ProcessEntity(sinfo, (string)defaultValueTyped, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else if (((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(defaultValueTyped)) && (eventHandling != null))
{
XmlSchemaException exception = new XmlSchemaException("Sch_EnumerationValue", defaultValueTyped.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
eventHandling.SendEvent(exception, XmlSeverityType.Error);
}
}
}
catch (Exception)
{
if (eventHandling != null)
{
XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString());
eventHandling.SendEvent(exception2, XmlSeverityType.Error);
}
}
}
public static BaseValidator CreateInstance(ValidationType valType, XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling, bool processIdentityConstraints)
{
switch (valType)
{
case ValidationType.None:
return new BaseValidator(reader, schemaCollection, eventHandling);
case ValidationType.Auto:
return new AutoValidator(reader, schemaCollection, eventHandling);
case ValidationType.DTD:
return new DtdValidator(reader, eventHandling, processIdentityConstraints);
case ValidationType.XDR:
return new XdrValidator(reader, schemaCollection, eventHandling);
case ValidationType.Schema:
return new XsdValidator(reader, schemaCollection, eventHandling);
}
return null;
}
protected static void ProcessEntity(System.Xml.Schema.SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition)
{
SchemaEntity entity;
string res = null;
if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out entity))
{
res = "Sch_UndeclaredEntity";
}
else if (entity.NData.IsEmpty)
{
res = "Sch_UnparsedEntityRef";
}
if (res != null)
{
XmlSchemaException exception = new XmlSchemaException(res, name, baseUriStr, lineNumber, linePosition);
if (eventHandling == null)
{
throw exception;
}
eventHandling.SendEvent(exception, XmlSeverityType.Error);
}
}
public AutoValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
schemaInfo = new SchemaInfo();
}
protected static void ProcessEntity(SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition) {
SchemaEntity en;
string errorResId = null;
if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) {
// validation error, see xml spec [68]
errorResId = Res.Sch_UndeclaredEntity;
}
else if (en.NData.IsEmpty) {
errorResId = Res.Sch_UnparsedEntityRef;
}
if (errorResId != null) {
XmlSchemaException e = new XmlSchemaException(errorResId, name, baseUriStr, lineNumber, linePosition);
if (eventHandling != null) {
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
else {
throw e;
}
}
}
internal DtdValidator(XmlValidatingReaderImpl reader, IValidationEventHandling eventHandling, bool processIdentityConstraints) : base(reader, null, eventHandling)
{
_processIdentityConstraints = processIdentityConstraints;
Init();
}
public static void CheckDefaultValue(
SchemaAttDef attdef,
SchemaInfo sinfo,
IValidationEventHandling eventHandling,
string baseUriStr
) {
try {
if (baseUriStr == null) {
baseUriStr = string.Empty;
}
XmlSchemaDatatype dtype = attdef.Datatype;
if (dtype == null) {
return; // no reason to check
}
object typedValue = attdef.DefaultValueTyped;
// Check special types
XmlTokenizedType ttype = dtype.TokenizedType;
if (ttype == XmlTokenizedType.ENTITY) {
if (dtype.Variety == XmlSchemaDatatypeVariety.List) {
string[] ss = (string[])typedValue;
for (int i = 0; i < ss.Length; ++i) {
ProcessEntity(sinfo, ss[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else {
ProcessEntity(sinfo, (string)typedValue, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else if (ttype == XmlTokenizedType.ENUMERATION) {
if (!attdef.CheckEnumeration(typedValue)) {
if (eventHandling != null) {
XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
}
}
}
#if DEBUG
catch (XmlSchemaException ex) {
Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message);
#else
catch (Exception) {
#endif
if (eventHandling != null) {
XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString());
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
}
}
public static void CheckDefaultValue(
SchemaAttDef attdef,
SchemaInfo sinfo,
IValidationEventHandling eventHandling,
string baseUriStr
)
{
try {
if (baseUriStr == null)
{
baseUriStr = string.Empty;
}
XmlSchemaDatatype dtype = attdef.Datatype;
if (dtype == null)
{
return; // no reason to check
}
object typedValue = attdef.DefaultValueTyped;
// Check special types
XmlTokenizedType ttype = dtype.TokenizedType;
if (ttype == XmlTokenizedType.ENTITY)
{
if (dtype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] ss = (string[])typedValue;
for (int i = 0; i < ss.Length; ++i)
{
ProcessEntity(sinfo, ss[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else
{
ProcessEntity(sinfo, (string)typedValue, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
}
}
else if (ttype == XmlTokenizedType.ENUMERATION)
{
if (!attdef.CheckEnumeration(typedValue))
{
if (eventHandling != null)
{
XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition);
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
}
}
}
#if DEBUG
catch (XmlSchemaException ex) {
Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message);
#else
catch (Exception) {
#endif
if (eventHandling != null)
{
XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString());
eventHandling.SendEvent(e, XmlSeverityType.Error);
}
}
}
protected static void ProcessEntity(System.Xml.Schema.SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition)
{
SchemaEntity entity;
string res = null;
if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out entity))
{
res = "Sch_UndeclaredEntity";
}
else if (entity.NData.IsEmpty)
{
res = "Sch_UnparsedEntityRef";
}
if (res != null)
{
XmlSchemaException exception = new XmlSchemaException(res, name, baseUriStr, lineNumber, linePosition);
if (eventHandling == null)
{
throw exception;
}
eventHandling.SendEvent(exception, XmlSeverityType.Error);
}
}
internal DtdValidator(XmlValidatingReaderImpl reader, IValidationEventHandling eventHandling, bool processIdentityConstraints) : base(reader, null, eventHandling)
{
this.name = XmlQualifiedName.Empty;
this.processIdentityConstraints = processIdentityConstraints;
this.Init();
}
internal XsdValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
this.startIDConstraint = -1;
this.Init();
}
internal XsdValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
this.startIDConstraint = -1;
this.Init();
}
internal XsdValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
Init();
}
internal XdrValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
this.name = XmlQualifiedName.Empty;
this.Init();
}
internal XdrValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling) {
Init();
}
internal XdrValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
this.name = XmlQualifiedName.Empty;
this.Init();
}
public static BaseValidator CreateInstance(ValidationType valType, XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling, bool processIdentityConstraints)
{
switch (valType)
{
case ValidationType.XDR:
return(new XdrValidator(reader, schemaCollection, eventHandling));
case ValidationType.Schema:
return(new XsdValidator(reader, schemaCollection, eventHandling));
case ValidationType.DTD:
return(new DtdValidator(reader, eventHandling, processIdentityConstraints));
case ValidationType.Auto:
return(new AutoValidator(reader, schemaCollection, eventHandling));
case ValidationType.None:
return(new BaseValidator(reader, schemaCollection, eventHandling));
default:
break;
}
return(null);
}
public AutoValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling)
{
schemaInfo = new SchemaInfo();
}
internal DtdValidator(XmlValidatingReaderImpl reader, IValidationEventHandling eventHandling, bool processIdentityConstraints) : base(reader, null, eventHandling)
{
this.name = XmlQualifiedName.Empty;
this.processIdentityConstraints = processIdentityConstraints;
this.Init();
}
internal DtdValidator(XmlValidatingReaderImpl reader, IValidationEventHandling eventHandling, bool processIdentityConstraints) : base(reader, null, eventHandling) {
this.processIdentityConstraints = processIdentityConstraints;
Init();
}