mcs/class/referencesource/System.Xml/System/Xml/Schema/BaseValidator.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="BaseValidator.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 //------------------------------------------------------------------------------
   7
   8 namespace System.Xml.Schema {
   9
  10     using System.IO;
  11     using System.Diagnostics;
  12     using System.Xml;
  13     using System.Text;
  14     using System.Collections;
  15
  16 #pragma warning disable 618
  17
  18     internal class BaseValidator {
  19         XmlSchemaCollection schemaCollection;
  20         IValidationEventHandling eventHandling;
  21         XmlNameTable nameTable;
  22         SchemaNames schemaNames;
  23         PositionInfo positionInfo;
  24         XmlResolver xmlResolver;
  25         Uri baseUri;
  26
  27         protected SchemaInfo schemaInfo;
  28         protected XmlValidatingReaderImpl reader;
  29         protected XmlQualifiedName elementName;
  30         protected ValidationState context;
  31         protected StringBuilder    textValue;
  32         protected string           textString;
  33         protected bool             hasSibling;
  34         protected bool             checkDatatype;
  35
  36         public BaseValidator(BaseValidator other) {
  37             reader = other.reader;
  38             schemaCollection = other.schemaCollection;
  39             eventHandling = other.eventHandling;
  40             nameTable = other.nameTable;
  41             schemaNames = other.schemaNames;
  42             positionInfo = other.positionInfo;
  43             xmlResolver = other.xmlResolver;
  44             baseUri = other.baseUri;
  45             elementName = other.elementName;
  46         }
  47
  48         public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) {
  49             Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
  50             this.reader = reader;
  51             this.schemaCollection = schemaCollection;
  52             this.eventHandling = eventHandling;
  53             nameTable = reader.NameTable;
  54             positionInfo = PositionInfo.GetPositionInfo(reader);
  55             elementName = new XmlQualifiedName();
  56         }
  57
  58         public XmlValidatingReaderImpl Reader {
  59             get { return reader; }
  60         }
  61
  62         public XmlSchemaCollection SchemaCollection {
  63             get { return schemaCollection; }
  64         }
  65
  66         public XmlNameTable NameTable {
  67             get { return nameTable; }
  68         }
  69
  70         public SchemaNames SchemaNames {
  71             get {
  72                 if (schemaNames != null) {
  73                     return schemaNames;
  74                 }
  75                 if (schemaCollection != null) {
  76                     schemaNames = schemaCollection.GetSchemaNames(nameTable);
  77                 }
  78                 else {
  79                     schemaNames = new SchemaNames(nameTable);
  80                 }
  81                 return schemaNames;
  82             }
  83         }
  84
  85         public PositionInfo PositionInfo {
  86             get { return positionInfo; }
  87         }
  88
  89         public XmlResolver XmlResolver {
  90             get { return xmlResolver; }
  91             set { xmlResolver = value; }
  92         }
  93
  94         public Uri BaseUri {
  95             get { return baseUri; }
  96             set { baseUri = value; }
  97         }
  98
  99         public ValidationEventHandler EventHandler {
 100             get { return (ValidationEventHandler)eventHandling.EventHandler; }
 101         }
 102
 103         public SchemaInfo SchemaInfo {
 104             get {
 105                 return schemaInfo;
 106             }
 107             set {
 108                 schemaInfo = value;
 109             }
 110         }
 111
 112         public IDtdInfo DtdInfo {
 113             get {
 114                 return schemaInfo;
 115             }
 116             set {
 117                 SchemaInfo tmpSchemaInfo  = value as SchemaInfo;
 118                 if (tmpSchemaInfo == null) {
 119                     throw new XmlException(Res.Xml_InternalError, string.Empty);
 120                 }
 121                 this.schemaInfo = tmpSchemaInfo;
 122             }
 123         }
 124
 125         public virtual bool PreserveWhitespace {
 126             get {
 127                 return false;
 128             }
 129         }
 130
 131         public virtual void Validate() {
 132         }
 133
 134         public virtual void CompleteValidation() {
 135         }
 136
 137         public virtual object  FindId(string name) {
 138             return null;
 139         }
 140
 141         public void ValidateText() {
 142             if (context.NeedValidateChildren) {
 143                 if (context.IsNill) {
 144                     SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
 145                     return;
 146                 }
 147                 ContentValidator contentValidator = context.ElementDecl.ContentValidator;
 148                 XmlSchemaContentType contentType = contentValidator.ContentType;
 149                 if (contentType == XmlSchemaContentType.ElementOnly) {
 150                     ArrayList names = contentValidator.ExpectedElements(context, false);
 151                     if (names == null) {
 152                         SendValidationEvent(Res.Sch_InvalidTextInElement, XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace));
 153                     }
 154                     else {
 155                         Debug.Assert(names.Count > 0);
 156                         SendValidationEvent(Res.Sch_InvalidTextInElementExpecting, new string[] { XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace), XmlSchemaValidator.PrintExpectedElements(names, false) });
 157                     }
 158                 }
 159                 else if (contentType == XmlSchemaContentType.Empty) {
 160                     SendValidationEvent(Res.Sch_InvalidTextInEmpty, string.Empty);
 161                 }
 162                 if (checkDatatype) {
 163                     SaveTextValue(reader.Value);
 164                 }
 165             }
 166         }
 167
 168         public void ValidateWhitespace() {
 169             if (context.NeedValidateChildren) {
 170                 XmlSchemaContentType contentType = context.ElementDecl.ContentValidator.ContentType;
 171                 if (context.IsNill) {
 172                     SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
 173                 }
 174                 if (contentType == XmlSchemaContentType.Empty) {
 175                     SendValidationEvent(Res.Sch_InvalidWhitespaceInEmpty, string.Empty);
 176                 }
 177                 if (checkDatatype) {
 178                     SaveTextValue(reader.Value);
 179                 }
 180             }
 181         }
 182
 183         private void SaveTextValue(string value) {
 184             if (textString.Length == 0) {
 185                 textString = value;
 186             }
 187             else {
 188                 if (!hasSibling) {
 189                     textValue.Append(textString);
 190                     hasSibling = true;
 191                 }
 192                 textValue.Append(value);
 193             }
 194         }
 195
 196         protected void SendValidationEvent(string code) {
 197             SendValidationEvent(code, string.Empty);
 198         }
 199
 200         protected void SendValidationEvent(string code, string[] args) {
 201             SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
 202         }
 203
 204         protected void SendValidationEvent(string code, string arg) {
 205             SendValidationEvent(new XmlSchemaException(code, arg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
 206         }
 207
 208         protected void SendValidationEvent(string code, string arg1, string arg2) {
 209             SendValidationEvent(new XmlSchemaException(code, new string[] { arg1, arg2 }, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
 210         }
 211
 212         protected void SendValidationEvent(XmlSchemaException e) {
 213             SendValidationEvent(e, XmlSeverityType.Error);
 214         }
 215
 216         protected void SendValidationEvent(string code, string msg, XmlSeverityType severity) {
 217             SendValidationEvent(new XmlSchemaException(code, msg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
 218         }
 219
 220         protected void SendValidationEvent(string code, string[] args, XmlSeverityType severity) {
 221             SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
 222         }
 223
 224         protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) {
 225             if (eventHandling != null) {
 226                 eventHandling.SendEvent(e, severity);
 227             }
 228             else if (severity == XmlSeverityType.Error) {
 229                 throw e;
 230             }
 231         }
 232
 233         protected static void ProcessEntity(SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition) {
 234             SchemaEntity en;
 235             XmlSchemaException e = null;
 236             if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) {
 237                 // validation error, see xml spec [68]
 238                 e = new XmlSchemaException(Res.Sch_UndeclaredEntity, name, baseUri, lineNumber, linePosition);
 239             }
 240             else if (en.NData.IsEmpty) {
 241                 e = new XmlSchemaException(Res.Sch_UnparsedEntityRef, name, baseUri, lineNumber, linePosition);
 242             }
 243             if (e != null) {
 244                 if (eventhandler != null) {
 245                     eventhandler(sender, new ValidationEventArgs(e));
 246                 }
 247                 else {
 248                     throw e;
 249                 }
 250             }
 251         }
 252
 253         protected static void ProcessEntity(SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition) {
 254             SchemaEntity en;
 255             string errorResId = null;
 256             if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) {
 257                 // validation error, see xml spec [68]
 258                 errorResId = Res.Sch_UndeclaredEntity;
 259
 260             }
 261             else if (en.NData.IsEmpty) {
 262                 errorResId = Res.Sch_UnparsedEntityRef;
 263             }
 264             if (errorResId != null) {
 265                 XmlSchemaException e = new XmlSchemaException(errorResId, name, baseUriStr, lineNumber, linePosition);
 266
 267                 if (eventHandling != null) {
 268                     eventHandling.SendEvent(e, XmlSeverityType.Error);
 269                 }
 270                 else {
 271                     throw e;
 272                 }
 273             }
 274         }
 275
 276         public static BaseValidator CreateInstance(ValidationType valType, XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling, bool processIdentityConstraints) {
 277             switch(valType) {
 278                 case ValidationType.XDR:
 279                     return new XdrValidator(reader, schemaCollection, eventHandling);
 280
 281                 case ValidationType.Schema:
 282                     return new XsdValidator(reader, schemaCollection, eventHandling);
 283
 284                 case ValidationType.DTD:
 285                     return new DtdValidator(reader, eventHandling, processIdentityConstraints);
 286
 287                 case ValidationType.Auto:
 288                     return new AutoValidator(reader, schemaCollection, eventHandling);
 289
 290                 case ValidationType.None:
 291                     return new BaseValidator(reader, schemaCollection, eventHandling);
 292
 293                 default:
 294                         break;
 295             }
 296             return null;
 297         }
 298
 299     }
 300 #pragma warning restore 618
 301
 302 }
 303
 304