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