The Labs \ Source Viewer \ SSCLI \ System.Xml.Schema \ DeclBaseInfo

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XdrBuilder.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">priyal</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Schema
  17. {
  18.    
  19.     using System.IO;
  20.     using System.Collections;
  21.     using System.Diagnostics;
  22.     using System.ComponentModel;
  23.     using System.Globalization;
  24.    
  25. /*
  26.     * The XdrBuilder class parses the XDR Schema and
  27.     * builds internal validation information
  28.     */   
  29.     internal sealed class XdrBuilder : SchemaBuilder
  30.     {
  31.         private const int XdrSchema = 1;
  32.         private const int XdrElementType = 2;
  33.         private const int XdrAttributeType = 3;
  34.         private const int XdrElement = 4;
  35.         private const int XdrAttribute = 5;
  36.         private const int XdrGroup = 6;
  37.         private const int XdrElementDatatype = 7;
  38.         private const int XdrAttributeDatatype = 8;
  39.        
  40.         private const int SchemaFlagsNs = 256;
  41.        
  42.         private const int StackIncrement = 10;
  43.        
  44.        
  45.         private const int SchemaOrderNone = 0;
  46.         private const int SchemaOrderMany = 1;
  47.         private const int SchemaOrderSequence = 2;
  48.         private const int SchemaOrderChoice = 3;
  49.         private const int SchemaOrderAll = 4;
  50.        
  51.         private const int SchemaContentNone = 0;
  52.         private const int SchemaContentEmpty = 1;
  53.         private const int SchemaContentText = 2;
  54.         private const int SchemaContentMixed = 3;
  55.         private const int SchemaContentElement = 4;
  56.        
  57.        
  58.         private sealed class DeclBaseInfo
  59.         {
  60.             // used for <element... or <attribute...
  61.             internal XmlQualifiedName _Name;
  62.             internal string _Prefix;
  63.             internal XmlQualifiedName _TypeName;
  64.             internal string _TypePrefix;
  65.             internal object _Default;
  66.             internal object _Revises;
  67.             internal uint _MaxOccurs;
  68.             internal uint _MinOccurs;
  69.            
  70.             // used for checking undeclared attribute type
  71.             internal bool _Checking;
  72.             internal SchemaElementDecl _ElementDecl;
  73.             internal SchemaAttDef _Attdef;
  74.             internal DeclBaseInfo _Next;
  75.            
  76.             internal DeclBaseInfo()
  77.             {
  78.                 Reset();
  79.             }
  80.            
  81.             internal void Reset()
  82.             {
  83.                 _Name = XmlQualifiedName.Empty;
  84.                 _Prefix = null;
  85.                 _TypeName = XmlQualifiedName.Empty;
  86.                 _TypePrefix = null;
  87.                 _Default = null;
  88.                 _Revises = null;
  89.                 _MaxOccurs = 1;
  90.                 _MinOccurs = 1;
  91.                 _Checking = false;
  92.                 _ElementDecl = null;
  93.                 _Next = null;
  94.                 _Attdef = null;
  95.             }
  96.         }
  97.        
  98.         private sealed class GroupContent
  99.         {
  100.             internal uint _MinVal;
  101.             internal uint _MaxVal;
  102.             internal bool _HasMaxAttr;
  103.             internal bool _HasMinAttr;
  104.             internal int _Order;
  105.            
  106.             static internal void Copy(GroupContent from, GroupContent to)
  107.             {
  108.                 to._MinVal = from._MinVal;
  109.                 to._MaxVal = from._MaxVal;
  110.                 to._Order = from._Order;
  111.             }
  112.            
  113.             static internal GroupContent Copy(GroupContent other)
  114.             {
  115.                 GroupContent g = new GroupContent();
  116.                 Copy(other, g);
  117.                 return g;
  118.             }
  119.         }
  120.        
  121.         private sealed class ElementContent
  122.         {
  123.             // for <ElementType ...
  124.             internal SchemaElementDecl _ElementDecl;
  125.             // Element Information
  126.             internal int _ContentAttr;
  127.             // content attribute
  128.             internal int _OrderAttr;
  129.             // order attribute
  130.             internal bool _MasterGroupRequired;
  131.             // In a situation like <!ELEMENT root (e1)> e1 has to have a ()
  132.             internal bool _ExistTerminal;
  133.             // when there exist a terminal, we need to addOrder before
  134.             // we can add another terminal
  135.             internal bool _AllowDataType;
  136.             // must have textOnly if we have datatype
  137.             internal bool _HasDataType;
  138.             // got data type
  139.             // for <element ...
  140.             internal bool _HasType;
  141.             // user must have a type attribute in <element ...
  142.             internal bool _EnumerationRequired;
  143.             internal uint _MinVal;
  144.             internal uint _MaxVal;
  145.             // -1 means infinity
  146.             internal uint _MaxLength;
  147.             // dt:maxLength
  148.             internal uint _MinLength;
  149.             // dt:minLength
  150.             internal Hashtable _AttDefList;
  151.             // a list of current AttDefs for the <ElementType ...
  152.             // only the used one will be added
  153.         }
  154.        
  155.         private sealed class AttributeContent
  156.         {
  157.             // used for <AttributeType ...
  158.             internal SchemaAttDef _AttDef;
  159.            
  160.             // used to store name & prefix for the AttributeType
  161.             internal XmlQualifiedName _Name;
  162.             internal string _Prefix;
  163.             internal bool _Required;
  164.             // true: when the attribute required="yes"
  165.             // used for both AttributeType and attribute
  166.             internal uint _MinVal;
  167.             internal uint _MaxVal;
  168.             // -1 means infinity
  169.             internal uint _MaxLength;
  170.             // dt:maxLength
  171.             internal uint _MinLength;
  172.             // dt:minLength
  173.             // used for datatype
  174.             internal bool _EnumerationRequired;
  175.             // when we have dt:value then we must have dt:type="enumeration"
  176.             internal bool _HasDataType;
  177.            
  178.             // used for <attribute ...
  179.             internal bool _Global;
  180.            
  181.             internal object _Default;
  182.         }
  183.        
  184.         private delegate void XdrBuildFunction(XdrBuilder builder, object obj, string prefix);
  185.         private delegate void XdrInitFunction(XdrBuilder builder, object obj);
  186.         private delegate void XdrBeginChildFunction(XdrBuilder builder);
  187.         private delegate void XdrEndChildFunction(XdrBuilder builder);
  188.        
  189.         private sealed class XdrAttributeEntry
  190.         {
  191.             internal SchemaNames.Token _Attribute;
  192.             // possible attribute names
  193.             internal int _SchemaFlags;
  194.             internal XmlSchemaDatatype _Datatype;
  195.             internal XdrBuildFunction _BuildFunc;
  196.             // Corresponding build functions for attribute value
  197.             internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, XdrBuildFunction build)
  198.             {
  199.                 _Attribute = a;
  200.                 _Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype);
  201.                 _SchemaFlags = 0;
  202.                 _BuildFunc = build;
  203.             }
  204.             internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, int schemaFlags, XdrBuildFunction build)
  205.             {
  206.                 _Attribute = a;
  207.                 _Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype);
  208.                 _SchemaFlags = schemaFlags;
  209.                 _BuildFunc = build;
  210.             }
  211.         }
  212.        
  213.         //
  214.         // XdrEntry controls the states of parsing a schema document
  215.         // and calls the corresponding "init", "end" and "build" functions when necessary
  216.         //
  217.         private sealed class XdrEntry
  218.         {
  219.             internal SchemaNames.Token _Name;
  220.             // the name of the object it is comparing to
  221.             internal int[] _NextStates;
  222.             // possible next states
  223.             internal XdrAttributeEntry[] _Attributes;
  224.             // allowed attributes
  225.             internal XdrInitFunction _InitFunc;
  226.             // "init" functions in XdrBuilder
  227.             internal XdrBeginChildFunction _BeginChildFunc;
  228.             // "begin" functions in XdrBuilder for BeginChildren
  229.             internal XdrEndChildFunction _EndChildFunc;
  230.             // "end" functions in XdrBuilder for EndChildren
  231.             internal bool _AllowText;
  232.             // whether text content is allowed
  233.             internal XdrEntry(SchemaNames.Token n, int[] states, XdrAttributeEntry[] attributes, XdrInitFunction init, XdrBeginChildFunction begin, XdrEndChildFunction end, bool fText)
  234.             {
  235.                 _Name = n;
  236.                 _NextStates = states;
  237.                 _Attributes = attributes;
  238.                 _InitFunc = init;
  239.                 _BeginChildFunc = begin;
  240.                 _EndChildFunc = end;
  241.                 _AllowText = fText;
  242.             }
  243.         }
  244.        
  245.        
  246.         /////////////////////////////////////////////////////////////////////////////
  247.         // Data structures for XML-Data Reduced (XDR Schema)
  248.         //
  249.        
  250.         //
  251.         // Elements
  252.         //
  253.         private static readonly int[] S_XDR_Root_Element = {XdrSchema};
  254.         private static readonly int[] S_XDR_Root_SubElements = {XdrElementType, XdrAttributeType};
  255.         private static readonly int[] S_XDR_ElementType_SubElements = {XdrElement, XdrGroup, XdrAttributeType, XdrAttribute, XdrElementDatatype};
  256.         private static readonly int[] S_XDR_AttributeType_SubElements = {XdrAttributeDatatype};
  257.         private static readonly int[] S_XDR_Group_SubElements = {XdrElement, XdrGroup};
  258.        
  259.         //
  260.         // Attributes
  261.         //
  262.         private static readonly XdrAttributeEntry[] S_XDR_Root_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaName, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildRoot_Name)), new XdrAttributeEntry(SchemaNames.Token.SchemaId, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildRoot_ID))};
  263.        
  264.         private static readonly XdrAttributeEntry[] S_XDR_ElementType_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaName, XmlTokenizedType.QName, SchemaFlagsNs, new XdrBuildFunction(XDR_BuildElementType_Name)), new XdrAttributeEntry(SchemaNames.Token.SchemaContent, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildElementType_Content)), new XdrAttributeEntry(SchemaNames.Token.SchemaModel, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildElementType_Model)), new XdrAttributeEntry(SchemaNames.Token.SchemaOrder, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildElementType_Order)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtType, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtType)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtValues, XmlTokenizedType.NMTOKENS, new XdrBuildFunction(XDR_BuildElementType_DtValues)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMaxLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtMaxLength)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMinLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtMinLength))};
  265.        
  266.         private static readonly XdrAttributeEntry[] S_XDR_AttributeType_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaName, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttributeType_Name)), new XdrAttributeEntry(SchemaNames.Token.SchemaRequired, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttributeType_Required)), new XdrAttributeEntry(SchemaNames.Token.SchemaDefault, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttributeType_Default)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtType, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttributeType_DtType)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtValues, XmlTokenizedType.NMTOKENS, new XdrBuildFunction(XDR_BuildAttributeType_DtValues)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMaxLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttributeType_DtMaxLength)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMinLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttributeType_DtMinLength))};
  267.        
  268.         private static readonly XdrAttributeEntry[] S_XDR_Element_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaType, XmlTokenizedType.QName, SchemaFlagsNs, new XdrBuildFunction(XDR_BuildElement_Type)), new XdrAttributeEntry(SchemaNames.Token.SchemaMinOccurs, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElement_MinOccurs)), new XdrAttributeEntry(SchemaNames.Token.SchemaMaxOccurs, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElement_MaxOccurs))};
  269.        
  270.         private static readonly XdrAttributeEntry[] S_XDR_Attribute_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaType, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttribute_Type)), new XdrAttributeEntry(SchemaNames.Token.SchemaRequired, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttribute_Required)), new XdrAttributeEntry(SchemaNames.Token.SchemaDefault, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttribute_Default))};
  271.        
  272.         private static readonly XdrAttributeEntry[] S_XDR_Group_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaOrder, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildGroup_Order)), new XdrAttributeEntry(SchemaNames.Token.SchemaMinOccurs, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildGroup_MinOccurs)), new XdrAttributeEntry(SchemaNames.Token.SchemaMaxOccurs, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildGroup_MaxOccurs))};
  273.        
  274.         private static readonly XdrAttributeEntry[] S_XDR_ElementDataType_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaDtType, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtType)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtValues, XmlTokenizedType.NMTOKENS, new XdrBuildFunction(XDR_BuildElementType_DtValues)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMaxLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtMaxLength)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMinLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildElementType_DtMinLength))};
  275.        
  276.            
  277.         private static readonly XdrAttributeEntry[] S_XDR_AttributeDataType_Attributes = {new XdrAttributeEntry(SchemaNames.Token.SchemaDtType, XmlTokenizedType.QName, new XdrBuildFunction(XDR_BuildAttributeType_DtType)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtValues, XmlTokenizedType.NMTOKENS, new XdrBuildFunction(XDR_BuildAttributeType_DtValues)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMaxLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttributeType_DtMaxLength)), new XdrAttributeEntry(SchemaNames.Token.SchemaDtMinLength, XmlTokenizedType.CDATA, new XdrBuildFunction(XDR_BuildAttributeType_DtMinLength))};
  278.         //
  279.         // Schema entries
  280.         //
  281.         private static readonly XdrEntry[] S_SchemaEntries = {new XdrEntry(SchemaNames.Token.Empty, S_XDR_Root_Element, null, null, null, null, false), new XdrEntry(SchemaNames.Token.XdrRoot, S_XDR_Root_SubElements, S_XDR_Root_Attributes, new XdrInitFunction(XDR_InitRoot), new XdrBeginChildFunction(XDR_BeginRoot), new XdrEndChildFunction(XDR_EndRoot), false), new XdrEntry(SchemaNames.Token.XdrElementType, S_XDR_ElementType_SubElements, S_XDR_ElementType_Attributes, new XdrInitFunction(XDR_InitElementType), new XdrBeginChildFunction(XDR_BeginElementType), new XdrEndChildFunction(XDR_EndElementType), false), new XdrEntry(SchemaNames.Token.XdrAttributeType, S_XDR_AttributeType_SubElements, S_XDR_AttributeType_Attributes, new XdrInitFunction(XDR_InitAttributeType), new XdrBeginChildFunction(XDR_BeginAttributeType), new XdrEndChildFunction(XDR_EndAttributeType), false), new XdrEntry(SchemaNames.Token.XdrElement, null, S_XDR_Element_Attributes, new XdrInitFunction(XDR_InitElement), null, new XdrEndChildFunction(XDR_EndElement), false), new XdrEntry(SchemaNames.Token.XdrAttribute, null, S_XDR_Attribute_Attributes, new XdrInitFunction(XDR_InitAttribute), new XdrBeginChildFunction(XDR_BeginAttribute), new XdrEndChildFunction(XDR_EndAttribute), false), new XdrEntry(SchemaNames.Token.XdrGroup, S_XDR_Group_SubElements, S_XDR_Group_Attributes, new XdrInitFunction(XDR_InitGroup), null, new XdrEndChildFunction(XDR_EndGroup), false), new XdrEntry(SchemaNames.Token.XdrDatatype, null, S_XDR_ElementDataType_Attributes, new XdrInitFunction(XDR_InitElementDtType), null, new XdrEndChildFunction(XDR_EndElementDtType), true), new XdrEntry(SchemaNames.Token.XdrDatatype, null, S_XDR_AttributeDataType_Attributes, new XdrInitFunction(XDR_InitAttributeDtType), null, new XdrEndChildFunction(XDR_EndAttributeDtType), true)};
  282.        
  283.         private SchemaInfo _SchemaInfo;
  284.         private string _TargetNamespace;
  285.         private XmlReader _reader;
  286.         private PositionInfo positionInfo;
  287.         private ParticleContentValidator _contentValidator;
  288.        
  289.         private XdrEntry _CurState;
  290.         private XdrEntry _NextState;
  291.        
  292.         private HWStack _StateHistory;
  293.         private HWStack _GroupStack;
  294.         private string _XdrName;
  295.         private string _XdrPrefix;
  296.        
  297.         private ElementContent _ElementDef;
  298.         private GroupContent _GroupDef;
  299.         private AttributeContent _AttributeDef;
  300.        
  301.         private DeclBaseInfo _UndefinedAttributeTypes;
  302.         private DeclBaseInfo _BaseDecl;
  303.        
  304.         private XmlNameTable _NameTable;
  305.         private SchemaNames _SchemaNames;
  306.        
  307.         private XmlNamespaceManager _CurNsMgr;
  308.         private string _Text;
  309.        
  310.         private ValidationEventHandler validationEventHandler;
  311.         Hashtable _UndeclaredElements = new Hashtable();
  312.        
  313.         private const string x_schema = "x-schema:";
  314.        
  315.         private XmlResolver xmlResolver = null;
  316.        
  317.         internal XdrBuilder(XmlReader reader, XmlNamespaceManager curmgr, SchemaInfo sinfo, string targetNamspace, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler)
  318.         {
  319.             _SchemaInfo = sinfo;
  320.             _TargetNamespace = targetNamspace;
  321.             _reader = reader;
  322.             _CurNsMgr = curmgr;
  323.             validationEventHandler = eventhandler;
  324.             _StateHistory = new HWStack(StackIncrement);
  325.             _ElementDef = new ElementContent();
  326.             _AttributeDef = new AttributeContent();
  327.             _GroupStack = new HWStack(StackIncrement);
  328.             _GroupDef = new GroupContent();
  329.             _NameTable = nameTable;
  330.             _SchemaNames = schemaNames;
  331.             _CurState = S_SchemaEntries[0];
  332.             positionInfo = PositionInfo.GetPositionInfo(_reader);
  333.             xmlResolver = new XmlUrlResolver();
  334.         }
  335.        
  336.         internal override bool ProcessElement(string prefix, string name, string ns)
  337.         {
  338.             XmlQualifiedName qname = new XmlQualifiedName(name, XmlSchemaDatatype.XdrCanonizeUri(ns, _NameTable, _SchemaNames));
  339.             if (GetNextState(qname)) {
  340.                 Push();
  341.                 if (_CurState._InitFunc != null) {
  342.                     (this._CurState._InitFunc)(this, qname);
  343.                 }
  344.                 return true;
  345.             }
  346.             else {
  347.                 if (!IsSkipableElement(qname)) {
  348.                     SendValidationEvent(Res.Sch_UnsupportedElement, XmlQualifiedName.ToString(name, prefix));
  349.                 }
  350.                 return false;
  351.             }
  352.         }
  353.        
  354.         internal override void ProcessAttribute(string prefix, string name, string ns, string value)
  355.         {
  356.             XmlQualifiedName qname = new XmlQualifiedName(name, XmlSchemaDatatype.XdrCanonizeUri(ns, _NameTable, _SchemaNames));
  357.             for (int i = 0; i < _CurState._Attributes.Length; i++) {
  358.                 XdrAttributeEntry a = _CurState._Attributes[i];
  359.                 if (_SchemaNames.TokenToQName[(int)a._Attribute].Equals(qname)) {
  360.                     XdrBuildFunction buildFunc = a._BuildFunc;
  361.                     if (a._Datatype.TokenizedType == XmlTokenizedType.QName) {
  362.                         string prefixValue;
  363.                         XmlQualifiedName qnameValue = XmlQualifiedName.Parse(value, _CurNsMgr, out prefixValue);
  364.                         qnameValue.Atomize(_NameTable);
  365.                         if (prefixValue.Length != 0) {
  366.                             if (a._Attribute != SchemaNames.Token.SchemaType) {
  367.                                 // <attribute type= || <element type=
  368.                                 throw new XmlException(Res.Xml_UnexpectedToken, "NAME");
  369.                             }
  370.                         }
  371.                         else if (IsGlobal(a._SchemaFlags)) {
  372.                             qnameValue = new XmlQualifiedName(qnameValue.Name, _TargetNamespace);
  373.                         }
  374.                         else {
  375.                             qnameValue = new XmlQualifiedName(qnameValue.Name);
  376.                         }
  377.                         buildFunc(this, qnameValue, prefixValue);
  378.                     }
  379.                     else {
  380.                         buildFunc(this, a._Datatype.ParseValue(value, _NameTable, _CurNsMgr), string.Empty);
  381.                     }
  382.                     return;
  383.                 }
  384.             }
  385.            
  386.             if ((object)ns == (object)_SchemaNames.NsXmlNs && IsXdrSchema(value)) {
  387.                 LoadSchema(value);
  388.                 return;
  389.             }
  390.            
  391.             // Check non-supported attribute
  392.             if (!IsSkipableAttribute(qname)) {
  393.                 SendValidationEvent(Res.Sch_UnsupportedAttribute, XmlQualifiedName.ToString(qname.Name, prefix));
  394.             }
  395.         }
  396.        
  397.         internal XmlResolver XmlResolver {
  398.             set { xmlResolver = value; }
  399.         }
  400.        
  401.         private bool LoadSchema(string uri)
  402.         {
  403.             if (xmlResolver == null) {
  404.                 return false;
  405.             }
  406.             uri = _NameTable.Add(uri);
  407.             if (_SchemaInfo.TargetNamespaces.Contains(uri)) {
  408.                 return false;
  409.             }
  410.             SchemaInfo schemaInfo = null;
  411.             Uri _baseUri = xmlResolver.ResolveUri(null, _reader.BaseURI);
  412.             XmlReader reader = null;
  413.             try {
  414.                 Uri ruri = xmlResolver.ResolveUri(_baseUri, uri.Substring(x_schema.Length));
  415.                 Stream stm = (Stream)xmlResolver.GetEntity(ruri, null, null);
  416.                 reader = new XmlTextReader(ruri.ToString(), stm, _NameTable);
  417.                 schemaInfo = new SchemaInfo();
  418.                 Parser parser = new Parser(SchemaType.XDR, _NameTable, _SchemaNames, validationEventHandler);
  419.                 parser.XmlResolver = xmlResolver;
  420.                 parser.Parse(reader, uri);
  421.                 schemaInfo = parser.XdrSchema;
  422.             }
  423.             catch (XmlException e) {
  424.                 SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Warning);
  425.                 schemaInfo = null;
  426.             }
  427.             finally {
  428.                 if (reader != null) {
  429.                     reader.Close();
  430.                 }
  431.             }
  432.             if (schemaInfo != null && schemaInfo.ErrorCount == 0) {
  433.                 _SchemaInfo.Add(schemaInfo, validationEventHandler);
  434.                 return true;
  435.             }
  436.             return false;
  437.         }
  438.        
  439.         static internal bool IsXdrSchema(string uri)
  440.         {
  441.             return uri.Length >= x_schema.Length && 0 == string.Compare(uri, 0, x_schema, 0, x_schema.Length, StringComparison.Ordinal) && !uri.StartsWith("x-schema:#", StringComparison.Ordinal);
  442.         }
  443.        
  444.         internal override bool IsContentParsed()
  445.         {
  446.             return true;
  447.         }
  448.        
  449.         internal override void ProcessMarkup(XmlNode[] markup)
  450.         {
  451.             throw new InvalidOperationException(Res.GetString(Res.Xml_InvalidOperation));
  452.             // should never be called
  453.         }
  454.        
  455.         internal override void ProcessCData(string value)
  456.         {
  457.             if (_CurState._AllowText) {
  458.                 _Text = value;
  459.             }
  460.             else {
  461.                 SendValidationEvent(Res.Sch_TextNotAllowed, value);
  462.             }
  463.         }
  464.        
  465.         internal override void StartChildren()
  466.         {
  467.             if (_CurState._BeginChildFunc != null) {
  468.                 (this._CurState._BeginChildFunc)(this);
  469.             }
  470.         }
  471.        
  472.         internal override void EndChildren()
  473.         {
  474.             if (_CurState._EndChildFunc != null) {
  475.                 (this._CurState._EndChildFunc)(this);
  476.             }
  477.            
  478.             Pop();
  479.         }
  480.        
  481.         //
  482.         // State stack push & pop
  483.         //
  484.         private void Push()
  485.         {
  486.             _StateHistory.Push();
  487.             _StateHistory[_StateHistory.Length - 1] = _CurState;
  488.             _CurState = _NextState;
  489.         }
  490.        
  491.         private void Pop()
  492.         {
  493.             _CurState = (XdrEntry)_StateHistory.Pop();
  494.         }
  495.        
  496.        
  497.         //
  498.         // Group stack push & pop
  499.         //
  500.         private void PushGroupInfo()
  501.         {
  502.             _GroupStack.Push();
  503.             _GroupStack[_GroupStack.Length - 1] = GroupContent.Copy(_GroupDef);
  504.         }
  505.        
  506.         private void PopGroupInfo()
  507.         {
  508.             _GroupDef = (GroupContent)_GroupStack.Pop();
  509.             Debug.Assert(_GroupDef != null);
  510.         }
  511.        
  512.         //
  513.         // XDR Schema
  514.         //
  515.         private static void XDR_InitRoot(XdrBuilder builder, object obj)
  516.         {
  517.             builder._SchemaInfo.SchemaType = SchemaType.XDR;
  518.             builder._ElementDef._ElementDecl = null;
  519.             builder._ElementDef._AttDefList = null;
  520.             builder._AttributeDef._AttDef = null;
  521.         }
  522.        
  523.         private static void XDR_BuildRoot_Name(XdrBuilder builder, object obj, string prefix)
  524.         {
  525.             builder._XdrName = (string)obj;
  526.             builder._XdrPrefix = prefix;
  527.         }
  528.        
  529.         private static void XDR_BuildRoot_ID(XdrBuilder builder, object obj, string prefix)
  530.         {
  531.            
  532.         }
  533.        
  534.         private static void XDR_BeginRoot(XdrBuilder builder)
  535.         {
  536.             if (builder._TargetNamespace == null) {
  537.                 // inline xdr schema
  538.                 if (builder._XdrName != null) {
  539.                     builder._TargetNamespace = builder._NameTable.Add("x-schema:#" + builder._XdrName);
  540.                 }
  541.                 else {
  542.                     builder._TargetNamespace = String.Empty;
  543.                 }
  544.             }
  545.             builder._SchemaInfo.TargetNamespaces.Add(builder._TargetNamespace, true);
  546.         }
  547.        
  548.         private static void XDR_EndRoot(XdrBuilder builder)
  549.         {
  550.             //
  551.             // check undefined attribute types
  552.             // We already checked local attribute types, so only need to check global attribute types here
  553.             //
  554.             while (builder._UndefinedAttributeTypes != null) {
  555.                 XmlQualifiedName gname = builder._UndefinedAttributeTypes._TypeName;
  556.                
  557.                 // if there is no URN in this name then the name is local to the
  558.                 // schema, but the global attribute was still URN qualified, so
  559.                 // we need to qualify this name now.
  560.                 if (gname.Namespace.Length == 0) {
  561.                     gname = new XmlQualifiedName(gname.Name, builder._TargetNamespace);
  562.                 }
  563.                 SchemaAttDef ad = (SchemaAttDef)builder._SchemaInfo.AttributeDecls[gname];
  564.                 if (ad != null) {
  565.                     builder._UndefinedAttributeTypes._Attdef = (SchemaAttDef)ad.Clone();
  566.                     builder._UndefinedAttributeTypes._Attdef.Name = gname;
  567.                     builder.XDR_CheckAttributeDefault(builder._UndefinedAttributeTypes, builder._UndefinedAttributeTypes._Attdef);
  568.                 }
  569.                 else {
  570.                     builder.SendValidationEvent(Res.Sch_UndeclaredAttribute, gname.Name);
  571.                 }
  572.                 builder._UndefinedAttributeTypes = builder._UndefinedAttributeTypes._Next;
  573.             }
  574.            
  575.             foreach (SchemaElementDecl ed in builder._UndeclaredElements.Values) {
  576.                 builder.SendValidationEvent(Res.Sch_UndeclaredElement, XmlQualifiedName.ToString(ed.Name.Name, ed.Prefix));
  577.             }
  578.            
  579.            
  580.            
  581.         }
  582.        
  583.        
  584.         //
  585.         // XDR ElementType
  586.         //
  587.        
  588.         private static void XDR_InitElementType(XdrBuilder builder, object obj)
  589.         {
  590.             builder._ElementDef._ElementDecl = new SchemaElementDecl();
  591.             builder._contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
  592.             builder._contentValidator.IsOpen = true;
  593.            
  594.             builder._ElementDef._ContentAttr = SchemaContentNone;
  595.             builder._ElementDef._OrderAttr = SchemaOrderNone;
  596.             builder._ElementDef._MasterGroupRequired = false;
  597.             builder._ElementDef._ExistTerminal = false;
  598.             builder._ElementDef._AllowDataType = true;
  599.             builder._ElementDef._HasDataType = false;
  600.             builder._ElementDef._EnumerationRequired = false;
  601.             builder._ElementDef._AttDefList = new Hashtable();
  602.             builder._ElementDef._MaxLength = uint.MaxValue;
  603.             builder._ElementDef._MinLength = uint.MaxValue;
  604.            
  605.             // builder._AttributeDef._HasDataType = false;
  606.             // builder._AttributeDef._Default = null;
  607.         }
  608.        
  609.         private static void XDR_BuildElementType_Name(XdrBuilder builder, object obj, string prefix)
  610.         {
  611.             XmlQualifiedName qname = (XmlQualifiedName)obj;
  612.            
  613.             if (builder._SchemaInfo.ElementDecls[qname] != null) {
  614.                 builder.SendValidationEvent(Res.Sch_DupElementDecl, XmlQualifiedName.ToString(qname.Name, prefix));
  615.             }
  616.             builder._ElementDef._ElementDecl.Name = qname;
  617.             builder._ElementDef._ElementDecl.Prefix = prefix;
  618.             builder._SchemaInfo.ElementDecls.Add(qname, builder._ElementDef._ElementDecl);
  619.             if (builder._UndeclaredElements[qname] != null) {
  620.                 builder._UndeclaredElements.Remove(qname);
  621.             }
  622.         }
  623.        
  624.         private static void XDR_BuildElementType_Content(XdrBuilder builder, object obj, string prefix)
  625.         {
  626.             builder._ElementDef._ContentAttr = builder.GetContent((XmlQualifiedName)obj);
  627.         }
  628.        
  629.         private static void XDR_BuildElementType_Model(XdrBuilder builder, object obj, string prefix)
  630.         {
  631.             builder._contentValidator.IsOpen = builder.GetModel((XmlQualifiedName)obj);
  632.         }
  633.        
  634.         private static void XDR_BuildElementType_Order(XdrBuilder builder, object obj, string prefix)
  635.         {
  636.             builder._ElementDef._OrderAttr = builder._GroupDef._Order = builder.GetOrder((XmlQualifiedName)obj);
  637.         }
  638.        
  639.         private static void XDR_BuildElementType_DtType(XdrBuilder builder, object obj, string prefix)
  640.         {
  641.             builder._ElementDef._HasDataType = true;
  642.             string s = ((string)obj).Trim();
  643.             if (s.Length == 0) {
  644.                 builder.SendValidationEvent(Res.Sch_MissDtvalue);
  645.             }
  646.             else {
  647.                 XmlSchemaDatatype dtype = XmlSchemaDatatype.FromXdrName(s);
  648.                 if (dtype == null) {
  649.                     builder.SendValidationEvent(Res.Sch_UnknownDtType, s);
  650.                 }
  651.                 builder._ElementDef._ElementDecl.Datatype = dtype;
  652.             }
  653.         }
  654.        
  655.         private static void XDR_BuildElementType_DtValues(XdrBuilder builder, object obj, string prefix)
  656.         {
  657.             builder._ElementDef._EnumerationRequired = true;
  658.             builder._ElementDef._ElementDecl.Values = new ArrayList((string[])obj);
  659.         }
  660.        
  661.         private static void XDR_BuildElementType_DtMaxLength(XdrBuilder builder, object obj, string prefix)
  662.         {
  663.             ParseDtMaxLength(ref builder._ElementDef._MaxLength, obj, builder);
  664.         }
  665.        
  666.         private static void XDR_BuildElementType_DtMinLength(XdrBuilder builder, object obj, string prefix)
  667.         {
  668.             ParseDtMinLength(ref builder._ElementDef._MinLength, obj, builder);
  669.         }
  670.        
  671.         private static void XDR_BeginElementType(XdrBuilder builder)
  672.         {
  673.             string code = null;
  674.             string msg = null;
  675.            
  676.             //
  677.             // check name attribute
  678.             //
  679.             if (builder._ElementDef._ElementDecl.Name.IsEmpty) {
  680.                 code = Res.Sch_MissAttribute;
  681.                 msg = "name";
  682.                 goto cleanup;
  683.             }
  684.            
  685.             //
  686.             // check dt:type attribute
  687.             //
  688.             if (builder._ElementDef._HasDataType) {
  689.                 if (!builder._ElementDef._AllowDataType) {
  690.                     code = Res.Sch_DataTypeTextOnly;
  691.                     goto cleanup;
  692.                 }
  693.                 else {
  694.                     builder._ElementDef._ContentAttr = SchemaContentText;
  695.                 }
  696.             }
  697.             else if (builder._ElementDef._ContentAttr == SchemaContentNone) {
  698.                 switch (builder._ElementDef._OrderAttr) {
  699.                     case SchemaOrderNone:
  700.                         builder._ElementDef._ContentAttr = SchemaContentMixed;
  701.                         builder._ElementDef._OrderAttr = SchemaOrderMany;
  702.                         break;
  703.                     case SchemaOrderSequence:
  704.                         builder._ElementDef._ContentAttr = SchemaContentElement;
  705.                         break;
  706.                     case SchemaOrderChoice:
  707.                         builder._ElementDef._ContentAttr = SchemaContentElement;
  708.                         break;
  709.                     case SchemaOrderMany:
  710.                         builder._ElementDef._ContentAttr = SchemaContentMixed;
  711.                         break;
  712.                 }
  713.             }
  714.            
  715.            
  716.             //save the model value from the base
  717.             bool tempOpen = builder._contentValidator.IsOpen;
  718.             ElementContent def = builder._ElementDef;
  719.             switch (builder._ElementDef._ContentAttr) {
  720.                 case SchemaContentText:
  721.                     builder._ElementDef._ElementDecl.ContentValidator = ContentValidator.TextOnly;
  722.                     builder._GroupDef._Order = SchemaOrderMany;
  723.                     builder._contentValidator = null;
  724.                     break;
  725.                 case SchemaContentElement:
  726.                     builder._contentValidator = new ParticleContentValidator(XmlSchemaContentType.ElementOnly);
  727.                     if (def._OrderAttr == SchemaOrderNone) {
  728.                         builder._GroupDef._Order = SchemaOrderSequence;
  729.                     }
  730.                     def._MasterGroupRequired = true;
  731.                     builder._contentValidator.IsOpen = tempOpen;
  732.                     break;
  733.                 case SchemaContentEmpty:
  734.                    
  735.                     builder._ElementDef._ElementDecl.ContentValidator = ContentValidator.Empty;
  736.                     builder._contentValidator = null;
  737.                     break;
  738.                 case SchemaContentMixed:
  739.                    
  740.                     if (def._OrderAttr == SchemaOrderNone || def._OrderAttr == SchemaOrderMany) {
  741.                         builder._GroupDef._Order = SchemaOrderMany;
  742.                     }
  743.                     else {
  744.                         code = Res.Sch_MixedMany;
  745.                         goto cleanup;
  746.                     }
  747.                     def._MasterGroupRequired = true;
  748.                     builder._contentValidator.IsOpen = tempOpen;
  749.                     break;
  750.             }
  751.            
  752.            
  753.             if (def._ContentAttr == SchemaContentMixed || def._ContentAttr == SchemaContentElement) {
  754.                 builder._contentValidator.Start();
  755.                 builder._contentValidator.OpenGroup();
  756.             }
  757.             cleanup:
  758.             if (code != null) {
  759.                 builder.SendValidationEvent(code, msg);
  760.             }
  761.         }
  762.        
  763.         private static void XDR_EndElementType(XdrBuilder builder)
  764.         {
  765.             SchemaElementDecl ed = builder._ElementDef._ElementDecl;
  766.            
  767.             if (ed != null) {
  768.                 ed.EndAddAttDef();
  769.             }
  770.             // check undefined attribute types first
  771.             if (builder._UndefinedAttributeTypes != null && builder._ElementDef._AttDefList != null) {
  772.                 DeclBaseInfo patt = builder._UndefinedAttributeTypes;
  773.                 DeclBaseInfo p1 = patt;
  774.                
  775.                 while (patt != null) {
  776.                     SchemaAttDef pAttdef = null;
  777.                    
  778.                     if (patt._ElementDecl == ed) {
  779.                         XmlQualifiedName pName = patt._TypeName;
  780.                         pAttdef = (SchemaAttDef)builder._ElementDef._AttDefList[pName];
  781.                         if (pAttdef != null) {
  782.                             patt._Attdef = (SchemaAttDef)pAttdef.Clone();
  783.                             patt._Attdef.Name = pName;
  784.                             builder.XDR_CheckAttributeDefault(patt, pAttdef);
  785.                            
  786.                             // remove it from _pUndefinedAttributeTypes
  787.                             if (patt == builder._UndefinedAttributeTypes) {
  788.                                 patt = builder._UndefinedAttributeTypes = patt._Next;
  789.                                 p1 = patt;
  790.                             }
  791.                             else {
  792.                                 p1._Next = patt._Next;
  793.                                 patt = p1._Next;
  794.                             }
  795.                         }
  796.                     }
  797.                    
  798.                     if (pAttdef == null) {
  799.                         if (patt != builder._UndefinedAttributeTypes)
  800.                             p1 = p1._Next;
  801.                         patt = patt._Next;
  802.                     }
  803.                 }
  804.             }
  805.            
  806.             if (builder._ElementDef._MasterGroupRequired) {
  807.                 // if the content is mixed, there is a group that need to be closed
  808.                 builder._contentValidator.CloseGroup();
  809.                
  810.                 if (!builder._ElementDef._ExistTerminal) {
  811.                     if (builder._contentValidator.IsOpen) {
  812.                         builder._ElementDef._ElementDecl.ContentValidator = ContentValidator.Any;
  813.                         builder._contentValidator = null;
  814.                     }
  815.                     else {
  816.                         if (builder._ElementDef._ContentAttr != SchemaContentMixed)
  817.                             builder.SendValidationEvent(Res.Sch_ElementMissing);
  818.                     }
  819.                 }
  820.                 else {
  821.                     if (builder._GroupDef._Order == SchemaOrderMany) {
  822.                         builder._contentValidator.AddStar();
  823.                     }
  824.                 }
  825.             }
  826.             if (ed.Datatype != null) {
  827.                 XmlTokenizedType ttype = ed.Datatype.TokenizedType;
  828.                 if (ttype == XmlTokenizedType.ENUMERATION && !builder._ElementDef._EnumerationRequired) {
  829.                     builder.SendValidationEvent(Res.Sch_MissDtvaluesAttribute);
  830.                 }
  831.                
  832.                 if (ttype != XmlTokenizedType.ENUMERATION && builder._ElementDef._EnumerationRequired) {
  833.                     builder.SendValidationEvent(Res.Sch_RequireEnumeration);
  834.                 }
  835.             }
  836.             CompareMinMaxLength(builder._ElementDef._MinLength, builder._ElementDef._MaxLength, builder);
  837.             ed.MaxLength = (long)builder._ElementDef._MaxLength;
  838.             ed.MinLength = (long)builder._ElementDef._MinLength;
  839.            
  840.             if (builder._contentValidator != null) {
  841.                 builder._ElementDef._ElementDecl.ContentValidator = builder._contentValidator.Finish(true);
  842.                 builder._contentValidator = null;
  843.             }
  844.            
  845.             builder._ElementDef._ElementDecl = null;
  846.             builder._ElementDef._AttDefList = null;
  847.         }
  848.        
  849.        
  850.         //
  851.         // XDR AttributeType
  852.         //
  853.        
  854.         private static void XDR_InitAttributeType(XdrBuilder builder, object obj)
  855.         {
  856.             AttributeContent ad = builder._AttributeDef;
  857.             ad._AttDef = new SchemaAttDef(XmlQualifiedName.Empty, null);
  858.            
  859.             ad._Required = false;
  860.             ad._Prefix = null;
  861.            
  862.             ad._Default = null;
  863.             ad._MinVal = 0;
  864.             // optional by default.
  865.             ad._MaxVal = 1;
  866.            
  867.             // used for datatype
  868.             ad._EnumerationRequired = false;
  869.             ad._HasDataType = false;
  870.             ad._Global = (builder._StateHistory.Length == 2);
  871.            
  872.             ad._MaxLength = uint.MaxValue;
  873.             ad._MinLength = uint.MaxValue;
  874.         }
  875.        
  876.         private static void XDR_BuildAttributeType_Name(XdrBuilder builder, object obj, string prefix)
  877.         {
  878.             XmlQualifiedName qname = (XmlQualifiedName)obj;
  879.            
  880.             builder._AttributeDef._Name = qname;
  881.             builder._AttributeDef._Prefix = prefix;
  882.             builder._AttributeDef._AttDef.Name = qname;
  883.            
  884.             if (builder._ElementDef._ElementDecl != null) {
  885.                 // Local AttributeType
  886.                 if (builder._ElementDef._AttDefList[qname] == null) {
  887.                     builder._ElementDef._AttDefList.Add(qname, builder._AttributeDef._AttDef);
  888.                 }
  889.                 else {
  890.                     builder.SendValidationEvent(Res.Sch_DupAttribute, XmlQualifiedName.ToString(qname.Name, prefix));
  891.                 }
  892.             }
  893.             else {
  894.                 // Global AttributeType
  895.                 // Global AttributeTypes are URN qualified so that we can look them up across schemas.
  896.                 qname = new XmlQualifiedName(qname.Name, builder._TargetNamespace);
  897.                 builder._AttributeDef._AttDef.Name = qname;
  898.                 if (builder._SchemaInfo.AttributeDecls[qname] == null) {
  899.                     builder._SchemaInfo.AttributeDecls.Add(qname, builder._AttributeDef._AttDef);
  900.                 }
  901.                 else {
  902.                     builder.SendValidationEvent(Res.Sch_DupAttribute, XmlQualifiedName.ToString(qname.Name, prefix));
  903.                 }
  904.             }
  905.         }
  906.        
  907.         private static void XDR_BuildAttributeType_Required(XdrBuilder builder, object obj, string prefix)
  908.         {
  909.             builder._AttributeDef._Required = IsYes(obj, builder);
  910.         }
  911.        
  912.         private static void XDR_BuildAttributeType_Default(XdrBuilder builder, object obj, string prefix)
  913.         {
  914.             builder._AttributeDef._Default = obj;
  915.         }
  916.        
  917.         private static void XDR_BuildAttributeType_DtType(XdrBuilder builder, object obj, string prefix)
  918.         {
  919.             XmlQualifiedName qname = (XmlQualifiedName)obj;
  920.             builder._AttributeDef._HasDataType = true;
  921.             builder._AttributeDef._AttDef.Datatype = builder.CheckDatatype(qname.Name);
  922.         }
  923.        
  924.         private static void XDR_BuildAttributeType_DtValues(XdrBuilder builder, object obj, string prefix)
  925.         {
  926.             builder._AttributeDef._EnumerationRequired = true;
  927.             builder._AttributeDef._AttDef.Values = new ArrayList((string[])obj);
  928.         }
  929.        
  930.         private static void XDR_BuildAttributeType_DtMaxLength(XdrBuilder builder, object obj, string prefix)
  931.         {
  932.             ParseDtMaxLength(ref builder._AttributeDef._MaxLength, obj, builder);
  933.         }
  934.        
  935.         private static void XDR_BuildAttributeType_DtMinLength(XdrBuilder builder, object obj, string prefix)
  936.         {
  937.             ParseDtMinLength(ref builder._AttributeDef._MinLength, obj, builder);
  938.         }
  939.        
  940.         private static void XDR_BeginAttributeType(XdrBuilder builder)
  941.         {
  942.             if (builder._AttributeDef._Name.IsEmpty) {
  943.                 builder.SendValidationEvent(Res.Sch_MissAttribute);
  944.             }
  945.         }
  946.        
  947.         private static void XDR_EndAttributeType(XdrBuilder builder)
  948.         {
  949.             string code = null;
  950.             if (builder._AttributeDef._HasDataType && builder._AttributeDef._AttDef.Datatype != null) {
  951.                 XmlTokenizedType ttype = builder._AttributeDef._AttDef.Datatype.TokenizedType;
  952.                
  953.                 if (ttype == XmlTokenizedType.ENUMERATION && !builder._AttributeDef._EnumerationRequired) {
  954.                     code = Res.Sch_MissDtvaluesAttribute;
  955.                     goto cleanup;
  956.                 }
  957.                
  958.                 if (ttype != XmlTokenizedType.ENUMERATION && builder._AttributeDef._EnumerationRequired) {
  959.                     code = Res.Sch_RequireEnumeration;
  960.                     goto cleanup;
  961.                 }
  962.                
  963.                 // a attributes of type id is not supposed to have a default value
  964.                 if (builder._AttributeDef._Default != null && ttype == XmlTokenizedType.ID) {
  965.                     code = Res.Sch_DefaultIdValue;
  966.                     goto cleanup;
  967.                 }
  968.             }
  969.             else {
  970.                 builder._AttributeDef._AttDef.Datatype = XmlSchemaDatatype.FromXmlTokenizedType(XmlTokenizedType.CDATA);
  971.             }
  972.            
  973.             //
  974.             // constraints
  975.             //
  976.             CompareMinMaxLength(builder._AttributeDef._MinLength, builder._AttributeDef._MaxLength, builder);
  977.             builder._AttributeDef._AttDef.MaxLength = builder._AttributeDef._MaxLength;
  978.             builder._AttributeDef._AttDef.MinLength = builder._AttributeDef._MinLength;
  979.            
  980.             //
  981.             // checkAttributeType
  982.             //
  983.             if (builder._AttributeDef._Default != null) {
  984.                 builder._AttributeDef._AttDef.DefaultValueRaw = builder._AttributeDef._AttDef.DefaultValueExpanded = (string)builder._AttributeDef._Default;
  985.                 builder.CheckDefaultAttValue(builder._AttributeDef._AttDef);
  986.             }
  987.            
  988.             builder.SetAttributePresence(builder._AttributeDef._AttDef, builder._AttributeDef._Required);
  989.             cleanup:
  990.            
  991.             if (code != null) {
  992.                 builder.SendValidationEvent(code);
  993.             }
  994.         }
  995.        
  996.        
  997.         //
  998.         // XDR Element
  999.         //
  1000.        
  1001.         private static void XDR_InitElement(XdrBuilder builder, object obj)
  1002.         {
  1003.             if (builder._ElementDef._HasDataType || (builder._ElementDef._ContentAttr == SchemaContentEmpty) || (builder._ElementDef._ContentAttr == SchemaContentText)) {
  1004.                 builder.SendValidationEvent(Res.Sch_ElementNotAllowed);
  1005.             }
  1006.            
  1007.             builder._ElementDef._AllowDataType = false;
  1008.            
  1009.             builder._ElementDef._HasType = false;
  1010.             builder._ElementDef._MinVal = 1;
  1011.             builder._ElementDef._MaxVal = 1;
  1012.         }
  1013.        
  1014.         private static void XDR_BuildElement_Type(XdrBuilder builder, object obj, string prefix)
  1015.         {
  1016.             XmlQualifiedName qname = (XmlQualifiedName)obj;
  1017.            
  1018.             if (builder._SchemaInfo.ElementDecls[qname] == null) {
  1019.                 SchemaElementDecl ed = (SchemaElementDecl)builder._UndeclaredElements[qname];
  1020.                 if (ed == null) {
  1021.                     ed = new SchemaElementDecl(qname, prefix, SchemaType.DTD);
  1022.                     builder._UndeclaredElements.Add(qname, ed);
  1023.                 }
  1024.             }
  1025.            
  1026.             builder._ElementDef._HasType = true;
  1027.             if (builder._ElementDef._ExistTerminal)
  1028.                 builder.AddOrder();
  1029.             else
  1030.                 builder._ElementDef._ExistTerminal = true;
  1031.            
  1032.             builder._contentValidator.AddName(qname, null);
  1033.         }
  1034.        
  1035.         private static void XDR_BuildElement_MinOccurs(XdrBuilder builder, object obj, string prefix)
  1036.         {
  1037.             builder._ElementDef._MinVal = ParseMinOccurs(obj, builder);
  1038.         }
  1039.        
  1040.         private static void XDR_BuildElement_MaxOccurs(XdrBuilder builder, object obj, string prefix)
  1041.         {
  1042.             builder._ElementDef._MaxVal = ParseMaxOccurs(obj, builder);
  1043.         }
  1044.        
  1045.        
  1046.         // private static void XDR_BeginElement(XdrBuilder builder)
  1047.         // {
  1048.         //
  1049.         // }
  1050.        
  1051.        
  1052.         private static void XDR_EndElement(XdrBuilder builder)
  1053.         {
  1054.             if (builder._ElementDef._HasType) {
  1055.                 HandleMinMax(builder._contentValidator, builder._ElementDef._MinVal, builder._ElementDef._MaxVal);
  1056.             }
  1057.             else {
  1058.                 builder.SendValidationEvent(Res.Sch_MissAttribute);
  1059.             }
  1060.         }
  1061.        
  1062.        
  1063.         //
  1064.         // XDR Attribute
  1065.         //
  1066.        
  1067.         private static void XDR_InitAttribute(XdrBuilder builder, object obj)
  1068.         {
  1069.             if (builder._BaseDecl == null)
  1070.                 builder._BaseDecl = new DeclBaseInfo();
  1071.             builder._BaseDecl._MinOccurs = 0;
  1072.         }
  1073.        
  1074.         private static void XDR_BuildAttribute_Type(XdrBuilder builder, object obj, string prefix)
  1075.         {
  1076.             builder._BaseDecl._TypeName = (XmlQualifiedName)obj;
  1077.             builder._BaseDecl._Prefix = prefix;
  1078.         }
  1079.        
  1080.         private static void XDR_BuildAttribute_Required(XdrBuilder builder, object obj, string prefix)
  1081.         {
  1082.             if (IsYes(obj, builder)) {
  1083.                 builder._BaseDecl._MinOccurs = 1;
  1084.             }
  1085.         }
  1086.        
  1087.         private static void XDR_BuildAttribute_Default(XdrBuilder builder, object obj, string prefix)
  1088.         {
  1089.             builder._BaseDecl._Default = obj;
  1090.         }
  1091.        
  1092.         private static void XDR_BeginAttribute(XdrBuilder builder)
  1093.         {
  1094.             if (builder._BaseDecl._TypeName.IsEmpty) {
  1095.                 builder.SendValidationEvent(Res.Sch_MissAttribute);
  1096.             }
  1097.            
  1098.             SchemaAttDef attdef = null;
  1099.             XmlQualifiedName qname = builder._BaseDecl._TypeName;
  1100.             string prefix = builder._BaseDecl._Prefix;
  1101.            
  1102.             // local?
  1103.             if (builder._ElementDef._AttDefList != null) {
  1104.                 attdef = (SchemaAttDef)builder._ElementDef._AttDefList[qname];
  1105.             }
  1106.            
  1107.             // global?
  1108.             if (attdef == null) {
  1109.                 // if there is no URN in this name then the name is local to the
  1110.                 // schema, but the global attribute was still URN qualified, so
  1111.                 // we need to qualify this name now.
  1112.                 XmlQualifiedName gname = qname;
  1113.                 if (prefix.Length == 0)
  1114.                     gname = new XmlQualifiedName(qname.Name, builder._TargetNamespace);
  1115.                 SchemaAttDef ad = (SchemaAttDef)builder._SchemaInfo.AttributeDecls[gname];
  1116.                 if (ad != null) {
  1117.                     attdef = (SchemaAttDef)ad.Clone();
  1118.                     attdef.Name = qname;
  1119.                 }
  1120.                 else if (prefix.Length != 0) {
  1121.                     builder.SendValidationEvent(Res.Sch_UndeclaredAttribute, XmlQualifiedName.ToString(qname.Name, prefix));
  1122.                 }
  1123.             }
  1124.            
  1125.             if (attdef != null) {
  1126.                 builder.XDR_CheckAttributeDefault(builder._BaseDecl, attdef);
  1127.             }
  1128.             else {
  1129.                 // will process undeclared types later
  1130.                 attdef = new SchemaAttDef(qname, prefix);
  1131.                 DeclBaseInfo decl = new DeclBaseInfo();
  1132.                 decl._Checking = true;
  1133.                 decl._Attdef = attdef;
  1134.                 decl._TypeName = builder._BaseDecl._TypeName;
  1135.                 decl._ElementDecl = builder._ElementDef._ElementDecl;
  1136.                 decl._MinOccurs = builder._BaseDecl._MinOccurs;
  1137.                 decl._Default = builder._BaseDecl._Default;
  1138.                
  1139.                 // add undefined attribute types
  1140.                 decl._Next = builder._UndefinedAttributeTypes;
  1141.                 builder._UndefinedAttributeTypes = decl;
  1142.             }
  1143.            
  1144.             builder._ElementDef._ElementDecl.AddAttDef(attdef);
  1145.         }
  1146.        
  1147.         private static void XDR_EndAttribute(XdrBuilder builder)
  1148.         {
  1149.             builder._BaseDecl.Reset();
  1150.         }
  1151.        
  1152.        
  1153.         //
  1154.         // XDR Group
  1155.         //
  1156.        
  1157.         private static void XDR_InitGroup(XdrBuilder builder, object obj)
  1158.         {
  1159.             if (builder._ElementDef._ContentAttr == SchemaContentEmpty || builder._ElementDef._ContentAttr == SchemaContentText) {
  1160.                 builder.SendValidationEvent(Res.Sch_GroupDisabled);
  1161.             }
  1162.            
  1163.             builder.PushGroupInfo();
  1164.            
  1165.             builder._GroupDef._MinVal = 1;
  1166.             builder._GroupDef._MaxVal = 1;
  1167.             builder._GroupDef._HasMaxAttr = false;
  1168.             builder._GroupDef._HasMinAttr = false;
  1169.            
  1170.             if (builder._ElementDef._ExistTerminal)
  1171.                 builder.AddOrder();
  1172.            
  1173.             // now we are in a group so we reset fExistTerminal
  1174.             builder._ElementDef._ExistTerminal = false;
  1175.            
  1176.             builder._contentValidator.OpenGroup();
  1177.         }
  1178.        
  1179.         private static void XDR_BuildGroup_Order(XdrBuilder builder, object obj, string prefix)
  1180.         {
  1181.             builder._GroupDef._Order = builder.GetOrder((XmlQualifiedName)obj);
  1182.             if (builder._ElementDef._ContentAttr == SchemaContentMixed && builder._GroupDef._Order != SchemaOrderMany) {
  1183.                 builder.SendValidationEvent(Res.Sch_MixedMany);
  1184.             }
  1185.         }
  1186.        
  1187.         private static void XDR_BuildGroup_MinOccurs(XdrBuilder builder, object obj, string prefix)
  1188.         {
  1189.             builder._GroupDef._MinVal = ParseMinOccurs(obj, builder);
  1190.             builder._GroupDef._HasMinAttr = true;
  1191.         }
  1192.        
  1193.         private static void XDR_BuildGroup_MaxOccurs(XdrBuilder builder, object obj, string prefix)
  1194.         {
  1195.             builder._GroupDef._MaxVal = ParseMaxOccurs(obj, builder);
  1196.             builder._GroupDef._HasMaxAttr = true;
  1197.         }
  1198.        
  1199.        
  1200.         // private static void XDR_BeginGroup(XdrBuilder builder)
  1201.         // {
  1202.         //
  1203.         // }
  1204.        
  1205.        
  1206.         private static void XDR_EndGroup(XdrBuilder builder)
  1207.         {
  1208.             if (!builder._ElementDef._ExistTerminal) {
  1209.                 builder.SendValidationEvent(Res.Sch_ElementMissing);
  1210.             }
  1211.            
  1212.             builder._contentValidator.CloseGroup();
  1213.            
  1214.             if (builder._GroupDef._Order == SchemaOrderMany) {
  1215.                 builder._contentValidator.AddStar();
  1216.             }
  1217.            
  1218.             if (SchemaOrderMany == builder._GroupDef._Order && builder._GroupDef._HasMaxAttr && builder._GroupDef._MaxVal != uint.MaxValue) {
  1219.                 builder.SendValidationEvent(Res.Sch_ManyMaxOccurs);
  1220.             }
  1221.            
  1222.             HandleMinMax(builder._contentValidator, builder._GroupDef._MinVal, builder._GroupDef._MaxVal);
  1223.            
  1224.             builder.PopGroupInfo();
  1225.         }
  1226.        
  1227.        
  1228.         //
  1229.         // DataType
  1230.         //
  1231.        
  1232.         private static void XDR_InitElementDtType(XdrBuilder builder, object obj)
  1233.         {
  1234.             if (builder._ElementDef._HasDataType) {
  1235.                 builder.SendValidationEvent(Res.Sch_DupDtType);
  1236.             }
  1237.            
  1238.             if (!builder._ElementDef._AllowDataType) {
  1239.                 builder.SendValidationEvent(Res.Sch_DataTypeTextOnly);
  1240.             }
  1241.         }
  1242.        
  1243.         private static void XDR_EndElementDtType(XdrBuilder builder)
  1244.         {
  1245.             if (!builder._ElementDef._HasDataType) {
  1246.                 builder.SendValidationEvent(Res.Sch_MissAttribute);
  1247.             }
  1248.             builder._ElementDef._ElementDecl.ContentValidator = ContentValidator.TextOnly;
  1249.             builder._ElementDef._ContentAttr = SchemaContentText;
  1250.             builder._ElementDef._MasterGroupRequired = false;
  1251.             builder._contentValidator = null;
  1252.         }
  1253.        
  1254.         private static void XDR_InitAttributeDtType(XdrBuilder builder, object obj)
  1255.         {
  1256.             if (builder._AttributeDef._HasDataType) {
  1257.                 builder.SendValidationEvent(Res.Sch_DupDtType);
  1258.             }
  1259.         }
  1260.        
  1261.         private static void XDR_EndAttributeDtType(XdrBuilder builder)
  1262.         {
  1263.             string code = null;
  1264.            
  1265.             if (!builder._AttributeDef._HasDataType) {
  1266.                 code = Res.Sch_MissAttribute;
  1267.             }
  1268.             else {
  1269.                 if (builder._AttributeDef._AttDef.Datatype != null) {
  1270.                     XmlTokenizedType ttype = builder._AttributeDef._AttDef.Datatype.TokenizedType;
  1271.                    
  1272.                     if (ttype == XmlTokenizedType.ENUMERATION && !builder._AttributeDef._EnumerationRequired) {
  1273.                         code = Res.Sch_MissDtvaluesAttribute;
  1274.                     }
  1275.                     else if (ttype != XmlTokenizedType.ENUMERATION && builder._AttributeDef._EnumerationRequired) {
  1276.                         code = Res.Sch_RequireEnumeration;
  1277.                     }
  1278.                 }
  1279.             }
  1280.             if (code != null) {
  1281.                 builder.SendValidationEvent(code);
  1282.             }
  1283.         }
  1284.        
  1285.         //
  1286.         // private utility methods
  1287.         //
  1288.        
  1289.         private bool GetNextState(XmlQualifiedName qname)
  1290.         {
  1291.             if (_CurState._NextStates != null) {
  1292.                 for (int i = 0; i < _CurState._NextStates.Length; i++) {
  1293.                     if (_SchemaNames.TokenToQName[(int)S_SchemaEntries[_CurState._NextStates[i]]._Name].Equals(qname)) {
  1294.                         _NextState = S_SchemaEntries[_CurState._NextStates[i]];
  1295.                         return true;
  1296.                     }
  1297.                 }
  1298.             }
  1299.            
  1300.             return false;
  1301.         }
  1302.        
  1303.         private bool IsSkipableElement(XmlQualifiedName qname)
  1304.         {
  1305.             string ns = qname.Namespace;
  1306.             if (ns != null && !Ref.Equal(ns, _SchemaNames.NsXdr))
  1307.                 return true;
  1308.            
  1309.             // skip description && extends
  1310.             if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.XdrDescription].Equals(qname) || _SchemaNames.TokenToQName[(int)SchemaNames.Token.XdrExtends].Equals(qname))
  1311.                 return true;
  1312.            
  1313.             return false;
  1314.         }
  1315.        
  1316.         private bool IsSkipableAttribute(XmlQualifiedName qname)
  1317.         {
  1318.             string ns = qname.Namespace;
  1319.             if (ns.Length != 0 && !Ref.Equal(ns, _SchemaNames.NsXdr) && !Ref.Equal(ns, _SchemaNames.NsDataType)) {
  1320.                 return true;
  1321.             }
  1322.            
  1323.             if (Ref.Equal(ns, _SchemaNames.NsDataType) && _CurState._Name == SchemaNames.Token.XdrDatatype && (_SchemaNames.QnDtMax.Equals(qname) || _SchemaNames.QnDtMin.Equals(qname) || _SchemaNames.QnDtMaxExclusive.Equals(qname) || _SchemaNames.QnDtMinExclusive.Equals(qname))) {
  1324.                 return true;
  1325.             }
  1326.            
  1327.             return false;
  1328.         }
  1329.        
  1330.         private int GetOrder(XmlQualifiedName qname)
  1331.         {
  1332.             int order = 0;
  1333.             if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaSeq].Equals(qname)) {
  1334.                 order = SchemaOrderSequence;
  1335.             }
  1336.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaOne].Equals(qname)) {
  1337.                 order = SchemaOrderChoice;
  1338.             }
  1339.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaMany].Equals(qname)) {
  1340.                 order = SchemaOrderMany;
  1341.             }
  1342.             else {
  1343.                 SendValidationEvent(Res.Sch_UnknownOrder, qname.Name);
  1344.             }
  1345.            
  1346.             return order;
  1347.         }
  1348.        
  1349.         private void AddOrder()
  1350.         {
  1351.             // additional order can be add on by changing the setOrder and addOrder
  1352.             switch (_GroupDef._Order) {
  1353.                 case SchemaOrderSequence:
  1354.                     _contentValidator.AddSequence();
  1355.                     break;
  1356.                 case SchemaOrderChoice:
  1357.                 case SchemaOrderMany:
  1358.                     _contentValidator.AddChoice();
  1359.                     break;
  1360.                 default:
  1361.                 case SchemaOrderAll:
  1362.                     throw new XmlException(Res.Xml_UnexpectedToken, "NAME");
  1363.                     break;
  1364.             }
  1365.         }
  1366.        
  1367.         private static bool IsYes(object obj, XdrBuilder builder)
  1368.         {
  1369.             XmlQualifiedName qname = (XmlQualifiedName)obj;
  1370.             bool fYes = false;
  1371.            
  1372.             if (qname.Name == "yes") {
  1373.                 fYes = true;
  1374.             }
  1375.             else if (qname.Name != "no") {
  1376.                 builder.SendValidationEvent(Res.Sch_UnknownRequired);
  1377.             }
  1378.            
  1379.             return fYes;
  1380.         }
  1381.        
  1382.         private static uint ParseMinOccurs(object obj, XdrBuilder builder)
  1383.         {
  1384.             uint cVal = 1;
  1385.            
  1386.             if (!ParseInteger((string)obj, ref cVal) || (cVal != 0 && cVal != 1)) {
  1387.                 builder.SendValidationEvent(Res.Sch_MinOccursInvalid);
  1388.             }
  1389.             return cVal;
  1390.         }
  1391.        
  1392.         private static uint ParseMaxOccurs(object obj, XdrBuilder builder)
  1393.         {
  1394.             uint cVal = uint.MaxValue;
  1395.             string s = (string)obj;
  1396.            
  1397.             if (!s.Equals("*") && (!ParseInteger(s, ref cVal) || (cVal != uint.MaxValue && cVal != 1))) {
  1398.                 builder.SendValidationEvent(Res.Sch_MaxOccursInvalid);
  1399.             }
  1400.             return cVal;
  1401.         }
  1402.        
  1403.         private static void HandleMinMax(ParticleContentValidator pContent, uint cMin, uint cMax)
  1404.         {
  1405.             if (pContent != null) {
  1406.                 if (cMax == uint.MaxValue) {
  1407.                     if (cMin == 0)
  1408.                         pContent.AddStar();
  1409.                     else
  1410.                         // minOccurs="0" and maxOccurs="infinite"
  1411.                         pContent.AddPlus();
  1412.                     // minOccurs="1" and maxOccurs="infinite"
  1413.                 }
  1414.                 else if (cMin == 0) {
  1415.                     // minOccurs="0" and maxOccurs="1")
  1416.                     pContent.AddQMark();
  1417.                 }
  1418.             }
  1419.         }
  1420.        
  1421.         private static void ParseDtMaxLength(ref uint cVal, object obj, XdrBuilder builder)
  1422.         {
  1423.             if (uint.MaxValue != cVal) {
  1424.                 builder.SendValidationEvent(Res.Sch_DupDtMaxLength);
  1425.             }
  1426.            
  1427.             if (!ParseInteger((string)obj, ref cVal) || cVal < 0) {
  1428.                 builder.SendValidationEvent(Res.Sch_DtMaxLengthInvalid, obj.ToString());
  1429.             }
  1430.         }
  1431.        
  1432.         private static void ParseDtMinLength(ref uint cVal, object obj, XdrBuilder builder)
  1433.         {
  1434.             if (uint.MaxValue != cVal) {
  1435.                 builder.SendValidationEvent(Res.Sch_DupDtMinLength);
  1436.             }
  1437.            
  1438.             if (!ParseInteger((string)obj, ref cVal) || cVal < 0) {
  1439.                 builder.SendValidationEvent(Res.Sch_DtMinLengthInvalid, obj.ToString());
  1440.             }
  1441.         }
  1442.        
  1443.         private static void CompareMinMaxLength(uint cMin, uint cMax, XdrBuilder builder)
  1444.         {
  1445.             if (cMin != uint.MaxValue && cMax != uint.MaxValue && cMin > cMax) {
  1446.                 builder.SendValidationEvent(Res.Sch_DtMinMaxLength);
  1447.             }
  1448.         }
  1449.        
  1450.         private static bool ParseInteger(string str, ref uint n)
  1451.         {
  1452.             return UInt32.TryParse(str, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out n);
  1453.         }
  1454.        
  1455.         private void XDR_CheckAttributeDefault(DeclBaseInfo decl, SchemaAttDef pAttdef)
  1456.         {
  1457.             if (decl._Default != null || pAttdef.DefaultValueTyped != null) {
  1458.                 if (decl._Default != null) {
  1459.                     pAttdef.DefaultValueRaw = pAttdef.DefaultValueExpanded = (string)decl._Default;
  1460.                     CheckDefaultAttValue(pAttdef);
  1461.                 }
  1462.             }
  1463.            
  1464.             SetAttributePresence(pAttdef, 1 == decl._MinOccurs);
  1465.         }
  1466.        
  1467.         private void SetAttributePresence(SchemaAttDef pAttdef, bool fRequired)
  1468.         {
  1469.             if (SchemaDeclBase.Use.Fixed != pAttdef.Presence) {
  1470.                 if (fRequired || SchemaDeclBase.Use.Required == pAttdef.Presence) {
  1471.                     // If it is required and it has a default value then it is a FIXED attribute.
  1472.                     if (pAttdef.DefaultValueTyped != null)
  1473.                         pAttdef.Presence = SchemaDeclBase.Use.Fixed;
  1474.                     else
  1475.                         pAttdef.Presence = SchemaDeclBase.Use.Required;
  1476.                 }
  1477.                 else if (pAttdef.DefaultValueTyped != null) {
  1478.                     pAttdef.Presence = SchemaDeclBase.Use.Default;
  1479.                 }
  1480.                 else {
  1481.                     pAttdef.Presence = SchemaDeclBase.Use.Implied;
  1482.                 }
  1483.             }
  1484.         }
  1485.        
  1486.         private int GetContent(XmlQualifiedName qname)
  1487.         {
  1488.             int content = 0;
  1489.             if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaEmpty].Equals(qname)) {
  1490.                 content = SchemaContentEmpty;
  1491.                 _ElementDef._AllowDataType = false;
  1492.             }
  1493.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaElementOnly].Equals(qname)) {
  1494.                 content = SchemaContentElement;
  1495.                 _ElementDef._AllowDataType = false;
  1496.             }
  1497.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaMixed].Equals(qname)) {
  1498.                 content = SchemaContentMixed;
  1499.                 _ElementDef._AllowDataType = false;
  1500.             }
  1501.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaTextOnly].Equals(qname)) {
  1502.                 content = SchemaContentText;
  1503.             }
  1504.             else {
  1505.                 SendValidationEvent(Res.Sch_UnknownContent, qname.Name);
  1506.             }
  1507.             return content;
  1508.         }
  1509.        
  1510.         private bool GetModel(XmlQualifiedName qname)
  1511.         {
  1512.             bool fOpen = false;
  1513.             if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaOpen].Equals(qname))
  1514.                 fOpen = true;
  1515.             else if (_SchemaNames.TokenToQName[(int)SchemaNames.Token.SchemaClosed].Equals(qname))
  1516.                 fOpen = false;
  1517.             else
  1518.                 SendValidationEvent(Res.Sch_UnknownModel, qname.Name);
  1519.             return fOpen;
  1520.         }
  1521.        
  1522.         private XmlSchemaDatatype CheckDatatype(string str)
  1523.         {
  1524.             XmlSchemaDatatype dtype = XmlSchemaDatatype.FromXdrName(str);
  1525.             if (dtype == null) {
  1526.                 SendValidationEvent(Res.Sch_UnknownDtType, str);
  1527.             }
  1528.             else if (dtype.TokenizedType == XmlTokenizedType.ID) {
  1529.                 if (!_AttributeDef._Global) {
  1530.                     if (_ElementDef._ElementDecl.IsIdDeclared) {
  1531.                         SendValidationEvent(Res.Sch_IdAttrDeclared, XmlQualifiedName.ToString(_ElementDef._ElementDecl.Name.Name, _ElementDef._ElementDecl.Prefix));
  1532.                     }
  1533.                     _ElementDef._ElementDecl.IsIdDeclared = true;
  1534.                 }
  1535.             }
  1536.            
  1537.             return dtype;
  1538.         }
  1539.        
  1540.         private void CheckDefaultAttValue(SchemaAttDef attDef)
  1541.         {
  1542.             string str = (attDef.DefaultValueRaw).Trim();
  1543.             XdrValidator.CheckDefaultValue(str, attDef, _SchemaInfo, _CurNsMgr, _NameTable, null, validationEventHandler, _reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition
  1544.             );
  1545.         }
  1546.        
  1547.         private bool IsGlobal(int flags)
  1548.         {
  1549.             return flags == SchemaFlagsNs;
  1550.         }
  1551.        
  1552.         private void SendValidationEvent(string code, string[] args, XmlSeverityType severity)
  1553.         {
  1554.             SendValidationEvent(new XmlSchemaException(code, args, this._reader.BaseURI, this.positionInfo.LineNumber, this.positionInfo.LinePosition), severity);
  1555.         }
  1556.        
  1557.         private void SendValidationEvent(string code)
  1558.         {
  1559.             SendValidationEvent(code, string.Empty);
  1560.         }
  1561.        
  1562.         private void SendValidationEvent(string code, string msg)
  1563.         {
  1564.             SendValidationEvent(new XmlSchemaException(code, msg, this._reader.BaseURI, this.positionInfo.LineNumber, this.positionInfo.LinePosition), XmlSeverityType.Error);
  1565.         }
  1566.        
  1567.         private void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity)
  1568.         {
  1569.             _SchemaInfo.ErrorCount++;
  1570.             if (validationEventHandler != null) {
  1571.                 validationEventHandler(this, new ValidationEventArgs(e, severity));
  1572.             }
  1573.             else if (severity == XmlSeverityType.Error) {
  1574.                 throw e;
  1575.             }
  1576.         }
  1577.        
  1578.        
  1579.     }
  1580.     // class XdrBuilder
  1581. }
  1582. // namespace System.Xml

Developer Fusion