?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / class / System.XML / System.Xml.Schema / XmlSchemaElement.cs
blob9ccb00f4a0d65383513c47985897194b9cdb8751
1 //
2 // System.Xml.Schema.XmlSchemaElement.cs
3 //
4 // Authors:
5 // Dwivedi, Ajay kumar Adwiv@Yahoo.com
6 // Enomoto, Atsushi ginga@kit.hi-ho.ne.jp
7 //
8
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining
11 // a copy of this software and associated documentation files (the
12 // "Software"), to deal in the Software without restriction, including
13 // without limitation the rights to use, copy, modify, merge, publish,
14 // distribute, sublicense, and/or sell copies of the Software, and to
15 // permit persons to whom the Software is furnished to do so, subject to
16 // the following conditions:
17 //
18 // The above copyright notice and this permission notice shall be
19 // included in all copies or substantial portions of the Software.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 //
29 using System;
30 using System.Collections;
31 using System.Xml;
32 using System.Xml.Serialization;
33 using System.ComponentModel;
34
35 namespace System.Xml.Schema
36 {
37 /// <summary>
38 /// Summary description for XmlSchemaElement.
39 /// </summary>
40 public class XmlSchemaElement : XmlSchemaParticle
41 {
42 private XmlSchemaDerivationMethod block;
43 private XmlSchemaObjectCollection constraints;
44 private string defaultValue;
45 private object elementType;
46 #if NET_2_0
47 private XmlSchemaType elementSchemaType;
48 #endif
49 private XmlSchemaDerivationMethod final;
50 private string fixedValue;
51 private XmlSchemaForm form;
52 private bool isAbstract;
53 private bool isNillable;
54 private string name;
55 private XmlQualifiedName refName;
56 private XmlSchemaType schemaType;
57 private XmlQualifiedName schemaTypeName;
58 private XmlQualifiedName substitutionGroup;
59
60 // Post compilation items.
61 XmlSchema schema;
62 internal bool parentIsSchema = false;
63 private XmlQualifiedName qName;
64 private XmlSchemaDerivationMethod blockResolved;
65 private XmlSchemaDerivationMethod finalResolved;
66 private XmlSchemaParticle substChoice;
67 private XmlSchemaElement referencedElement;
68 private ArrayList substitutingElements = new ArrayList ();
69 private XmlSchemaElement substitutionGroupElement;
70 private bool actualIsAbstract;
71 private bool actualIsNillable;
72 private string validatedDefaultValue;
73 private string validatedFixedValue;
74
75 const string xmlname = "element";
76
77 public XmlSchemaElement()
78 {
79 block = XmlSchemaDerivationMethod.None;
80 final = XmlSchemaDerivationMethod.None;
81 constraints = new XmlSchemaObjectCollection();
82 refName = XmlQualifiedName.Empty;
83 schemaTypeName = XmlQualifiedName.Empty;
84 substitutionGroup = XmlQualifiedName.Empty;
85 InitPostCompileInformations ();
86 }
87
88 private void InitPostCompileInformations ()
89 {
90 qName = XmlQualifiedName.Empty;
91 schema = null;
92 // parentIsSchema = false; ... it is set in Schema's Compile()
93 blockResolved = XmlSchemaDerivationMethod.None;
94 finalResolved = XmlSchemaDerivationMethod.None;
95 substChoice = null;
96 referencedElement = null;
97 substitutingElements.Clear ();
98 substitutionGroupElement = null;
99 actualIsAbstract = false;
100 actualIsNillable = false;
101 validatedDefaultValue = null;
102 validatedFixedValue = null;
103 }
104
105 #region Attributes
106
107 [DefaultValue(false)]
108 [System.Xml.Serialization.XmlAttribute("abstract")]
109 public bool IsAbstract
110 {
111 get{ return isAbstract; }
112 set{ isAbstract = value; }
113 }
114
115 [DefaultValue(XmlSchemaDerivationMethod.None)]
116 [System.Xml.Serialization.XmlAttribute("block")]
117 public XmlSchemaDerivationMethod Block
118 {
119 get{ return block; }
120 set{ block = value; }
121 }
122
123 [DefaultValue(null)]
124 [System.Xml.Serialization.XmlAttribute("default")]
125 public string DefaultValue
126 {
127 get{ return defaultValue; }
128 set{ defaultValue = value; }
129 }
130
131 [DefaultValue(XmlSchemaDerivationMethod.None)]
132 [System.Xml.Serialization.XmlAttribute("final")]
133 public XmlSchemaDerivationMethod Final
134 {
135 get{ return final; }
136 set{ final = value; }
137 }
138
139 [DefaultValue(null)]
140 [System.Xml.Serialization.XmlAttribute("fixed")]
141 public string FixedValue
142 {
143 get{ return fixedValue; }
144 set{ fixedValue = value; }
145 }
146 [DefaultValue(XmlSchemaForm.None)]
147 [System.Xml.Serialization.XmlAttribute("form")]
148 public XmlSchemaForm Form
149 {
150 get{ return form; }
151 set{ form = value; }
152 }
153
154 [DefaultValue(null)]
155 [System.Xml.Serialization.XmlAttribute("name")]
156 public string Name
157 {
158 get{ return name; }
159 set{ name = value; }
160 }
161
162 [DefaultValue(false)]
163 [System.Xml.Serialization.XmlAttribute("nillable")]
164 public bool IsNillable
165 {
166 get{ return isNillable; }
167 set{ isNillable = value; }
168 }
169
170 [System.Xml.Serialization.XmlAttribute("ref")]
171 public XmlQualifiedName RefName
172 {
173 get{ return refName; }
174 set{ refName = value;}
175 }
176
177 [System.Xml.Serialization.XmlAttribute("substitutionGroup")]
178 public XmlQualifiedName SubstitutionGroup
179 {
180 get{ return substitutionGroup; }
181 set{ substitutionGroup = value; }
182 }
183
184 [System.Xml.Serialization.XmlAttribute("type")]
185 public XmlQualifiedName SchemaTypeName
186 {
187 get{ return schemaTypeName; }
188 set{ schemaTypeName = value; }
189 }
190 #endregion
191
192 #region Elements
193
194 [XmlElement("simpleType",typeof(XmlSchemaSimpleType),Namespace="http://www.w3.org/2001/XMLSchema")]
195 [XmlElement("complexType",typeof(XmlSchemaComplexType),Namespace="http://www.w3.org/2001/XMLSchema")]
196 public XmlSchemaType SchemaType
197 {
198 get{ return schemaType; }
199 set{ schemaType = value; }
200 }
201
202 [XmlElement("unique",typeof(XmlSchemaUnique),Namespace="http://www.w3.org/2001/XMLSchema")]
203 [XmlElement("key",typeof(XmlSchemaKey),Namespace="http://www.w3.org/2001/XMLSchema")]
204 [XmlElement("keyref",typeof(XmlSchemaKeyref),Namespace="http://www.w3.org/2001/XMLSchema")]
205 public XmlSchemaObjectCollection Constraints
206 {
207 get{ return constraints; }
208 }
209 #endregion
210
211 #region Post Compilation Schema Info
212 [XmlIgnore]
213 public XmlQualifiedName QualifiedName
214 {
215 get{ return qName; }
216 }
217
218 [XmlIgnore]
219 #if NET_2_0
220 [Obsolete]
221 #endif
222 public object ElementType
223 {
224 get {
225 if (referencedElement != null)
226 return referencedElement.ElementType;
227 else
228 return elementType;
229 }
230 }
231
232 #if NET_2_0
233 [XmlIgnore]
234 public XmlSchemaType ElementSchemaType
235 {
236 get {
237 if (referencedElement != null)
238 return referencedElement.ElementSchemaType;
239 else
240 return elementSchemaType;
241 }
242 }
243 #endif
244
245 [XmlIgnore]
246 public XmlSchemaDerivationMethod BlockResolved
247 {
248 get{
249 if (referencedElement != null)
250 return referencedElement.BlockResolved;
251 else
252 return blockResolved;
253 }
254 }
255
256 [XmlIgnore]
257 public XmlSchemaDerivationMethod FinalResolved
258 {
259 get{
260 if (referencedElement != null)
261 return referencedElement.FinalResolved;
262 else
263 return finalResolved;
264 }
265 }
266
267 internal bool ActualIsNillable {
268 get {
269 if (referencedElement != null)
270 return referencedElement.ActualIsNillable;
271 else
272 return actualIsNillable;
273 }
274 }
275
276 internal bool ActualIsAbstract {
277 get {
278 if (referencedElement != null)
279 return referencedElement.ActualIsAbstract;
280 else
281 return actualIsAbstract;
282 }
283 }
284
285 // Post compilation default value (normalized)
286 internal string ValidatedDefaultValue {
287 get{
288 if (referencedElement != null)
289 return referencedElement.ValidatedDefaultValue;
290 else
291 return validatedDefaultValue;
292 }
293 }
294
295 // Post compilation fixed value (normalized)
296 internal string ValidatedFixedValue {
297 get{
298 if (referencedElement != null)
299 return referencedElement.ValidatedFixedValue;
300 else
301 return validatedFixedValue;
302 }
303 }
304
305 internal ArrayList SubstitutingElements {
306 get {
307 if (referencedElement != null)
308 return referencedElement.SubstitutingElements;
309 else
310 return this.substitutingElements;
311 }
312 }
313
314 internal XmlSchemaElement SubstitutionGroupElement {
315 get {
316 if (referencedElement != null)
317 return referencedElement.SubstitutionGroupElement;
318 else
319 return substitutionGroupElement;
320 }
321 }
322
323 #endregion
324
325 /// <remarks>
326 /// a) If Element has parent as schema:
327 /// 1. name must be present and of type NCName.
328 /// 2. ref must be absent
329 /// 3. form must be absent
330 /// 4. minOccurs must be absent
331 /// 5. maxOccurs must be absent
332 /// b) If Element has parent is not schema and ref is absent
333 /// 1. name must be present and of type NCName.
334 /// 2. if form equals qualified or form is absent and schema's formdefault is qualifed,
335 /// targetNamespace is schema's targetnamespace else empty.
336 /// 3. type and either <simpleType> or <complexType> are mutually exclusive
337 /// 4. default and fixed must not both be present.
338 /// 5. substitutiongroup must be absent
339 /// 6. final must be absent
340 /// 7. abstract must be absent
341 /// c) if the parent is not schema and ref is set
342 /// 1. name must not be present
343 /// 2. all of <simpleType>,<complexType>, <key>, <keyref>, <unique>, nillable,
344 /// default, fixed, form, block and type, must be absent.
345 /// 3. substitutiongroup is prohibited
346 /// 4. final is prohibited
347 /// 5. abstract is prohibited
348 /// 6. default and fixed must not both be present.(Actually both are absent)
349 /// </remarks>
350 internal override int Compile(ValidationEventHandler h, XmlSchema schema)
351 {
352 // If this is already compiled this time, simply skip.
353 if (this.IsComplied (schema.CompilationId))
354 return 0;
355 InitPostCompileInformations ();
356 this.schema = schema;
357
358 if(this.defaultValue != null && this.fixedValue != null)
359 error(h,"both default and fixed can't be present");
360
361 if(parentIsSchema || isRedefineChild)
362 {
363 if(this.refName != null && !RefName.IsEmpty)
364 error(h,"ref must be absent");
365
366 if(this.name == null) //b1
367 error(h,"Required attribute name must be present");
368 else if(!XmlSchemaUtil.CheckNCName(this.name)) // b1.2
369 error(h,"attribute name must be NCName");
370 else
371 this.qName = new XmlQualifiedName (this.name, schema.TargetNamespace);
372
373 if(form != XmlSchemaForm.None)
374 error(h,"form must be absent");
375 if(MinOccursString != null)
376 error(h,"minOccurs must be absent");
377 if(MaxOccursString != null)
378 error(h,"maxOccurs must be absent");
379
380 XmlSchemaDerivationMethod allfinal = (XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Restriction);
381 if(final == XmlSchemaDerivationMethod.All)
382 finalResolved = allfinal;
383 else if(final == XmlSchemaDerivationMethod.None)
384 finalResolved = XmlSchemaDerivationMethod.Empty;
385 else
386 {
387 // if((final & ~allfinal) != 0)
388 if ((final | XmlSchemaUtil.FinalAllowed) != XmlSchemaUtil.FinalAllowed)
389 error (h,"some values for final are invalid in this context");
390 finalResolved = final & allfinal;
391 }
392
393 if(schemaType != null && schemaTypeName != null && !schemaTypeName.IsEmpty)
394 {
395 error(h,"both schemaType and content can't be present");
396 }
397
398 //Even if both are present, read both of them.
399 if(schemaType != null)
400 {
401 if(schemaType is XmlSchemaSimpleType)
402 {
403 errorCount += ((XmlSchemaSimpleType)schemaType).Compile(h,schema);
404 }
405 else if(schemaType is XmlSchemaComplexType)
406 {
407 errorCount += ((XmlSchemaComplexType)schemaType).Compile(h,schema);
408 }
409 else
410 error(h,"only simpletype or complextype is allowed");
411 }
412 if(schemaTypeName != null && !schemaTypeName.IsEmpty)
413 {
414 if(!XmlSchemaUtil.CheckQName(SchemaTypeName))
415 error(h,"SchemaTypeName must be an XmlQualifiedName");
416 }
417 if(SubstitutionGroup != null && !SubstitutionGroup.IsEmpty)
418 {
419 if(!XmlSchemaUtil.CheckQName(SubstitutionGroup))
420 error(h,"SubstitutionGroup must be a valid XmlQualifiedName");
421 }
422
423 foreach(XmlSchemaObject obj in constraints)
424 {
425 if(obj is XmlSchemaUnique)
426 errorCount += ((XmlSchemaUnique)obj).Compile(h,schema);
427 else if(obj is XmlSchemaKey)
428 errorCount += ((XmlSchemaKey)obj).Compile(h,schema);
429 else if(obj is XmlSchemaKeyref)
430 errorCount += ((XmlSchemaKeyref)obj).Compile(h,schema);
431 }
432 }
433 else
434 {
435 if(substitutionGroup != null && !substitutionGroup.IsEmpty)
436 error(h,"substitutionGroup must be absent");
437 if(final != XmlSchemaDerivationMethod.None)
438 error(h,"final must be absent");
439
440 CompileOccurence (h, schema);
441
442 if(refName == null || RefName.IsEmpty)
443 {
444 string targetNamespace = String.Empty;
445
446 if(form == XmlSchemaForm.Qualified || (form == XmlSchemaForm.None && schema.ElementFormDefault == XmlSchemaForm.Qualified))
447 targetNamespace = schema.TargetNamespace;
448
449 if(this.name == null) //b1
450 error(h,"Required attribute name must be present");
451 else if(!XmlSchemaUtil.CheckNCName(this.name)) // b1.2
452 error(h,"attribute name must be NCName");
453 else
454 this.qName = new XmlQualifiedName(this.name, targetNamespace);
455
456 if(schemaType != null && schemaTypeName != null && !schemaTypeName.IsEmpty)
457 {
458 error(h,"both schemaType and content can't be present");
459 }
460
461 //Even if both are present, read both of them.
462 if(schemaType != null)
463 {
464 if(schemaType is XmlSchemaSimpleType)
465 {
466 errorCount += ((XmlSchemaSimpleType)schemaType).Compile(h,schema);
467 }
468 else if(schemaType is XmlSchemaComplexType)
469 {
470 errorCount += ((XmlSchemaComplexType)schemaType).Compile(h,schema);
471 }
472 else
473 error(h,"only simpletype or complextype is allowed");
474 }
475 if(schemaTypeName != null && !schemaTypeName.IsEmpty)
476 {
477 if(!XmlSchemaUtil.CheckQName(SchemaTypeName))
478 error(h,"SchemaTypeName must be an XmlQualifiedName");
479 }
480 if(SubstitutionGroup != null && !SubstitutionGroup.IsEmpty)
481 {
482 if(!XmlSchemaUtil.CheckQName(SubstitutionGroup))
483 error(h,"SubstitutionGroup must be a valid XmlQualifiedName");
484 }
485
486 foreach(XmlSchemaObject obj in constraints)
487 {
488 if(obj is XmlSchemaUnique)
489 errorCount += ((XmlSchemaUnique)obj).Compile(h,schema);
490 else if(obj is XmlSchemaKey)
491 errorCount += ((XmlSchemaKey)obj).Compile(h,schema);
492 else if(obj is XmlSchemaKeyref)
493 errorCount += ((XmlSchemaKeyref)obj).Compile(h,schema);
494 }
495 }
496 else
497 {
498 if(!XmlSchemaUtil.CheckQName(RefName))
499 error(h,"RefName must be a XmlQualifiedName");
500
501 if(name != null)
502 error(h,"name must not be present when ref is present");
503 if(Constraints.Count != 0)
504 error(h,"key, keyref and unique must be absent");
505 if(isNillable)
506 error(h,"nillable must be absent");
507 if(defaultValue != null)
508 error(h,"default must be absent");
509 if(fixedValue != null)
510 error(h,"fixed must be null");
511 if(form != XmlSchemaForm.None)
512 error(h,"form must be absent");
513 if(block != XmlSchemaDerivationMethod.None)
514 error(h,"block must be absent");
515 if(schemaTypeName != null && !schemaTypeName.IsEmpty)
516 error(h,"type must be absent");
517 if(SchemaType != null)
518 error(h,"simpleType or complexType must be absent");
519
520 qName = RefName;
521 }
522 }
523
524 switch (block) {
525 case XmlSchemaDerivationMethod.All:
526 blockResolved = XmlSchemaDerivationMethod.All;
527 break;
528 case XmlSchemaDerivationMethod.None:
529 blockResolved = XmlSchemaDerivationMethod.Empty;
530 break;
531 default:
532 if ((block | XmlSchemaUtil.ElementBlockAllowed) != XmlSchemaUtil.ElementBlockAllowed)
533 error (h,"Some of the values for block are invalid in this context");
534 blockResolved = block;
535 break;
536 }
537
538 if (Constraints != null) {
539 XmlSchemaObjectTable table = new XmlSchemaObjectTable ();
540 foreach (XmlSchemaIdentityConstraint c in Constraints) {
541 XmlSchemaUtil.AddToTable (table, c, c.QualifiedName, h);
542 }
543 }
544
545 XmlSchemaUtil.CompileID(Id,this,schema.IDCollection,h);
546
547 this.CompilationId = schema.CompilationId;
548 return errorCount;
549 }
550
551 [MonoTODO ("Return clone in case when it returns itself")]
552 internal override XmlSchemaParticle GetOptimizedParticle (bool isTop)
553 {
554 if (OptimizedParticle != null)
555 return OptimizedParticle;
556 if (RefName != null && RefName != XmlQualifiedName.Empty) {
557 referencedElement = schema.Elements [RefName] as XmlSchemaElement;
558 }
559
560 // if (this.referencedElement != null)
561 // OptimizedParticle = referencedElement.GetOptimizedParticle (isTop);
562 // else
563 if (ValidatedMaxOccurs == 0)
564 OptimizedParticle = XmlSchemaParticle.Empty;
565 // Substitution Group
566 else if (SubstitutingElements != null && SubstitutingElements.Count > 0) {
567 XmlSchemaChoice choice = new XmlSchemaChoice ();
568 choice.MinOccurs = MinOccurs;
569 choice.MaxOccurs = MaxOccurs;
570 substChoice = choice;
571 choice.Compile (null, schema); // compute Validated Min/Max Occurs.
572 XmlSchemaElement item = this.MemberwiseClone () as XmlSchemaElement;
573 item.MinOccurs = 1;
574 item.MaxOccurs = 1;
575 item.substitutionGroupElement = null;
576 item.substitutingElements = null;
577 for (int i = 0; i < SubstitutingElements.Count; i++) {
578 XmlSchemaElement se = SubstitutingElements [i] as XmlSchemaElement;
579 // choice.Items.Add (se);
580 // choice.CompiledItems.Add (se);
581 this.AddSubstElementRecursively (choice.Items, se);
582 this.AddSubstElementRecursively (choice.CompiledItems, se);
583 }
584 if (!choice.Items.Contains (item)) {
585 choice.Items.Add (item);
586 choice.CompiledItems.Add (item);
587 }
588 OptimizedParticle = choice;
589 }
590 else
591 OptimizedParticle = this;//.MemberwiseClone () as XmlSchemaElement;
592 return OptimizedParticle;
593 }
594
595 private void AddSubstElementRecursively (XmlSchemaObjectCollection col, XmlSchemaElement el)
596 {
597 if (el.SubstitutingElements != null)
598 for (int i = 0; i < el.SubstitutingElements.Count; i++)
599 this.AddSubstElementRecursively (col, el.SubstitutingElements [i] as XmlSchemaElement);
600 if (!col.Contains (el))
601 col.Add (el);
602 }
603
604 internal void FillSubstitutionElementInfo ()
605 {
606 if (this.substitutionGroupElement != null)
607 return;
608
609 if (this.SubstitutionGroup != XmlQualifiedName.Empty) {
610 XmlSchemaElement substElem = schema.Elements [SubstitutionGroup] as XmlSchemaElement;
611 this.substitutionGroupElement = substElem;
612 if (substElem != null)
613 substElem.substitutingElements.Add (this);
614 }
615 }
616
617 internal override int Validate(ValidationEventHandler h, XmlSchema schema)
618 {
619 if (IsValidated (schema.CompilationId))
620 return errorCount;
621
622 // See XML Schema Structures 3.6 for the complete description.
623
624 // Element Declaration Properties Correct
625 // 1. = 3.3.1 (modulo 5.3)
626
627 // 3.3.1:
628 // {annotation} is as is.
629 // {name}, {target namespace}, {scope}, {disallowed substitution},
630 // {substitution group exclusions} (handled the same as 'disallowed substitution')
631 // and {identity-constraint-definitions} are Compile()d.
632 // {value constraint} is going to be filled in step 2.
633
634 // actual {nillable}, {abstract}
635 this.actualIsNillable = IsNillable;
636 this.actualIsAbstract = IsAbstract;
637
638 // Before determining element type, we need to validate substituting element
639 if (this.SubstitutionGroup != XmlQualifiedName.Empty) {
640 XmlSchemaElement substElem = substitutionGroupElement;
641 if (substElem != null)
642 substElem.Validate (h, schema);
643 }
644
645 // {type} from here
646 XmlSchemaDatatype datatype = null;
647 if (schemaType != null)
648 elementType = schemaType;
649 else if (SchemaTypeName != XmlQualifiedName.Empty) {
650 XmlSchemaType type = schema.SchemaTypes [SchemaTypeName] as XmlSchemaType;
651 if (type != null) {
652 type.Validate (h, schema);
653 elementType = type;
654 }
655 else if (SchemaTypeName == XmlSchemaComplexType.AnyTypeName)
656 elementType = XmlSchemaComplexType.AnyType;
657 else if (XmlSchemaUtil.IsBuiltInDatatypeName (SchemaTypeName)) {
658 datatype = XmlSchemaDatatype.FromName (SchemaTypeName);
659 if (datatype == null)
660 error (h, "Invalid schema datatype was specified.");
661 else
662 elementType = datatype;
663 }
664 // otherwise, it might be missing sub components.
665 else if (!schema.IsNamespaceAbsent (SchemaTypeName.Namespace))
666 error (h, "Referenced element schema type " + SchemaTypeName + " was not found in the corresponding schema.");
667 }
668 else if (RefName != XmlQualifiedName.Empty)
669 {
670 XmlSchemaElement refElem = schema.Elements [RefName] as XmlSchemaElement;
671 // If el is null, then it is missing sub components .
672 if (refElem != null) {
673 this.referencedElement = refElem;
674 errorCount += refElem.Validate (h, schema);
675 }
676 // otherwise, it might be missing sub components.
677 else if (!schema.IsNamespaceAbsent (RefName.Namespace))
678 error (h, "Referenced element " + RefName + " was not found in the corresponding schema.");
679 }
680
681 // Otherwise if there are substitution group, then the type of the substitution group element.
682 if (referencedElement == null) {
683 if (elementType == null && this.substitutionGroupElement != null)
684 elementType = substitutionGroupElement.ElementType;
685 // Otherwise, the -ur type- definition.
686 if (elementType == null)
687 elementType = XmlSchemaComplexType.AnyType;
688 }
689
690 XmlSchemaType xsType = elementType as XmlSchemaType;
691 if (xsType != null) {
692 errorCount += xsType.Validate (h, schema);
693 datatype = xsType.Datatype;
694 }
695 // basic {type} is now filled, except for derivation by {substitution group}.
696
697 // {substitution group affiliation}
698 // 3. subsitution group's type derivation check.
699 if (this.SubstitutionGroup != XmlQualifiedName.Empty) {
700 XmlSchemaElement substElem = schema.Elements [SubstitutionGroup] as XmlSchemaElement;
701 // If el is null, then it is missing sub components .
702 if (substElem != null) {
703 XmlSchemaType substSchemaType = substElem.ElementType as XmlSchemaType;
704 if (substSchemaType != null) {
705 // 3.3.6 Properties Correct 3.
706 if ((substElem.FinalResolved & XmlSchemaDerivationMethod.Substitution) != 0)
707 error (h, "Substituted element blocks substitution.");
708 if (xsType != null && (substElem.FinalResolved & xsType.DerivedBy) != 0)
709 error (h, "Invalid derivation was found. Substituted element prohibits this derivation method: " + xsType.DerivedBy + ".");
710 }
711 XmlSchemaComplexType xsComplexType = xsType as XmlSchemaComplexType;
712 if (xsComplexType != null)
713 xsComplexType.ValidateTypeDerivationOK (substElem.ElementType, h, schema);
714 else {
715 XmlSchemaSimpleType xsSimpleType = xsType as XmlSchemaSimpleType;
716 if (xsSimpleType != null)
717 xsSimpleType.ValidateTypeDerivationOK (substElem.ElementType, h, schema, true);
718 }
719
720 }
721 // otherwise, it might be missing sub components.
722 else if (!schema.IsNamespaceAbsent (SubstitutionGroup.Namespace))
723 error (h, "Referenced element type " + SubstitutionGroup + " was not found in the corresponding schema.");
724 }
725
726 // 2. ElementDefaultValid
727 // 4. ID with {value constraint} is prohibited.
728 if (defaultValue != null || fixedValue != null) {
729 ValidateElementDefaultValidImmediate (h, schema);
730 if (datatype != null && // Such situation is basically an error. For ValidationEventHandler.
731 datatype.TokenizedType == XmlTokenizedType.ID)
732 error (h, "Element type is ID, which does not allows default or fixed values.");
733 }
734
735 // Identity constraints (3.11.3 / 3.11.6)
736 foreach (XmlSchemaIdentityConstraint ident in Constraints)
737 ident.Validate (h, schema);
738
739 #if NET_2_0
740 elementSchemaType = elementType as XmlSchemaType;
741 if (elementSchemaType == null && elementType != null)
742 elementSchemaType = XmlSchemaType.GetBuiltInType (((XmlSchemaDatatype) elementType).TypeCode);
743 #endif
744
745 ValidationId = schema.ValidationId;
746 return errorCount;
747 }
748
749 internal override bool ParticleEquals (XmlSchemaParticle other)
750 {
751 XmlSchemaElement element = other as XmlSchemaElement;
752 if (element == null)
753 return false;
754 if (this.ValidatedMaxOccurs != element.ValidatedMaxOccurs ||
755 this.ValidatedMinOccurs != element.ValidatedMinOccurs)
756 return false;
757 if (this.QualifiedName != element.QualifiedName ||
758 this.ElementType != element.ElementType ||
759 this.Constraints.Count != element.Constraints.Count)
760 return false;
761 for (int i = 0; i < this.Constraints.Count; i++) {
762 XmlSchemaIdentityConstraint c1 = Constraints [i] as XmlSchemaIdentityConstraint;
763 XmlSchemaIdentityConstraint c2 = element.Constraints [i] as XmlSchemaIdentityConstraint;
764 if (c1.QualifiedName != c2.QualifiedName ||
765 c1.Selector.XPath != c2.Selector.XPath ||
766 c1.Fields.Count != c2.Fields.Count)
767 return false;
768 for (int f = 0; f < c1.Fields.Count; f++) {
769 XmlSchemaXPath f1 = c1.Fields [f] as XmlSchemaXPath;
770 XmlSchemaXPath f2 = c2.Fields [f] as XmlSchemaXPath;
771 if (f1.XPath != f2.XPath)
772 return false;
773 }
774 }
775 if (this.BlockResolved != element.BlockResolved ||
776 this.FinalResolved != element.FinalResolved ||
777 this.ValidatedDefaultValue != element.ValidatedDefaultValue ||
778 this.ValidatedFixedValue != element.ValidatedFixedValue)
779 return false;
780 return true;
781 }
782
783 internal override bool ValidateDerivationByRestriction (XmlSchemaParticle baseParticle,
784 ValidationEventHandler h, XmlSchema schema, bool raiseError)
785 {
786 // element - NameAndTypeOK
787 XmlSchemaElement baseElement = baseParticle as XmlSchemaElement;
788 if (baseElement != null) {
789 return ValidateDerivationByRestrictionNameAndTypeOK (baseElement, h, schema, raiseError);
790 }
791
792 // any - NSCompat
793 XmlSchemaAny baseAny = baseParticle as XmlSchemaAny;
794 if (baseAny != null) {
795 // NSCompat
796 if (!baseAny.ValidateWildcardAllowsNamespaceName (this.QualifiedName.Namespace, h, schema, raiseError))
797 return false;
798 return ValidateOccurenceRangeOK (baseAny, h, schema, raiseError);
799 }
800
801 //*
802 // choice - RecurseAsIfGroup
803 XmlSchemaGroupBase gb = null;
804 if (baseParticle is XmlSchemaSequence)
805 gb = new XmlSchemaSequence ();
806 else if (baseParticle is XmlSchemaChoice)
807 gb = new XmlSchemaChoice ();
808 else if (baseParticle is XmlSchemaAll)
809 gb = new XmlSchemaAll ();
810
811 if (gb != null) {
812 gb.Items.Add (this);
813 gb.Compile (h, schema);
814 gb.Validate (h, schema);
815 // It looks weird, but here we never think about
816 // _pointlessness_ of this groupbase particle.
817 return gb.ValidateDerivationByRestriction (baseParticle, h, schema, raiseError);
818 }
819 //*/
820 return true;
821 }
822
823 private bool ValidateDerivationByRestrictionNameAndTypeOK (XmlSchemaElement baseElement,
824 ValidationEventHandler h, XmlSchema schema, bool raiseError)
825 {
826 // 1.
827 if (this.QualifiedName != baseElement.QualifiedName) {
828 if (raiseError)
829 error (h, "Invalid derivation by restriction of particle was found. Both elements must have the same name.");
830 return false;
831 }
832 // 2.
833 if (this.isNillable && !baseElement.isNillable) {
834 if (raiseError)
835 error (h, "Invalid element derivation by restriction of particle was found. Base element is not nillable and derived type is nillable.");
836 return false;
837 }
838 // 3.
839 if (!ValidateOccurenceRangeOK (baseElement, h, schema, raiseError))
840 return false;
841 // 4.
842 if (baseElement.ValidatedFixedValue != null &&
843 baseElement.ValidatedFixedValue != this.ValidatedFixedValue) {
844 if (raiseError)
845 error (h, "Invalid element derivation by restriction of particle was found. Both fixed value must be the same.");
846 return false;
847 }
848 // 5. TODO: What is "identity constraints subset" ???
849
850 // 6.
851 if ((baseElement.BlockResolved | this.BlockResolved) != this.BlockResolved) {
852 if (raiseError)
853 error (h, "Invalid derivation by restriction of particle was found. Derived element must contain all of the base element's block value.");
854 return false;
855 }
856 // 7.
857 if (baseElement.ElementType != null) {
858 XmlSchemaComplexType derivedCType = this.ElementType as XmlSchemaComplexType;
859 if (derivedCType != null) {
860 // FIXME: W3C REC says that it is Type Derivation OK to be check, but
861 // in fact it should be DerivationValid (Restriction, Complex).
862 derivedCType.ValidateDerivationValidRestriction (
863 baseElement.ElementType as XmlSchemaComplexType, h, schema);
864 derivedCType.ValidateTypeDerivationOK (baseElement.ElementType, h, schema);
865 } else {
866 XmlSchemaSimpleType derivedSType = this.ElementType as XmlSchemaSimpleType;
867 if (derivedSType != null)
868 derivedSType.ValidateTypeDerivationOK (baseElement.ElementType, h, schema, true);
869 else if (baseElement.ElementType != XmlSchemaComplexType.AnyType && baseElement.ElementType != this.ElementType) {
870 if (raiseError)
871 error (h, "Invalid element derivation by restriction of particle was found. Both primitive types differ.");
872 return false;
873 }
874 }
875 }
876 return true;
877 }
878
879 internal override void CheckRecursion (int depth, ValidationEventHandler h, XmlSchema schema)
880 {
881 XmlSchemaComplexType ct = this.ElementType as XmlSchemaComplexType;
882 if (ct == null || ct.Particle == null)
883 return;
884 ct.Particle.CheckRecursion (depth + 1, h, schema);
885 }
886
887 internal override void ValidateUniqueParticleAttribution (XmlSchemaObjectTable qnames, ArrayList nsNames,
888 ValidationEventHandler h, XmlSchema schema)
889 {
890 if (qnames.Contains (this.QualifiedName))// && !this.ParticleEquals ((XmlSchemaParticle) qnames [this.QualifiedName]))
891 error (h, "Ambiguous element label was detected: " + this.QualifiedName);
892 else {
893 foreach (XmlSchemaAny any in nsNames) {
894 if (any.ValidatedMaxOccurs == 0)
895 continue;
896 if (any.HasValueAny ||
897 any.HasValueLocal && this.QualifiedName.Namespace == "" ||
898 any.HasValueOther && this.QualifiedName.Namespace != this.QualifiedName.Namespace ||
899 any.HasValueTargetNamespace && this.QualifiedName.Namespace == this.QualifiedName.Namespace) {
900 error (h, "Ambiguous element label which is contained by -any- particle was detected: " + this.QualifiedName);
901 break;
902 } else if (!any.HasValueOther) {
903 bool bad = false;
904 foreach (string ns in any.ResolvedNamespaces) {
905 if (ns == this.QualifiedName.Namespace) {
906 bad = true;
907 break;
908 }
909 }
910 if (bad) {
911 error (h, "Ambiguous element label which is contained by -any- particle was detected: " + this.QualifiedName);
912 break;
913 }
914 } else {
915 if (any.TargetNamespace.Length == 0 ||
916 any.TargetNamespace != this.QualifiedName.Namespace)
917 error (h, "Ambiguous element label which is contained by -any- particle with ##other value was detected: " + this.QualifiedName);
918 }
919 }
920 qnames.Add (this.QualifiedName, this);
921 }
922 }
923
924 internal override void ValidateUniqueTypeAttribution (XmlSchemaObjectTable labels,
925 ValidationEventHandler h, XmlSchema schema)
926 {
927 XmlSchemaElement labeled = labels [this.QualifiedName] as XmlSchemaElement;
928 if (labeled == null)
929 labels.Add (this.QualifiedName, this);
930 else if (labeled.ElementType != this.ElementType)
931 error (h, "Different types are specified on the same named elements in the same sequence. Element name is " + QualifiedName);
932 }
933
934
935 // 3.3.6 Element Default Valid (Immediate)
936 private void ValidateElementDefaultValidImmediate (ValidationEventHandler h, XmlSchema schema)
937 {
938 // This presumes that ElementType is already filled.
939
940 XmlSchemaDatatype datatype = elementType as XmlSchemaDatatype;
941 XmlSchemaSimpleType simpleType = elementType as XmlSchemaSimpleType;
942 if (simpleType != null)
943 datatype = simpleType.Datatype;
944
945 if (datatype == null) {
946 XmlSchemaComplexType complexType = elementType as XmlSchemaComplexType;
947 switch (complexType.ContentType) {
948 case XmlSchemaContentType.Empty:
949 case XmlSchemaContentType.ElementOnly:
950 error (h, "Element content type must be simple type or mixed.");
951 break;
952 }
953 datatype = XmlSchemaSimpleType.AnySimpleType;
954 }
955
956 XmlNamespaceManager nsmgr = null;
957 if (datatype.TokenizedType == XmlTokenizedType.QName) {
958 if (this.Namespaces != null)
959 foreach (XmlQualifiedName qname in Namespaces.ToArray ())
960 nsmgr.AddNamespace (qname.Name, qname.Namespace);
961 }
962
963 try {
964 if (defaultValue != null) {
965 validatedDefaultValue = datatype.Normalize (defaultValue);
966 datatype.ParseValue (validatedDefaultValue, null, nsmgr);
967 }
968 } catch (Exception ex) {
969 // FIXME: This is not a good way to handle exception, but
970 // I think there is no remedy for such Framework specification.
971 error (h, "The Element's default value is invalid with respect to its type definition.", ex);
972 }
973 try {
974 if (fixedValue != null) {
975 validatedFixedValue = datatype.Normalize (fixedValue);
976 datatype.ParseValue (validatedFixedValue, null, nsmgr);
977 }
978 } catch (Exception ex) {
979 // FIXME: This is not a good way to handle exception.
980 error (h, "The Element's fixed value is invalid with its type definition.", ex);
981 }
982 }
983
984 //<element
985 // abstract = boolean : false
986 // block = (#all | List of (extension | restriction | substitution))
987 // default = string
988 // final = (#all | List of (extension | restriction))
989 // fixed = string
990 // form = (qualified | unqualified)
991 // id = ID
992 // maxOccurs = (nonNegativeInteger | unbounded) : 1
993 // minOccurs = nonNegativeInteger : 1
994 // name = NCName
995 // nillable = boolean : false
996 // ref = QName
997 // substitutionGroup = QName
998 // type = QName
999 // {any attributes with non-schema namespace . . .}>
1000 // Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
1001 //</element>
1002
1003 internal static XmlSchemaElement Read(XmlSchemaReader reader, ValidationEventHandler h)
1004 {
1005 XmlSchemaElement element = new XmlSchemaElement();
1006 Exception innerex;
1007 reader.MoveToElement();
1008
1009 if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
1010 {
1011 error(h,"Should not happen :1: XmlSchemaElement.Read, name="+reader.Name,null);
1012 reader.Skip();
1013 return null;
1014 }
1015
1016 element.LineNumber = reader.LineNumber;
1017 element.LinePosition = reader.LinePosition;
1018 element.SourceUri = reader.BaseURI;
1019
1020 while(reader.MoveToNextAttribute())
1021 {
1022 if(reader.Name == "abstract")
1023 {
1024 element.IsAbstract = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
1025 if(innerex != null)
1026 error(h,reader.Value + " is invalid value for abstract",innerex);
1027 }
1028 else if(reader.Name == "block")
1029 {
1030 element.block = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "block",
1031 XmlSchemaUtil.ElementBlockAllowed);
1032 if(innerex != null)
1033 error (h,"some invalid values for block attribute were found",innerex);
1034 }
1035 else if(reader.Name == "default")
1036 {
1037 element.defaultValue = reader.Value;
1038 }
1039 else if(reader.Name == "final")
1040 {
1041 element.Final = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "final",
1042 XmlSchemaUtil.FinalAllowed);
1043 if(innerex != null)
1044 error (h,"some invalid values for final attribute were found",innerex);
1045 }
1046 else if(reader.Name == "fixed")
1047 {
1048 element.fixedValue = reader.Value;
1049 }
1050 else if(reader.Name == "form")
1051 {
1052 element.form = XmlSchemaUtil.ReadFormAttribute(reader,out innerex);
1053 if(innerex != null)
1054 error(h,reader.Value + " is an invalid value for form attribute",innerex);
1055 }
1056 else if(reader.Name == "id")
1057 {
1058 element.Id = reader.Value;
1059 }
1060 else if(reader.Name == "maxOccurs")
1061 {
1062 try
1063 {
1064 element.MaxOccursString = reader.Value;
1065 }
1066 catch(Exception e)
1067 {
1068 error(h,reader.Value + " is an invalid value for maxOccurs",e);
1069 }
1070 }
1071 else if(reader.Name == "minOccurs")
1072 {
1073 try
1074 {
1075 element.MinOccursString = reader.Value;
1076 }
1077 catch(Exception e)
1078 {
1079 error(h,reader.Value + " is an invalid value for minOccurs",e);
1080 }
1081 }
1082 else if(reader.Name == "name")
1083 {
1084 element.Name = reader.Value;
1085 }
1086 else if(reader.Name == "nillable")
1087 {
1088 element.IsNillable = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
1089 if(innerex != null)
1090 error(h,reader.Value + "is not a valid value for nillable",innerex);
1091 }
1092 else if(reader.Name == "ref")
1093 {
1094 element.refName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
1095 if(innerex != null)
1096 error(h, reader.Value + " is not a valid value for ref attribute",innerex);
1097 }
1098 else if(reader.Name == "substitutionGroup")
1099 {
1100 element.substitutionGroup = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
1101 if(innerex != null)
1102 error(h, reader.Value + " is not a valid value for substitutionGroup attribute",innerex);
1103 }
1104 else if(reader.Name == "type")
1105 {
1106 element.SchemaTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
1107 if(innerex != null)
1108 error(h, reader.Value + " is not a valid value for type attribute",innerex);
1109 }
1110 else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
1111 {
1112 error(h,reader.Name + " is not a valid attribute for element",null);
1113 }
1114 else
1115 {
1116 XmlSchemaUtil.ReadUnhandledAttribute(reader,element);
1117 }
1118 }
1119
1120 reader.MoveToElement();
1121 if(reader.IsEmptyElement)
1122 return element;
1123
1124 // Content: annotation?,
1125 // (simpleType | complexType)?,
1126 // (unique | key | keyref)*
1127 int level = 1;
1128 while(reader.ReadNextElement())
1129 {
1130 if(reader.NodeType == XmlNodeType.EndElement)
1131 {
1132 if(reader.LocalName != xmlname)
1133 error(h,"Should not happen :2: XmlSchemaElement.Read, name="+reader.Name,null);
1134 break;
1135 }
1136 if(level <= 1 && reader.LocalName == "annotation")
1137 {
1138 level = 2; //Only one annotation
1139 XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
1140 if(annotation != null)
1141 element.Annotation = annotation;
1142 continue;
1143 }
1144 if(level <= 2)
1145 {
1146 if(reader.LocalName == "simpleType")
1147 {
1148 level = 3;
1149 XmlSchemaSimpleType simple = XmlSchemaSimpleType.Read(reader,h);
1150 if(simple != null)
1151 element.SchemaType = simple;
1152 continue;
1153 }
1154 if(reader.LocalName == "complexType")
1155 {
1156 level = 3;
1157 XmlSchemaComplexType complex = XmlSchemaComplexType.Read(reader,h);
1158 if(complex != null)
1159 {
1160 element.SchemaType = complex;
1161 }
1162 continue;
1163 }
1164 }
1165 if(level <= 3)
1166 {
1167 if(reader.LocalName == "unique")
1168 {
1169 level = 3;
1170 XmlSchemaUnique unique = XmlSchemaUnique.Read(reader,h);
1171 if(unique != null)
1172 element.constraints.Add(unique);
1173 continue;
1174 }
1175 else if(reader.LocalName == "key")
1176 {
1177 level = 3;
1178 XmlSchemaKey key = XmlSchemaKey.Read(reader,h);
1179 if(key != null)
1180 element.constraints.Add(key);
1181 continue;
1182 }
1183 else if(reader.LocalName == "keyref")
1184 {
1185 level = 3;
1186 XmlSchemaKeyref keyref = XmlSchemaKeyref.Read(reader,h);
1187 if(keyref != null)
1188 element.constraints.Add(keyref);
1189 continue;
1190 }
1191 }
1192 reader.RaiseInvalidElementError();
1193 }
1194 return element;
1195 }
1196 }
1197 }
Mirror of the official Mono project git repository