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