private void ProcessException(System.Xml.Schema.XmlSchemaException ex) { // If stack traces is empty then... if (ex.StackTrace == null) { try { throw new System.Xml.Schema.XmlSchemaException(ex.Message, ex, ex.LineNumber, ex.LinePosition); } catch (System.Xml.Schema.XmlSchemaException ex1) { //Dim remoteStackTraceString As Reflection.FieldInfo = GetType(Exception).GetField("_remoteStackTraceString", Reflection.BindingFlags.Instance Or Reflection.BindingFlags.NonPublic) // to the current InnerException.StackTrace //remoteStackTraceString.SetValue(ex, New StackTrace(True).ToString()) ex = ex1; } } Exceptions.Add(ex); ex.Data.Add("XSD", _xsd); if (!string.IsNullOrEmpty(_xmlPath)) { ex.Data.Add("XML Path", _xmlPath); } if (_xml.Length > 8192) { ex.Data.Add("XML Size", _xml.Length.ToString("#,##0")); _xml = _xml.Substring(0, 8192); } ex.Data.Add("XML", _xml); }
public void DenyUnrestricted () { // can we call everything without a SecurityException ? XmlSchemaException xe = new XmlSchemaException (String.Empty, null); Assert.AreEqual (0, xe.LineNumber, "LineNumber"); Assert.AreEqual (0, xe.LinePosition, "LinePosition"); Assert.IsNotNull (xe.Message, "Message"); Assert.IsNull (xe.SourceSchemaObject, "SourceSchemaObject"); Assert.IsNull (xe.SourceUri, "SourceUri"); }
protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { if (this.eventHandling != null) { this.eventHandling.SendEvent(e, severity); } else if (severity == XmlSeverityType.Error) { throw e; } }
private void SendValidationEvent(XmlSchemaException e) { if (validationEventHandler != null) { validationEventHandler(this, new ValidationEventArgs(e)); } else { throw e; } }
protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { if (eventHandler != null) { eventHandler(reader, new ValidationEventArgs(e, severity)); } else if (severity == XmlSeverityType.Error) { throw e; } }
protected void SendValidationEventNoThrow(XmlSchemaException e, XmlSeverityType severity) { if (severity == XmlSeverityType.Error) { _errorCount++; } if (_eventHandler != null) { _eventHandler(null, new ValidationEventArgs(e, severity)); } }
public static void CheckDefaultValue(string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos) { try { XmlSchemaDatatype datatype = attdef.Datatype; if (datatype != null) { if (datatype.TokenizedType != XmlTokenizedType.CDATA) { value = value.Trim(); } if (value.Length != 0) { object pVal = datatype.ParseValue(value, NameTable, nsManager); XmlTokenizedType tokenizedType = datatype.TokenizedType; if (tokenizedType == XmlTokenizedType.ENTITY) { if (datatype.Variety == XmlSchemaDatatypeVariety.List) { string[] strArray = (string[]) pVal; for (int i = 0; i < strArray.Length; i++) { BaseValidator.ProcessEntity(sinfo, strArray[i], sender, eventhandler, baseUri, lineNo, linePos); } } else { BaseValidator.ProcessEntity(sinfo, (string) pVal, sender, eventhandler, baseUri, lineNo, linePos); } } else if ((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(pVal)) { XmlSchemaException ex = new XmlSchemaException("Sch_EnumerationValue", pVal.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw ex; } eventhandler(sender, new ValidationEventArgs(ex)); } attdef.DefaultValueTyped = pVal; } } } catch { XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw exception2; } eventhandler(sender, new ValidationEventArgs(exception2)); } }
public static void CheckDefaultValue(string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos) { try { XmlSchemaDatatype datatype = attdef.Datatype; if (datatype != null) { if (datatype.TokenizedType != XmlTokenizedType.CDATA) { value = value.Trim(); } if (value.Length != 0) { object pVal = datatype.ParseValue(value, NameTable, nsManager); XmlTokenizedType tokenizedType = datatype.TokenizedType; if (tokenizedType == XmlTokenizedType.ENTITY) { if (datatype.Variety == XmlSchemaDatatypeVariety.List) { string[] strArray = (string[])pVal; for (int i = 0; i < strArray.Length; i++) { BaseValidator.ProcessEntity(sinfo, strArray[i], sender, eventhandler, baseUri, lineNo, linePos); } } else { BaseValidator.ProcessEntity(sinfo, (string)pVal, sender, eventhandler, baseUri, lineNo, linePos); } } else if ((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(pVal)) { XmlSchemaException ex = new XmlSchemaException("Sch_EnumerationValue", pVal.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw ex; } eventhandler(sender, new ValidationEventArgs(ex)); } attdef.DefaultValueTyped = pVal; } } } catch { XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw exception2; } eventhandler(sender, new ValidationEventArgs(exception2)); } }
public static void CheckDefaultValue( SchemaAttDef attdef, SchemaInfo sinfo, IDtdParserAdapter readerAdapter ) { try { 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) { Uri baseUri = readerAdapter.BaseUri; string baseUriStr = (baseUri == null) ? string.Empty : baseUri.ToString(); if (dtype.Variety == XmlSchemaDatatypeVariety.List) { string[] ss = (string[])typedValue; foreach (string s in ss) { ProcessEntity(sinfo, s, readerAdapter, readerAdapter.EventHandler, baseUriStr, attdef.ValueLineNum, attdef.ValueLinePos); } } else { ProcessEntity(sinfo, (string)typedValue, readerAdapter, readerAdapter.EventHandler, baseUriStr, attdef.ValueLineNum, attdef.ValueLinePos); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), readerAdapter.BaseUri.ToString(), attdef.ValueLineNum, attdef.ValueLinePos); readerAdapter.SendValidationEvent(XmlSeverityType.Error, e); } } } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message); #else catch (Exception) { #endif XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString()); readerAdapter.SendValidationEvent(XmlSeverityType.Error, e); } }
protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { if (severity == XmlSeverityType.Error) { this.errorCount++; } if (this.eventHandler != null) { this.eventHandler(null, new ValidationEventArgs(e, severity)); } else if (severity == XmlSeverityType.Error) { throw e; } }
public static void RaiseValidationEvent(ValidationEventHandler handle, Exception innerException, string message, XmlSchemaObject xsobj, object sender, string sourceUri, XmlSeverityType severity) { XmlSchemaException ex = new XmlSchemaException(message, sender, sourceUri, xsobj, innerException); ValidationEventArgs validationEventArgs = new ValidationEventArgs(ex, message, severity); if (handle == null) { if (validationEventArgs.Severity == XmlSeverityType.Error) { throw validationEventArgs.Exception; } } else { handle(sender, validationEventArgs); } }
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); } } }
internal static string WarningDetails(XmlSchemaException exception, string message) { string details; XmlSchemaObject source = exception.SourceSchemaObject; if (exception.LineNumber == 0 && exception.LinePosition == 0) { details = GetSchemaItem(source, null, message); } else { string ns = null; if (source != null) { while (source.Parent != null) { source = source.Parent; } if (source is XmlSchema) { ns = ((XmlSchema)source).TargetNamespace; } } details = Res.GetString(Res.SchemaSyntaxErrorDetails, ns, message, exception.LineNumber, exception.LinePosition); } return details; }
public static void RaiseValidationEvent(ValidationEventHandler handle, Exception innerException, string message, XmlSchemaObject xsobj, object sender, string sourceUri, XmlSeverityType severity) { XmlSchemaException ex = new XmlSchemaException ( message, sender, sourceUri, xsobj, innerException); ValidationEventArgs e = new ValidationEventArgs(ex,message,severity); if(handle == null) { if (e.Severity == XmlSeverityType.Error) throw e.Exception; } else { handle(sender,e); } }
protected static void ProcessEntity(System.Xml.Schema.SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition) { SchemaEntity entity; XmlSchemaException ex = null; if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out entity)) { ex = new XmlSchemaException("Sch_UndeclaredEntity", name, baseUri, lineNumber, linePosition); } else if (entity.NData.IsEmpty) { ex = new XmlSchemaException("Sch_UnparsedEntityRef", name, baseUri, lineNumber, linePosition); } if (ex != null) { if (eventhandler == null) { throw ex; } eventhandler(sender, new ValidationEventArgs(ex)); } }
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 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(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; } } }
protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { if (eventHandling != null) { eventHandling.SendEvent(e, severity); } else if (severity == XmlSeverityType.Error) { throw e; } }
private void SendValidationEvent( XmlSeverityType severity, XmlSchemaException e ) { Debug.Assert( validate ); readerAdapter.SendValidationEvent( severity, e ); }
internal XmlSchemaException(string message, int lineNumber, int linePosition, XmlSchemaObject sourceObject, string sourceUri, Exception innerException) : base(XmlSchemaException.GetMessage(message, sourceUri, lineNumber, linePosition, sourceObject), innerException) { this.hasLineInfo = true; this.lineNumber = lineNumber; this.linePosition = linePosition; this.sourceObj = sourceObject; this.sourceUri = sourceUri; }
internal XmlSchemaException(string message, object sender, string sourceUri, XmlSchemaObject sourceObject, Exception innerException) : base(XmlSchemaException.GetMessage(message, sourceUri, sender, sourceObject), innerException) { IXmlLineInfo xmlLineInfo = sender as IXmlLineInfo; if (xmlLineInfo != null && xmlLineInfo.HasLineInfo()) { this.hasLineInfo = true; this.lineNumber = xmlLineInfo.LineNumber; this.linePosition = xmlLineInfo.LinePosition; } this.sourceObj = sourceObject; }
private void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { this.schema.ErrorCount++; e.SetSchemaObject(this.schema); if (validationEventHandler != null) { validationEventHandler(null, new ValidationEventArgs(e, severity)); } else if (severity == XmlSeverityType.Error) { throw e; } }
private void SendValidationEvent(XmlSeverityType severity, XmlSchemaException exception) { if (_validationEventHandling != null) { _validationEventHandling.SendEvent(exception, severity); } }
/// <summary> /// Handles a XmlValidation exception/error /// </summary> /// <param name="sender"></param> /// <param name="arguments"></param> private static void ValidationError(object sender, ValidationEventArgs arguments) { m_SchemaException = arguments.Exception; m_sValidationErrorMessage = arguments.Message; m_SeverityType = arguments.Severity; m_bXmlFileValid = false; }
/// <summary> /// Handles a Schema read exception/error /// </summary> /// <param name="sender"></param> /// <param name="arguments"></param> private static void SchemaReadError(object sender, ValidationEventArgs arguments) { m_SchemaException = arguments.Exception; m_sValidationErrorMessage = arguments.Message; m_SeverityType = arguments.Severity; throw new Exception("SchemaReadError: " + arguments.Message); }
internal XmlSchemaException(string message, XmlSchemaObject sourceObject, Exception innerException) : base(XmlSchemaException.GetMessage(message, null, 0, 0, sourceObject), innerException) { this.hasLineInfo = true; }
/// <summary>Initializes a new instance of the <see cref="T:System.Xml.Schema.XmlSchemaException" /> class with the exception message and original <see cref="T:System.Exception" /> object that caused this exception specified.</summary> /// <param name="message">A string description of the error condition.</param> /// <param name="innerException">The original T:System.Exception object that caused this exception.</param> public XmlSchemaException(string message, Exception innerException) : base(XmlSchemaException.GetMessage(message, null, 0, 0, null), innerException) { }
public static void CheckDefaultValue( string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos ) { try { XmlSchemaDatatype dtype = attdef.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); // 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], sender, eventhandler, baseUri, lineNo, linePos); } } else { ProcessEntity(sinfo, (string)typedValue, sender, eventhandler, baseUri, lineNo, linePos); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { XmlSchemaException e = new XmlSchemaException(SR.Sch_EnumerationValue, typedValue.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } } attdef.DefaultValueTyped = typedValue; } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message); #else catch { #endif XmlSchemaException e = new XmlSchemaException(SR.Sch_AttributeDefaultDataType, attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
public void PermitOnlySerializationFormatter_GetObjectData () { StreamingContext sc = new StreamingContext (StreamingContextStates.All); XmlSchemaException xe = new XmlSchemaException (String.Empty, null); xe.GetObjectData (null, sc); }
private void SendValidationEvent(XmlSeverityType severity, XmlSchemaException e) { Debug.Assert(_validate); IValidationEventHandling eventHandling = _readerAdapterWithValidation.ValidationEventHandling; if (eventHandling != null) { eventHandling.SendEvent(e, severity); } }
internal ValidationEventArgs(XmlSchemaException ex, string message, XmlSeverityType severity) { this.exception = ex; this.message = message; this.severity = severity; }
internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { Exception exception; if (value == null) { throw new ArgumentNullException("value"); } typedValue = null; string s = value as string; if (s != null) { return TryParseValue(s, nameTable, nsmgr, out typedValue); } object valueToCheck = null; XmlSchemaSimpleType memberType = null; for (int i = 0; i < types.Length; ++i) { if (types[i].Datatype.TryParseValue(value, nameTable, nsmgr, out valueToCheck) == null) { //no error memberType = types[i]; break; } } if (valueToCheck == null) { exception = new XmlSchemaException(Res.Sch_UnionFailedEx, value.ToString()); goto Error; } try { if (this.HasLexicalFacets) { string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), nsmgr); //Using value here to avoid info loss exception = unionFacetsChecker.CheckLexicalFacets(ref s1, this); if (exception != null) goto Error; } typedValue = new XsdSimpleValue(memberType, valueToCheck); if (this.HasValueFacets) { exception = unionFacetsChecker.CheckValueFacets(typedValue, this); if (exception != null) goto Error; } return null; } catch (FormatException e) { //Catching for exceptions thrown by ValueConverter exception = e; } catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter exception = e; } catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter exception = e; } catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter exception = e; } Error: return exception; }
public static void CheckDefaultValue( string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos ) { try { XmlSchemaDatatype dtype = attdef.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); // 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], sender, eventhandler, baseUri, lineNo, linePos); } } else { ProcessEntity(sinfo, (string)typedValue, sender, eventhandler, baseUri, lineNo, linePos); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } } attdef.DefaultValueTyped = typedValue; } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message); #else catch { #endif XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
private void HandleError (string message, XmlSeverityType severity) { if (validatingReader != null && validatingReader.ValidationType == ValidationType.None) return; IXmlLineInfo info = this as IXmlLineInfo; bool hasLine = info.HasLineInfo (); XmlSchemaException ex = new XmlSchemaException ( message, hasLine ? info.LineNumber : 0, hasLine ? info.LinePosition : 0, null, BaseURI, null); HandleError (ex, severity); }
internal ValidationEventArgs(XmlSchemaException ex) { this.ex = ex; this.severity = XmlSeverityType.Error; }
protected static void ProcessEntity(SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition) { SchemaEntity en; XmlSchemaException e = null; if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) { // validation error, see xml spec [68] e = new XmlSchemaException(Res.Sch_UndeclaredEntity, name, baseUri, lineNumber, linePosition); } else if (en.NData.IsEmpty) { e = new XmlSchemaException(Res.Sch_UnparsedEntityRef, name, baseUri, lineNumber, linePosition); } if (e != null) { if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
internal static void CheckDefaultValue( string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable nameTable, object sender, ValidationEventHandler eventhandler ) { #if DEBUG Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceVerbose, string.Format("Validator.CheckDefaultValue(\"{0}\")", value)); #endif try { XmlSchemaDatatype dtype = attdef.Datatype; if (dtype == null) { return; // no reason to check } if (sinfo.SchemaType != SchemaType.XSD) { if (dtype.TokenizedType != XmlTokenizedType.CDATA) { value = value.Trim(); } if (sinfo.SchemaType == SchemaType.XDR && value == string.Empty) { return; // don't need to check } } object typedValue = dtype.ParseValue(value, nameTable, nsManager); // Check special types XmlTokenizedType ttype = dtype.TokenizedType; if (ttype == XmlTokenizedType.ENTITY) { if (dtype.Variety == XmlSchemaDatatypeVariety.List) { string[] ss = (string[])typedValue; foreach(string s in ss) { ProcessEntity(sinfo, s, sender, eventhandler); } } else { ProcessEntity(sinfo, (string)typedValue, sender, eventhandler); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString()); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } } attdef.DefaultValueTyped = typedValue; } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, ex.Message); #else catch { #endif XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString()); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
private void SendValidationEvent(XmlSchemaException e) { this.SendValidationEvent(new XmlSchemaValidationException(e.GetRes, e.Args, e.SourceUri, e.LineNumber, e.LinePosition), XmlSeverityType.Error); }
private void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { if (validationEventHandler != null) { validationEventHandler(null, new ValidationEventArgs(e, severity)); } else if (severity == XmlSeverityType.Error) { throw e; } }
private void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { _SchemaInfo.ErrorCount++; if (_validationEventHandler != null) { _validationEventHandler(this, new ValidationEventArgs(e, severity)); } else if (severity == XmlSeverityType.Error) { throw e; } }
internal void DtdParserProxy_SendValidationEvent( XmlSeverityType severity, XmlSchemaException exception ) { if ( DtdValidation ) { this.SendValidationEvent( severity, exception ); } }
private void SendValidationEvent(XmlSchemaException e) { SendValidationEvent(e, XmlSeverityType.Error); }
void SendValidationEvent( XmlSeverityType severity, XmlSchemaException exception ) { if ( validationEventHandler != null ) { validationEventHandler( this, new ValidationEventArgs( exception, severity ) ); } }
internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { Exception exception; XmlSchemaSimpleType memberType = null; typedValue = null; exception = unionFacetsChecker.CheckLexicalFacets(ref s, this); if (exception != null) goto Error; //Parse string to CLR value for (int i = 0; i < types.Length; ++i) { exception = types[i].Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue); if (exception == null) { memberType = types[i]; break; } } if (memberType == null) { exception = new XmlSchemaException(Res.Sch_UnionFailedEx, s); goto Error; } typedValue = new XsdSimpleValue(memberType, typedValue); exception = unionFacetsChecker.CheckValueFacets(typedValue, this); if (exception != null) goto Error; return null; Error: return exception; }
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); } } }
protected void SendValidationEvent(XmlSchemaException e) { SendValidationEvent(e, XmlSeverityType.Error); }
private string FormatPosition(XmlSchemaException xmlSchemaException) { return string.Format(" @ line:{0} column:{1}", xmlSchemaException.LineNumber, xmlSchemaException.LinePosition); }
private void HandleError (XmlSchemaException ex, XmlSeverityType severity) { if (validatingReader != null && validatingReader.ValidationType == ValidationType.None) return; if (validatingReader != null) this.validatingReader.OnValidationEvent (this, new ValidationEventArgs (ex, ex.Message, severity)); else if (severity == XmlSeverityType.Error) throw ex; }
internal ValidationEventArgs(XmlSchemaException ex, XmlSeverityType severity) { this.ex = ex; this.severity = severity; }