private void CheckValue(string value, SchemaAttDef attdef)
{
try
{
base.reader.TypedValueObject = null;
bool flag = attdef != null;
XmlSchemaDatatype datatype = flag ? attdef.Datatype : base.context.ElementDecl.Datatype;
if (datatype != null)
{
object pVal = datatype.ParseValue(value, base.NameTable, this.nsManager, true);
switch (datatype.TokenizedType)
{
case XmlTokenizedType.ENTITY:
case XmlTokenizedType.ID:
case XmlTokenizedType.IDREF:
if (datatype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] strArray = (string[])pVal;
for (int i = 0; i < strArray.Length; i++)
{
this.ProcessTokenizedType(datatype.TokenizedType, strArray[i]);
}
}
else
{
this.ProcessTokenizedType(datatype.TokenizedType, (string)pVal);
}
break;
}
SchemaDeclBase base2 = flag ? ((SchemaDeclBase)attdef) : ((SchemaDeclBase)base.context.ElementDecl);
if (!base2.CheckValue(pVal))
{
if (flag)
{
base.SendValidationEvent("Sch_FixedAttributeValue", attdef.Name.ToString());
}
else
{
base.SendValidationEvent("Sch_FixedElementValue", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
}
if (datatype.Variety == XmlSchemaDatatypeVariety.Union)
{
pVal = this.UnWrapUnion(pVal);
}
base.reader.TypedValueObject = pVal;
}
}
catch (XmlSchemaException)
{
if (attdef != null)
{
base.SendValidationEvent("Sch_AttributeValueDataType", attdef.Name.ToString());
}
else
{
base.SendValidationEvent("Sch_ElementValueDataType", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
}
}
private string GetTypeName(SchemaDeclBase decl)
{
string typeCodeString = decl.SchemaType.QualifiedName.ToString();
if (typeCodeString.Length == 0)
{
typeCodeString = decl.Datatype.TypeCodeString;
}
return typeCodeString;
}
private bool IsFixedEqual(SchemaDeclBase baseDecl, SchemaDeclBase derivedDecl) {
if (baseDecl.Presence == SchemaDeclBase.Use.Fixed || baseDecl.Presence == SchemaDeclBase.Use.RequiredFixed) {
object baseFixedValue = baseDecl.DefaultValueTyped;
object derivedFixedValue = derivedDecl.DefaultValueTyped;
Debug.Assert(baseFixedValue != null);
if (derivedDecl.Presence != SchemaDeclBase.Use.Fixed && derivedDecl.Presence != SchemaDeclBase.Use.RequiredFixed) {
return false;
}
Debug.Assert(derivedFixedValue != null);
XmlSchemaDatatype baseDatatype = baseDecl.Datatype;
XmlSchemaDatatype derivedDatatype = derivedDecl.Datatype;
if (baseDatatype.Variety == XmlSchemaDatatypeVariety.Union) {
if (derivedDatatype.Variety == XmlSchemaDatatypeVariety.Union) {
if ( !derivedDatatype.IsEqual(baseFixedValue, derivedFixedValue) ) {
return false;
}
}
else { //Base is union and derived is member of union
XsdSimpleValue simpleFixedValue = baseDecl.DefaultValueTyped as XsdSimpleValue;
Debug.Assert(simpleFixedValue != null);
XmlSchemaDatatype memberType = simpleFixedValue.XmlType.Datatype;
if (!memberType.IsComparable(derivedDatatype) || !derivedDatatype.IsEqual(simpleFixedValue.TypedValue, derivedFixedValue)) { //base type {Union of long & string}, derived type {int}
return false;
}
}
}
else if (!derivedDatatype.IsEqual(baseFixedValue, derivedFixedValue)) {
return false;
}
}
return true;
}
private void CheckValue(
string value,
SchemaAttDef attdef
)
{
try {
reader.TypedValueObject = null;
bool isAttn = attdef != null;
XmlSchemaDatatype dtype = isAttn ? attdef.Datatype : context.ElementDecl.Datatype;
if (dtype == null)
{
return; // no reason to check
}
object typedValue = dtype.ParseValue(value, NameTable, nsManager, true);
// Check special types
XmlTokenizedType ttype = dtype.TokenizedType;
if (ttype == XmlTokenizedType.ENTITY || ttype == XmlTokenizedType.ID || ttype == XmlTokenizedType.IDREF)
{
if (dtype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] ss = (string[])typedValue;
for (int i = 0; i < ss.Length; ++i)
{
ProcessTokenizedType(dtype.TokenizedType, ss[i]);
}
}
else
{
ProcessTokenizedType(dtype.TokenizedType, (string)typedValue);
}
}
SchemaDeclBase decl = isAttn ? (SchemaDeclBase)attdef : (SchemaDeclBase)context.ElementDecl;
if (!decl.CheckValue(typedValue))
{
if (isAttn)
{
SendValidationEvent(Res.Sch_FixedAttributeValue, attdef.Name.ToString());
}
else
{
SendValidationEvent(Res.Sch_FixedElementValue, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
}
if (dtype.Variety == XmlSchemaDatatypeVariety.Union)
{
typedValue = UnWrapUnion(typedValue);
}
reader.TypedValueObject = typedValue;
}
catch (XmlSchemaException) {
if (attdef != null)
{
SendValidationEvent(Res.Sch_AttributeValueDataType, attdef.Name.ToString());
}
else
{
SendValidationEvent(Res.Sch_ElementValueDataType, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
}
}
private string GetTypeName(SchemaDeclBase decl) {
Debug.Assert(decl != null && decl.SchemaType != null);
string typeName = decl.SchemaType.QualifiedName.ToString();
if (typeName.Length == 0) {
typeName = decl.Datatype.TypeCodeString;
}
return typeName;
}
private void CheckValue(string value, SchemaAttDef attdef)
{
try
{
base.reader.TypedValueObject = null;
bool flag = attdef != null;
XmlSchemaDatatype datatype = flag ? attdef.Datatype : base.context.ElementDecl.Datatype;
if (datatype != null)
{
if (datatype.TokenizedType != XmlTokenizedType.CDATA)
{
value = value.Trim();
}
if (value.Length != 0)
{
object pVal = datatype.ParseValue(value, base.NameTable, this.nsManager);
base.reader.TypedValueObject = pVal;
switch (datatype.TokenizedType)
{
case XmlTokenizedType.ENTITY:
case XmlTokenizedType.ID:
case XmlTokenizedType.IDREF:
if (datatype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] strArray = (string[])pVal;
for (int i = 0; i < strArray.Length; i++)
{
this.ProcessTokenizedType(datatype.TokenizedType, strArray[i]);
}
}
else
{
this.ProcessTokenizedType(datatype.TokenizedType, (string)pVal);
}
break;
}
SchemaDeclBase base2 = flag ? ((SchemaDeclBase)attdef) : ((SchemaDeclBase)base.context.ElementDecl);
if ((base2.MaxLength != 0xffffffffL) && (value.Length > base2.MaxLength))
{
base.SendValidationEvent("Sch_MaxLengthConstraintFailed", value);
}
if ((base2.MinLength != 0xffffffffL) && (value.Length < base2.MinLength))
{
base.SendValidationEvent("Sch_MinLengthConstraintFailed", value);
}
if ((base2.Values != null) && !base2.CheckEnumeration(pVal))
{
if (datatype.TokenizedType == XmlTokenizedType.NOTATION)
{
base.SendValidationEvent("Sch_NotationValue", pVal.ToString());
}
else
{
base.SendValidationEvent("Sch_EnumerationValue", pVal.ToString());
}
}
if (!base2.CheckValue(pVal))
{
if (flag)
{
base.SendValidationEvent("Sch_FixedAttributeValue", attdef.Name.ToString());
}
else
{
base.SendValidationEvent("Sch_FixedElementValue", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
}
}
}
}
catch (XmlSchemaException)
{
if (attdef != null)
{
base.SendValidationEvent("Sch_AttributeValueDataType", attdef.Name.ToString());
}
else
{
base.SendValidationEvent("Sch_ElementValueDataType", XmlSchemaValidator.QNameString(base.context.LocalName, base.context.Namespace));
}
}
}
private void CheckValue(
string value,
SchemaAttDef attdef
)
{
try
{
reader.TypedValueObject = null;
bool isAttn = attdef != null;
XmlSchemaDatatype dtype = isAttn ? attdef.Datatype : context.ElementDecl.Datatype;
if (dtype == null)
{
return; // no reason to check
}
if (dtype.TokenizedType != XmlTokenizedType.CDATA)
{
value = value.Trim();
}
if (value.Length == 0)
{
return; // don't need to check
}
object typedValue = dtype.ParseValue(value, NameTable, _nsManager);
reader.TypedValueObject = typedValue;
// Check special types
XmlTokenizedType ttype = dtype.TokenizedType;
if (ttype == XmlTokenizedType.ENTITY || ttype == XmlTokenizedType.ID || ttype == XmlTokenizedType.IDREF)
{
if (dtype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] ss = (string[])typedValue;
for (int i = 0; i < ss.Length; ++i)
{
ProcessTokenizedType(dtype.TokenizedType, ss[i]);
}
}
else
{
ProcessTokenizedType(dtype.TokenizedType, (string)typedValue);
}
}
SchemaDeclBase decl = isAttn ? (SchemaDeclBase)attdef : (SchemaDeclBase)context.ElementDecl;
if (decl.MaxLength != uint.MaxValue)
{
if (value.Length > decl.MaxLength)
{
SendValidationEvent(SR.Sch_MaxLengthConstraintFailed, value);
}
}
if (decl.MinLength != uint.MaxValue)
{
if (value.Length < decl.MinLength)
{
SendValidationEvent(SR.Sch_MinLengthConstraintFailed, value);
}
}
if (decl.Values != null && !decl.CheckEnumeration(typedValue))
{
if (dtype.TokenizedType == XmlTokenizedType.NOTATION)
{
SendValidationEvent(SR.Sch_NotationValue, typedValue.ToString());
}
else
{
SendValidationEvent(SR.Sch_EnumerationValue, typedValue.ToString());
}
}
if (!decl.CheckValue(typedValue))
{
if (isAttn)
{
SendValidationEvent(SR.Sch_FixedAttributeValue, attdef.Name.ToString());
}
else
{
SendValidationEvent(SR.Sch_FixedElementValue, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
}
}
catch (XmlSchemaException)
{
if (attdef != null)
{
SendValidationEvent(SR.Sch_AttributeValueDataType, attdef.Name.ToString());
}
else
{
SendValidationEvent(SR.Sch_ElementValueDataType, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
}
}
}
private bool IsFixedEqual(SchemaDeclBase baseDecl, SchemaDeclBase derivedDecl)
{
if ((baseDecl.Presence == SchemaDeclBase.Use.Fixed) || (baseDecl.Presence == SchemaDeclBase.Use.RequiredFixed))
{
object defaultValueTyped = baseDecl.DefaultValueTyped;
object obj3 = derivedDecl.DefaultValueTyped;
if ((derivedDecl.Presence != SchemaDeclBase.Use.Fixed) && (derivedDecl.Presence != SchemaDeclBase.Use.RequiredFixed))
{
return false;
}
XmlSchemaDatatype datatype = baseDecl.Datatype;
XmlSchemaDatatype dtype = derivedDecl.Datatype;
if (datatype.Variety == XmlSchemaDatatypeVariety.Union)
{
if (dtype.Variety != XmlSchemaDatatypeVariety.Union)
{
XsdSimpleValue value2 = baseDecl.DefaultValueTyped as XsdSimpleValue;
if (!value2.XmlType.Datatype.IsComparable(dtype) || !dtype.IsEqual(value2.TypedValue, obj3))
{
return false;
}
}
else if (!dtype.IsEqual(defaultValueTyped, obj3))
{
return false;
}
}
else if (!dtype.IsEqual(defaultValueTyped, obj3))
{
return false;
}
}
return true;
}
