You've already forked linux-packaging-mono
305 lines
12 KiB
C#
305 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="BaseValidator.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">Microsoft</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Xml.Schema {
|
|
|
|
using System.IO;
|
|
using System.Diagnostics;
|
|
using System.Xml;
|
|
using System.Text;
|
|
using System.Collections;
|
|
|
|
#pragma warning disable 618
|
|
|
|
internal class BaseValidator {
|
|
XmlSchemaCollection schemaCollection;
|
|
IValidationEventHandling eventHandling;
|
|
XmlNameTable nameTable;
|
|
SchemaNames schemaNames;
|
|
PositionInfo positionInfo;
|
|
XmlResolver xmlResolver;
|
|
Uri baseUri;
|
|
|
|
protected SchemaInfo schemaInfo;
|
|
protected XmlValidatingReaderImpl reader;
|
|
protected XmlQualifiedName elementName;
|
|
protected ValidationState context;
|
|
protected StringBuilder textValue;
|
|
protected string textString;
|
|
protected bool hasSibling;
|
|
protected bool checkDatatype;
|
|
|
|
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(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 XmlValidatingReaderImpl Reader {
|
|
get { return reader; }
|
|
}
|
|
|
|
public XmlSchemaCollection SchemaCollection {
|
|
get { return schemaCollection; }
|
|
}
|
|
|
|
public XmlNameTable NameTable {
|
|
get { return nameTable; }
|
|
}
|
|
|
|
public SchemaNames SchemaNames {
|
|
get {
|
|
if (schemaNames != null) {
|
|
return schemaNames;
|
|
}
|
|
if (schemaCollection != null) {
|
|
schemaNames = schemaCollection.GetSchemaNames(nameTable);
|
|
}
|
|
else {
|
|
schemaNames = new SchemaNames(nameTable);
|
|
}
|
|
return schemaNames;
|
|
}
|
|
}
|
|
|
|
public PositionInfo PositionInfo {
|
|
get { return positionInfo; }
|
|
}
|
|
|
|
public XmlResolver XmlResolver {
|
|
get { return xmlResolver; }
|
|
set { xmlResolver = value; }
|
|
}
|
|
|
|
public Uri BaseUri {
|
|
get { return baseUri; }
|
|
set { baseUri = value; }
|
|
}
|
|
|
|
public ValidationEventHandler EventHandler {
|
|
get { return (ValidationEventHandler)eventHandling.EventHandler; }
|
|
}
|
|
|
|
public SchemaInfo SchemaInfo {
|
|
get {
|
|
return schemaInfo;
|
|
}
|
|
set {
|
|
schemaInfo = value;
|
|
}
|
|
}
|
|
|
|
public IDtdInfo DtdInfo {
|
|
get {
|
|
return schemaInfo;
|
|
}
|
|
set {
|
|
SchemaInfo tmpSchemaInfo = value as SchemaInfo;
|
|
if (tmpSchemaInfo == null) {
|
|
throw new XmlException(Res.Xml_InternalError, string.Empty);
|
|
}
|
|
this.schemaInfo = tmpSchemaInfo;
|
|
}
|
|
}
|
|
|
|
public virtual bool PreserveWhitespace {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual void Validate() {
|
|
}
|
|
|
|
public virtual void CompleteValidation() {
|
|
}
|
|
|
|
public virtual object FindId(string name) {
|
|
return null;
|
|
}
|
|
|
|
public void ValidateText() {
|
|
if (context.NeedValidateChildren) {
|
|
if (context.IsNill) {
|
|
SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
|
|
return;
|
|
}
|
|
ContentValidator contentValidator = context.ElementDecl.ContentValidator;
|
|
XmlSchemaContentType contentType = contentValidator.ContentType;
|
|
if (contentType == XmlSchemaContentType.ElementOnly) {
|
|
ArrayList names = contentValidator.ExpectedElements(context, false);
|
|
if (names == null) {
|
|
SendValidationEvent(Res.Sch_InvalidTextInElement, XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace));
|
|
}
|
|
else {
|
|
Debug.Assert(names.Count > 0);
|
|
SendValidationEvent(Res.Sch_InvalidTextInElementExpecting, new string[] { XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace), XmlSchemaValidator.PrintExpectedElements(names, false) });
|
|
}
|
|
}
|
|
else if (contentType == XmlSchemaContentType.Empty) {
|
|
SendValidationEvent(Res.Sch_InvalidTextInEmpty, string.Empty);
|
|
}
|
|
if (checkDatatype) {
|
|
SaveTextValue(reader.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ValidateWhitespace() {
|
|
if (context.NeedValidateChildren) {
|
|
XmlSchemaContentType contentType = context.ElementDecl.ContentValidator.ContentType;
|
|
if (context.IsNill) {
|
|
SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
|
|
}
|
|
if (contentType == XmlSchemaContentType.Empty) {
|
|
SendValidationEvent(Res.Sch_InvalidWhitespaceInEmpty, string.Empty);
|
|
}
|
|
if (checkDatatype) {
|
|
SaveTextValue(reader.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SaveTextValue(string value) {
|
|
if (textString.Length == 0) {
|
|
textString = value;
|
|
}
|
|
else {
|
|
if (!hasSibling) {
|
|
textValue.Append(textString);
|
|
hasSibling = true;
|
|
}
|
|
textValue.Append(value);
|
|
}
|
|
}
|
|
|
|
protected void SendValidationEvent(string code) {
|
|
SendValidationEvent(code, string.Empty);
|
|
}
|
|
|
|
protected void SendValidationEvent(string code, string[] args) {
|
|
SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
|
|
}
|
|
|
|
protected void SendValidationEvent(string code, string arg) {
|
|
SendValidationEvent(new XmlSchemaException(code, arg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
|
|
}
|
|
|
|
protected void SendValidationEvent(string code, string arg1, string arg2) {
|
|
SendValidationEvent(new XmlSchemaException(code, new string[] { arg1, arg2 }, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
|
|
}
|
|
|
|
protected void SendValidationEvent(XmlSchemaException e) {
|
|
SendValidationEvent(e, XmlSeverityType.Error);
|
|
}
|
|
|
|
protected void SendValidationEvent(string code, string msg, XmlSeverityType severity) {
|
|
SendValidationEvent(new XmlSchemaException(code, msg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
|
|
}
|
|
|
|
protected void SendValidationEvent(string code, string[] args, XmlSeverityType severity) {
|
|
SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
|
|
}
|
|
|
|
protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) {
|
|
if (eventHandling != null) {
|
|
eventHandling.SendEvent(e, severity);
|
|
}
|
|
else if (severity == XmlSeverityType.Error) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
}
|
|
#pragma warning restore 618
|
|
|
|
}
|
|
|
|
|