path: root/mcs/class/referencesource/System.Xml/System/Xml/Schema/BaseValidator.cs

//------------------------------------------------------------------------------
// <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

}