internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames)
{
string nsXdr;
int length = 5;
bool flag = false;
if ((uri.Length > 5) && uri.StartsWith("uuid:", StringComparison.Ordinal))
{
flag = true;
}
else if ((uri.Length > 9) && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))
{
flag = true;
length = 9;
}
if (flag)
{
nsXdr = nameTable.Add(uri.Substring(0, length) + uri.Substring(length, uri.Length - length).ToUpper(CultureInfo.InvariantCulture));
}
else
{
nsXdr = uri;
}
if (Ref.Equal(schemaNames.NsDataTypeAlias, nsXdr) || Ref.Equal(schemaNames.NsDataTypeOld, nsXdr))
{
return(schemaNames.NsDataType);
}
if (Ref.Equal(schemaNames.NsXdrAlias, nsXdr))
{
nsXdr = schemaNames.NsXdr;
}
return(nsXdr);
}
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
: base(nameTable, schemaNames, eventHandler, compilationSettings)
{
_referenceNamespaces = new Hashtable();
_processedExternals = new Hashtable();
_lockList = new SortedList();
}
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler)
{
XmlNameTable nameTable = reader.NameTable;
SchemaNames schemaNames = new SchemaNames(nameTable);
return(new Parser(null, nameTable, schemaNames, validationEventHandler).Parse(reader, null, new SchemaInfo(schemaNames)));
}
internal Parser(XmlSchemaCollection schemaCollection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler)
{
this.SchemaCollection = schemaCollection;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.validationEventHandler += eventhandler;
}
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
Debug.Assert(nameTable != null);
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.compilationSettings = compilationSettings;
NsXml = nameTable.Add(XmlReservedNs.NsXml);
}
} //Use the default for XmlSchemaCollection
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
{
Debug.Assert(nameTable != null);
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.compilationSettings = compilationSettings;
NsXml = nameTable.Add(XmlReservedNs.NsXml);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = new XmlUrlResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler?eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = new XmlUrlResolver();
this.processMarkup = true;
this.dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
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;
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.Add1"]/*' />
/// <devdoc>
/// <para>Add the given schema into the schema collection.
/// If the given schema references other namespaces, the schemas for those
/// other namespaces are NOT automatically loaded.</para>
/// </devdoc>
public XmlSchema Add(String ns, XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
XmlNameTable tmpNameTable = reader.NameTable;
SchemaNames tmpSchemaNames = nameTable == tmpNameTable ? schemaNames : new SchemaNames(tmpNameTable);
SchemaInfo schemaInfo = new SchemaInfo(tmpSchemaNames);
return(Add(ns, schemaInfo, new Parser(this, reader.NameTable, tmpSchemaNames, validationEventHandler).Parse(reader, ns, schemaInfo), true));
}
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(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(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;
}
internal SchemaNames GetSchemaNames(XmlNameTable nt)
{
if (this.nameTable != nt)
{
return(new SchemaNames(nt));
}
if (this.schemaNames == null)
{
this.schemaNames = new SchemaNames(this.nameTable);
}
return(this.schemaNames);
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable) {
if (nametable == null) {
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
schemaNames = new SchemaNames(nametable);
isThreadSafe = true;
if (isThreadSafe) {
wLock = new ReaderWriterLock();
}
}
private void ValidateElement()
{
elementName.Init(reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(reader.NamespaceURI, NameTable, SchemaNames));
ValidateChildElement();
if (SchemaNames.IsXDRRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0)
{
_inlineSchemaParser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
_inlineSchemaParser.StartParsing(reader, null);
_inlineSchemaParser.ParseReaderNode();
}
else
{
ProcessElement();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable)
{
if (nametable == null)
{
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
schemaNames = new SchemaNames(nametable);
isThreadSafe = true;
if (isThreadSafe)
{
wLock = new ReaderWriterLock();
}
}
internal SchemaNames GetSchemaNames(XmlNameTable nt)
{
if (_nameTable != nt)
{
return(new SchemaNames(nt));
}
else
{
if (_schemaNames == null)
{
_schemaNames = new SchemaNames(_nameTable);
}
return(_schemaNames);
}
}
internal XdrBuilder(XmlReader reader, XmlNamespaceManager curmgr, SchemaInfo sinfo, string targetNamspace, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler)
{
this._SchemaInfo = sinfo;
this._TargetNamespace = targetNamspace;
this._reader = reader;
this._CurNsMgr = curmgr;
this.validationEventHandler = eventhandler;
this._StateHistory = new HWStack(10);
this._ElementDef = new ElementContent();
this._AttributeDef = new AttributeContent();
this._GroupStack = new HWStack(10);
this._GroupDef = new GroupContent();
this._NameTable = nameTable;
this._SchemaNames = schemaNames;
this._CurState = S_SchemaEntries[0];
this.positionInfo = PositionInfo.GetPositionInfo(this._reader);
this.xmlResolver = new XmlUrlResolver();
}
internal Validator(XmlNameTable nameTable, SchemaNames schemaNames, XmlValidatingReader reader) {
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.reader = reader;
positionInfo = PositionInfo.GetPositionInfo(reader);
nsManager = reader.NamespaceManager;
if (nsManager == null) {
nsManager = new XmlNamespaceManager(nameTable);
isProcessContents = true;
}
SchemaInfo = new SchemaInfo(schemaNames);
validationStack = new HWStack(STACK_INCREMENT);
textValue = new StringBuilder();
this.name = XmlQualifiedName.Empty;
attPresence = new Hashtable();
context = null;
attnDef = null;
}
internal XmlSchema ParseSchema(string targetNamespace, XmlReader reader)
{
XmlNameTable nameTable = reader.NameTable;
SchemaNames schemaNames = this.GetSchemaNames(nameTable);
System.Xml.Schema.Parser parser = new System.Xml.Schema.Parser(SchemaType.XSD, nameTable, schemaNames, this.eventHandler)
{
XmlResolver = this.readerSettings.GetXmlResolver()
};
try
{
parser.Parse(reader, targetNamespace);
}
catch (XmlSchemaException exception)
{
this.SendValidationEvent(exception, XmlSeverityType.Error);
return(null);
}
return(parser.XmlSchema);
}
internal void Preprocess(ValidationEventHandler eventhandler)
{
errorCount = 0;
Compiler.Cleanup(this);
isPreprocessed = false;
SchemaNames sn = new SchemaNames(NameTable);
new Compiler(NameTable, sn, eventhandler, true).Preprocess(this, null);
if (errorCount == 0)
{
isPreprocessed = true;
foreach (XmlSchemaExternal include in Includes)
{
if (include.Schema != null)
{
include.Schema.isPreprocessed = true;
}
}
}
}
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames)
{
string canonicalUri;
int offset = 5;
bool convert = false;
if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal))
{
convert = true;
}
else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))
{
convert = true;
offset = 9;
}
if (convert)
{
canonicalUri = nameTable.Add(string.Concat(uri.AsSpan(0, offset), CultureInfo.InvariantCulture.TextInfo.ToUpper(uri.Substring(offset, uri.Length - offset))));
}
else
{
canonicalUri = uri;
}
if (
Ref.Equal(schemaNames.NsDataTypeAlias, canonicalUri) ||
Ref.Equal(schemaNames.NsDataTypeOld, canonicalUri)
)
{
canonicalUri = schemaNames.NsDataType;
}
else if (Ref.Equal(schemaNames.NsXdrAlias, canonicalUri))
{
canonicalUri = schemaNames.NsXdr;
}
return(canonicalUri);
}
internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, int schemaFlags, XdrBuildFunction build)
{
_Attribute = a;
_Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype);
_SchemaFlags = schemaFlags;
_BuildFunc = build;
}
internal SchemaElementDecl(XmlSchemaDatatype dtype, SchemaNames names)
{
Datatype = dtype;
Content = new CompiledContentModel(names);
Content.ContentType = CompiledContentModel.Type.Text;
}
public SchemaElementDecl(XmlQualifiedName name, String prefix, SchemaType schemaType, SchemaNames names)
: base(name, prefix)
{
content = new CompiledContentModel(names);
}
public bool ParseContent; // whether text content is allowed
public XsdEntry(SchemaNames.Token n,
State state,
State[] nextStates,
XsdAttributeEntry[] attributes,
XsdInitFunction init,
XsdEndChildFunction end,
bool parseContent) {
Name = n;
CurrentState = state;
NextStates = nextStates;
Attributes = attributes;
InitFunc = init;
EndChildFunc = end;
ParseContent = parseContent;
}
internal XsdBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
XmlSchema schema,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
) {
this.reader = reader;
this.xso = this.schema = schema;
this.namespaceManager = new BuilderNamespaceManager(curmgr, reader);
this.validationEventHandler = eventhandler;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.stateHistory = new HWStack(STACK_INCREMENT);
this.currentEntry = SchemaEntries[0];
positionInfo = PositionInfo.GetPositionInfo(reader);
}
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames)
{
string nsXdr;
int length = 5;
bool flag = false;
if ((uri.Length > 5) && uri.StartsWith("uuid:", StringComparison.Ordinal))
{
flag = true;
}
else if ((uri.Length > 9) && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))
{
flag = true;
length = 9;
}
if (flag)
{
nsXdr = nameTable.Add(uri.Substring(0, length) + uri.Substring(length, uri.Length - length).ToUpper(CultureInfo.InvariantCulture));
}
else
{
nsXdr = uri;
}
if (Ref.Equal(schemaNames.NsDataTypeAlias, nsXdr) || Ref.Equal(schemaNames.NsDataTypeOld, nsXdr))
{
return schemaNames.NsDataType;
}
if (Ref.Equal(schemaNames.NsXdrAlias, nsXdr))
{
nsXdr = schemaNames.NsXdr;
}
return nsXdr;
}
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings())
{
} //Use the default for XmlSchemaCollection
internal SchemaInfo(SchemaNames names)
{
schemaType = SchemaType.None;
schemaNames = names;
}
internal Parser(XmlSchemaCollection schemaCollection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler) {
this.SchemaCollection = schemaCollection;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.validationEventHandler += eventhandler;
}
internal CompiledContentModel(SchemaNames names)
{
schemaNames = names;
endNode = null;
}
internal CompiledContentModel( SchemaNames names ) {
schemaNames = names;
endNode = null;
}
internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, XdrBuilder.XdrBuildFunction build)
{
this._Attribute = a;
this._Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype);
this._SchemaFlags = 0;
this._BuildFunc = build;
}
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compile1"]/*' />
public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver)
{
SchemaNames sn = new SchemaNames(NameTable);
Compile(null, NameTable, sn, validationEventHandler, null, new SchemaInfo(sn), false, resolver);
}
private void LoadExternals(XmlSchemaCollection schemaCollection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler validationEventHandler, XmlSchema schema)
{
foreach (XmlSchemaExternal include in schema.Includes)
{
string fullPath = null;
if (include.Schema != null)
{
// already loaded
fullPath = include.FullPath;
if (fullPath != null)
{
this.schemaLocations.Add(fullPath, fullPath);
}
LoadExternals(schemaCollection, nameTable, schemaNames, validationEventHandler, include.Schema);
continue;
}
string schemaLocation = include.SchemaLocation;
if (schemaCollection != null && include is XmlSchemaImport)
{
include.Schema = schemaCollection[((XmlSchemaImport)include).Namespace];
if (include.Schema != null)
{
include.Schema = include.Schema.Clone();
continue;
}
}
if (include is XmlSchemaImport && ((XmlSchemaImport)include).Namespace == XmlReservedNs.NsXml)
{
if (!buildinIncluded)
{
buildinIncluded = true;
include.Schema = GetBuildInSchema(nameTable);
}
continue;
}
if (schemaLocation == null)
{
continue;
}
Stream stream = ResolveSchemaLocation(schema, schemaLocation, out fullPath);
if (stream != null)
{
include.FullPath = fullPath;
if (this.schemaLocations[fullPath] == null)
{
this.schemaLocations.Add(fullPath, fullPath);
XmlTextReader reader = new XmlTextReader(fullPath, stream, nameTable);
try {
reader.XmlResolver = xmlResolver;
include.Schema = new Parser(schemaCollection, nameTable, schemaNames, validationEventHandler).Parse(reader, null, null);
while (reader.Read())
{
; // wellformness check
}
this.errorCount += include.Schema.ErrorCount;
LoadExternals(schemaCollection, nameTable, schemaNames, validationEventHandler, include.Schema);
}
catch (XmlSchemaException e) {
if (validationEventHandler != null)
{
validationEventHandler(null, new ValidationEventArgs(
new XmlSchemaException(Res.Sch_CannotLoadSchema, new string[] { schemaLocation, e.Message }), XmlSeverityType.Error
));
}
}
catch (Exception) {
if (validationEventHandler != null)
{
validationEventHandler(null, new ValidationEventArgs(
new XmlSchemaException(Res.Sch_InvalidIncludeLocation, include), XmlSeverityType.Warning
));
}
}
finally {
reader.Close();
}
}
else
{
stream.Close();
}
}
else
{
if (validationEventHandler != null)
{
validationEventHandler(null, new ValidationEventArgs(
new XmlSchemaException(Res.Sch_InvalidIncludeLocation, include), XmlSeverityType.Warning
));
}
}
}
}
public SchemaElementDecl(XmlQualifiedName name, String prefix, SchemaType schemaType, SchemaNames names)
: base(name, prefix) {
content = new CompiledContentModel(names);
}
internal SchemaNames GetSchemaNames(XmlNameTable nt) {
if (nameTable != nt) {
return new SchemaNames(nt);
}
else {
if (schemaNames == null) {
schemaNames = new SchemaNames( nameTable );
}
return schemaNames;
}
}
public SchemaCollectionPreprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
: base(nameTable, schemaNames, eventHandler) {
}
private ValidationType DetectValidationType()
{
//Type not yet detected : Check in Schema Collection
if (reader.Schemas != null && reader.Schemas.Count > 0)
{
XmlSchemaCollectionEnumerator enumerator = reader.Schemas.GetEnumerator();
while (enumerator.MoveNext())
{
XmlSchemaCollectionNode node = enumerator.CurrentNode !;
SchemaInfo schemaInfo = node.SchemaInfo !;
if (schemaInfo.SchemaType == SchemaType.XSD)
{
return(ValidationType.Schema);
}
else if (schemaInfo.SchemaType == SchemaType.XDR)
{
return(ValidationType.XDR);
}
}
}
if (reader.NodeType == XmlNodeType.Element)
{
SchemaType schemaType = SchemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI);
if (schemaType == SchemaType.XSD)
{
return(ValidationType.Schema);
}
else if (schemaType == SchemaType.XDR)
{
return(ValidationType.XDR);
}
else
{
int count = reader.AttributeCount;
for (int i = 0; i < count; i++)
{
reader.MoveToAttribute(i);
string objectNs = reader.NamespaceURI;
string objectName = reader.LocalName;
if (Ref.Equal(objectNs, SchemaNames.NsXmlNs))
{
if (XdrBuilder.IsXdrSchema(reader.Value))
{
reader.MoveToElement();
return(ValidationType.XDR);
}
}
else if (Ref.Equal(objectNs, SchemaNames.NsXsi))
{
reader.MoveToElement();
return(ValidationType.Schema);
}
else if (Ref.Equal(objectNs, SchemaNames.QnDtDt.Namespace) && Ref.Equal(objectName, SchemaNames.QnDtDt.Name))
{
reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(reader.Value);
reader.MoveToElement();
return(ValidationType.XDR);
}
} //end of for
if (count > 0)
{
reader.MoveToElement();
}
}
}
return(ValidationType.Auto);
}
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames)
{
string canonicalUri;
int offset = 5;
bool convert = false;
if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal))
{
convert = true;
}
else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))
{
convert = true;
offset = 9;
}
if (convert)
{
canonicalUri = nameTable.Add(uri.Substring(0, offset) + CultureInfo.InvariantCulture.TextInfo.ToUpper(uri.Substring(offset, uri.Length - offset)));
}
else
{
canonicalUri = uri;
}
if (
Ref.Equal(schemaNames.NsDataTypeAlias, canonicalUri) ||
Ref.Equal(schemaNames.NsDataTypeOld, canonicalUri)
)
{
canonicalUri = schemaNames.NsDataType;
}
else if (Ref.Equal(schemaNames.NsXdrAlias, canonicalUri))
{
canonicalUri = schemaNames.NsXdr;
}
return canonicalUri;
}
internal SchemaElementDecl(XmlSchemaDatatype dtype, SchemaNames names) {
Datatype = dtype;
Content = new CompiledContentModel(names);
Content.ContentType = CompiledContentModel.Type.Text;
}
public XsdBuildFunction BuildFunc; // Corresponding build functions for attribute value
public XsdAttributeEntry(SchemaNames.Token a, XsdBuildFunction build) {
Attribute = a;
BuildFunc = build;
}
internal bool _AllowText; // whether text content is allowed
internal XdrEntry(SchemaNames.Token n,
int[] states,
XdrAttributeEntry[] attributes,
XdrInitFunction init,
XdrBeginChildFunction begin,
XdrEndChildFunction end,
bool fText)
{
_Name = n;
_NextStates = states;
_Attributes = attributes;
_InitFunc = init;
_BeginChildFunc = begin;
_EndChildFunc = end;
_AllowText = fText;
}
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings())
{
}
internal void Compile(XmlSchemaCollection collection, XmlNameTable nameTable, SchemaNames schemaNames,
ValidationEventHandler validationEventHandler, string targetNamespace,
SchemaInfo schemaInfo, bool compileContentModel, XmlResolver resolver)
{
errorCount = 0;
xmlResolver = resolver;
if (needCleanup)
{
schemaLocations.Clear();
Compiler.Cleanup(this);
}
needCleanup = true;
isPreprocessed = false;
isCompiled = false;
if (baseUri != null)
{
schemaLocations.Add(baseUri, baseUri);
}
if (xmlResolver != null)
{
LoadExternals(collection, nameTable, schemaNames, validationEventHandler, this);
}
if (errorCount == 0)
{
new Compiler(nameTable, schemaNames, validationEventHandler, compileContentModel).Compile(this, targetNamespace, schemaInfo);
if (errorCount == 0)
{
isPreprocessed = true;
isCompiled = true;
foreach (XmlSchemaExternal include in Includes)
{
if (include.Schema != null)
{
include.Schema.isPreprocessed = true;
include.Schema.isCompiled = true;
include.Schema.LineNumber = include.LineNumber;
include.Schema.LinePosition = include.LinePosition;
include.Schema.SourceUri = include.SchemaLocation;
}
}
}
}
}
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection
internal XsdBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
XmlSchema schema,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
)
{
_reader = reader;
_xso = _schema = schema;
_namespaceManager = new BuilderNamespaceManager(curmgr, reader);
_validationEventHandler = eventhandler;
_nameTable = nameTable;
_schemaNames = schemaNames;
_stateHistory = new HWStack(STACK_INCREMENT);
_currentEntry = s_schemaEntries[0];
_positionInfo = PositionInfo.GetPositionInfo(reader);
}
internal Compiler(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler, bool compileContentModel) {
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.validationEventHandler += eventhandler;
this.compileContentModel = compileContentModel;
}
public XmlQualifiedName GetName(SchemaNames.Token token) {
return TokenToQName[(int)token];
}
internal XdrBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
SchemaInfo sinfo,
string targetNamspace,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
)
{
_SchemaInfo = sinfo;
_TargetNamespace = targetNamspace;
_reader = reader;
_CurNsMgr = curmgr;
_validationEventHandler = eventhandler;
_StateHistory = new HWStack(StackIncrement);
_ElementDef = new ElementContent();
_AttributeDef = new AttributeContent();
_GroupStack = new HWStack(StackIncrement);
_GroupDef = new GroupContent();
_NameTable = nameTable;
_SchemaNames = schemaNames;
_CurState = s_schemaEntries[0];
_positionInfo = PositionInfo.GetPositionInfo(_reader);
_xmlResolver = null;
}
