?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-06-21 Atsushi Enomoto <atsushi@ximian.com>
[mcs.git] / class / System.XML / System.Xml / XmlTextReader.cs
blobf9422aa1b27f6681612a1b01c99de58052764cab
1 //
2 // System.Xml.XmlTextReader
3 //
4 // Author:
5 // Jason Diamond (jason@injektilo.org)
6 // Adam Treat (manyoso@yahoo.com)
7 // Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
8 //
9 // (C) 2001, 2002 Jason Diamond http://injektilo.org/
10 // Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
11 //
12 // Permission is hereby granted, free of charge, to any person obtaining
13 // a copy of this software and associated documentation files (the
14 // "Software"), to deal in the Software without restriction, including
15 // without limitation the rights to use, copy, modify, merge, publish,
16 // distribute, sublicense, and/or sell copies of the Software, and to
17 // permit persons to whom the Software is furnished to do so, subject to
18 // the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be
21 // included in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 //
31 //#define USE_NAME_BUFFER
32
33 //
34 // Optimization TODOs:
35 //
36 // - support PushbackChar() which reverts one character read.
37 // - ReadTextReader() should always keep one pushback buffer
38 // as pushback safety net.
39 // - Replace (peek,read) * n -> read * n + pushback
40 //
41
42 using System;
43 using System.Collections;
44 #if NET_2_0
45 using System.Collections.Generic;
46 #endif
47 using System.Globalization;
48 using System.IO;
49 using System.Security.Permissions;
50 using System.Text;
51 using System.Xml.Schema;
52 using Mono.Xml;
53
54 #if NET_2_0
55 using System.Xml;
56
57 namespace Mono.Xml2
58 #else
59 namespace System.Xml
60 #endif
61 {
62
63 #if NET_2_0
64 internal class XmlTextReader : XmlReader,
65 IXmlLineInfo, IXmlNamespaceResolver, IHasXmlParserContext
66 #else
67 [PermissionSet (SecurityAction.InheritanceDemand, Unrestricted = true)]
68 public class XmlTextReader : XmlReader, IXmlLineInfo, IHasXmlParserContext
69 #endif
70 {
71 #region Constructors
72
73 protected XmlTextReader ()
74 {
75 }
76
77 public XmlTextReader (Stream input)
78 : this (new XmlStreamReader (input))
79 {
80 }
81
82 public XmlTextReader (string url)
83 : this(url, new NameTable ())
84 {
85 }
86
87 public XmlTextReader (TextReader input)
88 : this (input, new NameTable ())
89 {
90 }
91
92 protected XmlTextReader (XmlNameTable nt)
93 : this (String.Empty, null, XmlNodeType.None, null)
94 {
95 }
96
97 public XmlTextReader (Stream input, XmlNameTable nt)
98 : this(new XmlStreamReader (input), nt)
99 {
100 }
101
102 public XmlTextReader (string url, Stream input)
103 : this (url, new XmlStreamReader (input))
104 {
105 }
106
107 public XmlTextReader (string url, TextReader input)
108 : this (url, input, new NameTable ())
109 {
110 }
111
112 public XmlTextReader (string url, XmlNameTable nt)
113 {
114 string uriString;
115 Stream stream = GetStreamFromUrl (url, out uriString);
116 XmlParserContext ctx = new XmlParserContext (nt,
117 new XmlNamespaceManager (nt),
118 String.Empty,
119 XmlSpace.None);
120 this.InitializeContext (uriString, ctx, new XmlStreamReader (stream), XmlNodeType.Document);
121 }
122
123 public XmlTextReader (TextReader input, XmlNameTable nt)
124 : this (String.Empty, input, nt)
125 {
126 }
127
128 // This is used in XmlReader.Create() to indicate that string
129 // argument is uri, not an xml fragment.
130 internal XmlTextReader (bool dummy, XmlResolver resolver, string url, XmlNodeType fragType, XmlParserContext context)
131 {
132 if (resolver == null) {
133 #if MOONLIGHT
134 resolver = new XmlXapResolver ();
135 #else
136 resolver = new XmlUrlResolver ();
137 #endif
138 }
139 this.XmlResolver = resolver;
140 string uriString;
141 Stream stream = GetStreamFromUrl (url, out uriString);
142 this.InitializeContext (uriString, context, new XmlStreamReader (stream), fragType);
143 }
144
145 public XmlTextReader (Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
146 : this (context != null ? context.BaseURI : String.Empty,
147 new XmlStreamReader (xmlFragment),
148 fragType,
149 context)
150 {
151 disallowReset = true;
152 }
153
154 internal XmlTextReader (string baseURI, TextReader xmlFragment, XmlNodeType fragType)
155 : this (baseURI, xmlFragment, fragType, null)
156 {
157 }
158
159 public XmlTextReader (string url, Stream input, XmlNameTable nt)
160 : this (url, new XmlStreamReader (input), nt)
161 {
162 }
163
164 public XmlTextReader (string url, TextReader input, XmlNameTable nt)
165 : this (url, input, XmlNodeType.Document, null)
166 {
167 }
168
169 public XmlTextReader (string xmlFragment, XmlNodeType fragType, XmlParserContext context)
170 : this (context != null ? context.BaseURI : String.Empty,
171 new StringReader (xmlFragment),
172 fragType,
173 context)
174 {
175 disallowReset = true;
176 }
177
178 internal XmlTextReader (string url, TextReader fragment, XmlNodeType fragType, XmlParserContext context)
179 {
180 InitializeContext (url, context, fragment, fragType);
181 }
182
183 private Stream GetStreamFromUrl (string url, out string absoluteUriString)
184 {
185 #if NET_2_1
186 if (url == null)
187 throw new ArgumentNullException ("url");
188 if (url.Length == 0)
189 throw new ArgumentException ("url");
190 #endif
191 Uri uri = resolver.ResolveUri (null, url);
192 absoluteUriString = uri != null ? uri.ToString () : String.Empty;
193 return resolver.GetEntity (uri, null, typeof (Stream)) as Stream;
194 }
195
196 #endregion
197
198 #region Properties
199
200 public override int AttributeCount
201 {
202 get { return attributeCount; }
203 }
204
205 public override string BaseURI
206 {
207 get { return parserContext.BaseURI; }
208 }
209
210 #if NET_2_0
211 public override bool CanReadBinaryContent {
212 get { return true; }
213 }
214
215 public override bool CanReadValueChunk {
216 get { return true; }
217 }
218 #else
219 internal override bool CanReadBinaryContent {
220 get { return true; }
221 }
222
223 internal override bool CanReadValueChunk {
224 get { return true; }
225 }
226 #endif
227
228 internal bool CharacterChecking {
229 get { return checkCharacters; }
230 set { checkCharacters = value; }
231 }
232
233 // for XmlReaderSettings.CloseInput support
234 internal bool CloseInput {
235 get { return closeInput; }
236 set { closeInput = value; }
237 }
238
239 public override int Depth
240 {
241 get {
242 int nodeTypeMod = currentToken.NodeType == XmlNodeType.Element ? 0 : -1;
243 if (currentAttributeValue >= 0)
244 return nodeTypeMod + elementDepth + 2; // inside attribute value.
245 else if (currentAttribute >= 0)
246 return nodeTypeMod + elementDepth + 1;
247 return elementDepth;
248 }
249 }
250
251 public Encoding Encoding
252 {
253 get { return parserContext.Encoding; }
254 }
255 #if NET_2_0
256 public EntityHandling EntityHandling {
257 get { return entityHandling; }
258 set { entityHandling = value; }
259 }
260 #endif
261
262 public override bool EOF {
263 get { return readState == ReadState.EndOfFile; }
264 }
265
266 public override bool HasValue {
267 get { return cursorToken.Value != null; }
268 }
269
270 public override bool IsDefault {
271 // XmlTextReader does not expand default attributes.
272 get { return false; }
273 }
274
275 public override bool IsEmptyElement {
276 get { return cursorToken.IsEmptyElement; }
277 }
278
279 #if NET_2_0
280 #else
281 public override string this [int i] {
282 get { return GetAttribute (i); }
283 }
284
285 public override string this [string name] {
286 get { return GetAttribute (name); }
287 }
288
289 public override string this [string localName, string namespaceName] {
290 get { return GetAttribute (localName, namespaceName); }
291 }
292 #endif
293
294 public int LineNumber {
295 get {
296 if (useProceedingLineInfo)
297 return line;
298 else
299 return cursorToken.LineNumber;
300 }
301 }
302
303 public int LinePosition {
304 get {
305 if (useProceedingLineInfo)
306 return column;
307 else
308 return cursorToken.LinePosition;
309 }
310 }
311
312 public override string LocalName {
313 get { return cursorToken.LocalName; }
314 }
315
316 public override string Name {
317 get { return cursorToken.Name; }
318 }
319
320 public bool Namespaces {
321 get { return namespaces; }
322 set {
323 if (readState != ReadState.Initial)
324 throw new InvalidOperationException ("Namespaces have to be set before reading.");
325 namespaces = value;
326 }
327 }
328
329 public override string NamespaceURI {
330 get { return cursorToken.NamespaceURI; }
331 }
332
333 public override XmlNameTable NameTable {
334 get { return nameTable; }
335 }
336
337 public override XmlNodeType NodeType {
338 get { return cursorToken.NodeType; }
339 }
340
341 public bool Normalization {
342 get { return normalization; }
343 set { normalization = value; }
344 }
345
346 public override string Prefix {
347 get { return cursorToken.Prefix; }
348 }
349
350 public bool ProhibitDtd {
351 get { return prohibitDtd; }
352 set { prohibitDtd = value; }
353 }
354
355 public override char QuoteChar {
356 get { return cursorToken.QuoteChar; }
357 }
358
359 public override ReadState ReadState {
360 get { return readState; }
361 }
362
363 #if NET_2_0
364 public override XmlReaderSettings Settings {
365 get { return base.Settings; }
366 }
367 #endif
368
369 public override string Value {
370 get { return cursorToken.Value != null ? cursorToken.Value : String.Empty; }
371 }
372
373 public WhitespaceHandling WhitespaceHandling {
374 get { return whitespaceHandling; }
375 set { whitespaceHandling = value; }
376 }
377
378 public override string XmlLang {
379 get { return parserContext.XmlLang; }
380 }
381
382 public XmlResolver XmlResolver {
383 set { resolver = value; }
384 }
385
386 public override XmlSpace XmlSpace {
387 get { return parserContext.XmlSpace; }
388 }
389
390 #endregion
391
392 #region Methods
393
394 public override void Close ()
395 {
396 readState = ReadState.Closed;
397
398 cursorToken.Clear ();
399 currentToken.Clear ();
400 attributeCount = 0;
401 if (closeInput && reader != null)
402 reader.Close ();
403 }
404
405 public override string GetAttribute (int i)
406 {
407 if (i >= attributeCount)
408 throw new ArgumentOutOfRangeException ("i is smaller than AttributeCount");
409 else {
410 return attributeTokens [i].Value;
411 }
412 }
413
414 // MS.NET 1.0 msdn says that this method returns String.Empty
415 // for absent attribute, but in fact it returns null.
416 // This description is corrected in MS.NET 1.1 msdn.
417 public override string GetAttribute (string name)
418 {
419 for (int i = 0; i < attributeCount; i++)
420 if (attributeTokens [i].Name == name)
421 return attributeTokens [i].Value;
422 return null;
423 }
424
425 private int GetIndexOfQualifiedAttribute (string localName, string namespaceURI)
426 {
427 for (int i = 0; i < attributeCount; i++) {
428 XmlAttributeTokenInfo ti = attributeTokens [i];
429 if (ti.LocalName == localName && ti.NamespaceURI == namespaceURI)
430 return i;
431 }
432 return -1;
433 }
434
435 XmlParserContext IHasXmlParserContext.ParserContext {
436 get { return parserContext; }
437 }
438
439 public override string GetAttribute (string localName, string namespaceURI)
440 {
441 int idx = this.GetIndexOfQualifiedAttribute (localName, namespaceURI);
442 if (idx < 0)
443 return null;
444 return attributeTokens [idx].Value;
445 }
446
447 #if NET_2_0
448 public IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope)
449 {
450 return nsmgr.GetNamespacesInScope (scope);
451 }
452
453 IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope (XmlNamespaceScope scope)
454 {
455 return GetNamespacesInScope (scope);
456 }
457 #endif
458
459 public TextReader GetRemainder ()
460 {
461 if (peekCharsLength < 0)
462 return reader;
463 return new StringReader (new string (peekChars, peekCharsIndex, peekCharsLength - peekCharsIndex) + reader.ReadToEnd ());
464 }
465
466 #if NET_2_0
467 public bool HasLineInfo ()
468 #else
469 bool IXmlLineInfo.HasLineInfo ()
470 #endif
471 {
472 return true;
473 }
474
475 public override string LookupNamespace (string prefix)
476 {
477 return LookupNamespace (prefix, false);
478 }
479
480 private string LookupNamespace (string prefix, bool atomizedNames)
481 {
482 string s = nsmgr.LookupNamespace (
483 prefix, atomizedNames);
484 return s == String.Empty ? null : s;
485 }
486
487 #if NET_2_0
488 string IXmlNamespaceResolver.LookupPrefix (string ns)
489 {
490 return LookupPrefix (ns, false);
491 }
492
493 public string LookupPrefix (string ns, bool atomizedName)
494 {
495 return nsmgr.LookupPrefix (ns, atomizedName);
496 }
497 #endif
498
499 public override void MoveToAttribute (int i)
500 {
501 if (i >= attributeCount)
502 throw new ArgumentOutOfRangeException ("attribute index out of range.");
503
504 currentAttribute = i;
505 currentAttributeValue = -1;
506 cursorToken = attributeTokens [i];
507 }
508
509 public override bool MoveToAttribute (string name)
510 {
511 for (int i = 0; i < attributeCount; i++) {
512 XmlAttributeTokenInfo ti = attributeTokens [i];
513 if (ti.Name == name) {
514 MoveToAttribute (i);
515 return true;
516 }
517 }
518 return false;
519 }
520
521 public override bool MoveToAttribute (string localName, string namespaceName)
522 {
523 int idx = GetIndexOfQualifiedAttribute (localName, namespaceName);
524 if (idx < 0)
525 return false;
526 MoveToAttribute (idx);
527 return true;
528 }
529
530 public override bool MoveToElement ()
531 {
532 if (currentToken == null) // for attribute .ctor()
533 return false;
534
535 if (cursorToken == currentToken)
536 return false;
537
538 if (currentAttribute >= 0) {
539 currentAttribute = -1;
540 currentAttributeValue = -1;
541 cursorToken = currentToken;
542 return true;
543 }
544 else
545 return false;
546 }
547
548 public override bool MoveToFirstAttribute ()
549 {
550 if (attributeCount == 0)
551 return false;
552 MoveToElement ();
553 return MoveToNextAttribute ();
554 }
555
556 public override bool MoveToNextAttribute ()
557 {
558 if (currentAttribute == 0 && attributeCount == 0)
559 return false;
560 if (currentAttribute + 1 < attributeCount) {
561 currentAttribute++;
562 currentAttributeValue = -1;
563 cursorToken = attributeTokens [currentAttribute];
564 return true;
565 }
566 else
567 return false;
568 }
569
570 public override bool Read ()
571 {
572 if (readState == ReadState.Closed)
573 return false;
574 curNodePeekIndex = peekCharsIndex;
575 preserveCurrentTag = true;
576 nestLevel = 0;
577 ClearValueBuffer ();
578
579 if (startNodeType == XmlNodeType.Attribute) {
580 if (currentAttribute == 0)
581 return false; // already read.
582 SkipTextDeclaration ();
583 ClearAttributes ();
584 IncrementAttributeToken ();
585 ReadAttributeValueTokens ('"');
586 cursorToken = attributeTokens [0];
587 currentAttributeValue = -1;
588 readState = ReadState.Interactive;
589 return true;
590 }
591 if (readState == ReadState.Initial && currentState == XmlNodeType.Element)
592 SkipTextDeclaration ();
593
594 if (Binary != null)
595 Binary.Reset ();
596
597 bool more = false;
598 readState = ReadState.Interactive;
599 currentLinkedNodeLineNumber = line;
600 currentLinkedNodeLinePosition = column;
601 useProceedingLineInfo = true;
602
603 cursorToken = currentToken;
604 attributeCount = 0;
605 currentAttribute = currentAttributeValue = -1;
606 currentToken.Clear ();
607
608 // It was moved from end of ReadStartTag ().
609 if (depthUp) {
610 ++depth;
611 depthUp = false;
612 }
613
614 if (readCharsInProgress) {
615 readCharsInProgress = false;
616 return ReadUntilEndTag ();
617 }
618
619 more = ReadContent ();
620
621 if (!more && startNodeType == XmlNodeType.Document && currentState != XmlNodeType.EndElement)
622 throw NotWFError ("Document element did not appear.");
623
624 useProceedingLineInfo = false;
625 return more;
626 }
627
628 public override bool ReadAttributeValue ()
629 {
630 if (readState == ReadState.Initial && startNodeType == XmlNodeType.Attribute) {
631 Read ();
632 }
633
634 if (currentAttribute < 0)
635 return false;
636 XmlAttributeTokenInfo ti = attributeTokens [currentAttribute];
637 if (currentAttributeValue < 0)
638 currentAttributeValue = ti.ValueTokenStartIndex - 1;
639
640 if (currentAttributeValue < ti.ValueTokenEndIndex) {
641 currentAttributeValue++;
642 cursorToken = attributeValueTokens [currentAttributeValue];
643 return true;
644 }
645 else
646 return false;
647 }
648
649 public int ReadBase64 (byte [] buffer, int offset, int length)
650 {
651 BinaryCharGetter = binaryCharGetter;
652 try {
653 return Binary.ReadBase64 (buffer, offset, length);
654 } finally {
655 BinaryCharGetter = null;
656 }
657 }
658
659 public int ReadBinHex (byte [] buffer, int offset, int length)
660 {
661 BinaryCharGetter = binaryCharGetter;
662 try {
663 return Binary.ReadBinHex (buffer, offset, length);
664 } finally {
665 BinaryCharGetter = null;
666 }
667 }
668
669 public int ReadChars (char [] buffer, int offset, int length)
670 {
671 if (offset < 0) {
672 throw new ArgumentOutOfRangeException (
673 #if !NET_2_1
674 "offset", offset,
675 #endif
676 "Offset must be non-negative integer.");
677
678 } else if (length < 0) {
679 throw new ArgumentOutOfRangeException (
680 #if !NET_2_1
681 "length", length,
682 #endif
683 "Length must be non-negative integer.");
684
685 } else if (buffer.Length < offset + length)
686 throw new ArgumentOutOfRangeException ("buffer length is smaller than the sum of offset and length.");
687
688 if (IsEmptyElement) {
689 Read ();
690 return 0;
691 }
692
693 if (!readCharsInProgress && NodeType != XmlNodeType.Element)
694 return 0;
695
696 preserveCurrentTag = false;
697 readCharsInProgress = true;
698 useProceedingLineInfo = true;
699
700 return ReadCharsInternal (buffer, offset, length);
701 }
702
703 public void ResetState ()
704 {
705 if (disallowReset)
706 throw new InvalidOperationException ("Cannot call ResetState when parsing an XML fragment.");
707 Clear ();
708 }
709
710 public override void ResolveEntity ()
711 {
712 // XmlTextReader does not resolve entities.
713 throw new InvalidOperationException ("XmlTextReader cannot resolve external entities.");
714 }
715
716 #if NET_2_0
717 [MonoTODO] // FIXME: Implement, for performance improvement
718 public override void Skip ()
719 {
720 base.Skip ();
721 }
722 #endif
723 #endregion
724
725 #region Internals
726 // Parsed DTD Objects
727 // Note that thgis property must be kept since dtd2xsd uses it.
728 internal DTDObjectModel DTD {
729 get { return parserContext.Dtd; }
730 }
731
732 internal XmlResolver Resolver {
733 get { return resolver; }
734 }
735 #endregion
736
737 #region Privates
738 internal class XmlTokenInfo
739 {
740 public XmlTokenInfo (XmlTextReader xtr)
741 {
742 Reader = xtr;
743 Clear ();
744 }
745
746 string valueCache;
747
748 protected XmlTextReader Reader;
749
750 public string Name;
751 public string LocalName;
752 public string Prefix;
753 public string NamespaceURI;
754 public bool IsEmptyElement;
755 public char QuoteChar;
756 public int LineNumber;
757 public int LinePosition;
758 public int ValueBufferStart;
759 public int ValueBufferEnd;
760
761 public XmlNodeType NodeType;
762
763 public virtual string Value {
764 get {
765 if (valueCache != null)
766 return valueCache;
767 if (ValueBufferStart >= 0) {
768 //Console.WriteLine (NodeType + " / " + ValueBuffer.Length + " / " + ValueBufferStart + " / " + ValueBufferEnd);
769 valueCache = Reader.valueBuffer.ToString (ValueBufferStart, ValueBufferEnd - ValueBufferStart);
770 return valueCache;
771 }
772 switch (NodeType) {
773 case XmlNodeType.Text:
774 case XmlNodeType.SignificantWhitespace:
775 case XmlNodeType.Whitespace:
776 case XmlNodeType.Comment:
777 case XmlNodeType.CDATA:
778 case XmlNodeType.ProcessingInstruction:
779 valueCache = Reader.CreateValueString ();
780 return valueCache;
781 }
782 return null;
783 }
784 set { valueCache = value; }
785 }
786
787 public virtual void Clear ()
788 {
789 ValueBufferStart = -1;
790 valueCache = null;
791 NodeType = XmlNodeType.None;
792 Name = LocalName = Prefix = NamespaceURI = String.Empty;
793 IsEmptyElement = false;
794 QuoteChar = '"';
795 LineNumber = LinePosition = 0;
796 }
797 }
798
799 internal class XmlAttributeTokenInfo : XmlTokenInfo
800 {
801 public XmlAttributeTokenInfo (XmlTextReader reader)
802 : base (reader)
803 {
804 NodeType = XmlNodeType.Attribute;
805 }
806
807 public int ValueTokenStartIndex;
808 public int ValueTokenEndIndex;
809 string valueCache;
810 StringBuilder tmpBuilder = new StringBuilder ();
811
812 public override string Value {
813 get {
814 if (valueCache != null)
815 return valueCache;
816
817 // An empty value should return String.Empty.
818 if (ValueTokenStartIndex == ValueTokenEndIndex) {
819 XmlTokenInfo ti = Reader.attributeValueTokens [ValueTokenStartIndex];
820 if (ti.NodeType == XmlNodeType.EntityReference)
821 valueCache = String.Concat ("&", ti.Name, ";");
822 else
823 valueCache = ti.Value;
824 return valueCache;
825 }
826
827 tmpBuilder.Length = 0;
828 for (int i = ValueTokenStartIndex; i <= ValueTokenEndIndex; i++) {
829 XmlTokenInfo ti = Reader.attributeValueTokens [i];
830 if (ti.NodeType == XmlNodeType.Text)
831 tmpBuilder.Append (ti.Value);
832 else {
833 tmpBuilder.Append ('&');
834 tmpBuilder.Append (ti.Name);
835 tmpBuilder.Append (';');
836 }
837 }
838
839 valueCache = tmpBuilder.ToString (0, tmpBuilder.Length);
840 return valueCache;
841 }
842
843 set { valueCache = value; }
844 }
845
846 public override void Clear ()
847 {
848 base.Clear ();
849 valueCache = null;
850 NodeType = XmlNodeType.Attribute;
851 ValueTokenStartIndex = ValueTokenEndIndex = 0;
852 }
853
854 internal void FillXmlns ()
855 {
856 if (Object.ReferenceEquals (Prefix, XmlNamespaceManager.PrefixXmlns))
857 Reader.nsmgr.AddNamespace (LocalName, Value);
858 else if (Object.ReferenceEquals (Name, XmlNamespaceManager.PrefixXmlns))
859 Reader.nsmgr.AddNamespace (String.Empty, Value);
860 }
861
862 internal void FillNamespace ()
863 {
864 if (Object.ReferenceEquals (Prefix, XmlNamespaceManager.PrefixXmlns) ||
865 Object.ReferenceEquals (Name, XmlNamespaceManager.PrefixXmlns))
866 NamespaceURI = XmlNamespaceManager.XmlnsXmlns;
867 else if (Prefix.Length == 0)
868 NamespaceURI = string.Empty;
869 else
870 NamespaceURI = Reader.LookupNamespace (Prefix, true);
871 }
872 }
873
874 private XmlTokenInfo cursorToken;
875 private XmlTokenInfo currentToken;
876 private XmlAttributeTokenInfo currentAttributeToken;
877 private XmlTokenInfo currentAttributeValueToken;
878 private XmlAttributeTokenInfo [] attributeTokens = new XmlAttributeTokenInfo [10];
879 private XmlTokenInfo [] attributeValueTokens = new XmlTokenInfo [10];
880 private int currentAttribute;
881 private int currentAttributeValue;
882 private int attributeCount;
883
884 private XmlParserContext parserContext;
885 private XmlNameTable nameTable;
886 private XmlNamespaceManager nsmgr;
887
888 private ReadState readState;
889 private bool disallowReset;
890
891 private int depth;
892 private int elementDepth;
893 private bool depthUp;
894
895 private bool popScope;
896
897 struct TagName
898 {
899 public TagName (string n, string l, string p)
900 {
901 Name = n;
902 LocalName = l;
903 Prefix = p;
904 }
905
906 public readonly string Name;
907 public readonly string LocalName;
908 public readonly string Prefix;
909 }
910
911 private TagName [] elementNames;
912 int elementNameStackPos;
913
914 private bool allowMultipleRoot;
915
916 private bool isStandalone;
917
918 private bool returnEntityReference;
919 private string entityReferenceName;
920
921 #if USE_NAME_BUFFER
922 private char [] nameBuffer;
923 private int nameLength;
924 private int nameCapacity;
925 private const int initialNameCapacity = 32;
926 #endif
927
928 private StringBuilder valueBuffer;
929
930 private TextReader reader;
931 private char [] peekChars;
932 private int peekCharsIndex;
933 private int peekCharsLength;
934 private int curNodePeekIndex;
935 private bool preserveCurrentTag;
936 private const int peekCharCapacity = 1024;
937
938 private int line;
939 private int column;
940
941 private int currentLinkedNodeLineNumber;
942 private int currentLinkedNodeLinePosition;
943 private bool useProceedingLineInfo;
944
945 private XmlNodeType startNodeType;
946 // State machine attribute.
947 // XmlDeclaration: after the first node.
948 // DocumentType: after doctypedecl
949 // Element: inside document element
950 // EndElement: after document element
951 private XmlNodeType currentState;
952
953 // For ReadChars()/ReadBase64()/ReadBinHex()
954 private int nestLevel;
955 private bool readCharsInProgress;
956 XmlReaderBinarySupport.CharGetter binaryCharGetter;
957
958 // These values are never re-initialized.
959 private bool namespaces = true;
960 private WhitespaceHandling whitespaceHandling = WhitespaceHandling.All;
961 #if MOONLIGHT
962 private XmlResolver resolver = new XmlXapResolver ();
963 #else
964 private XmlResolver resolver = new XmlUrlResolver ();
965 #endif
966 private bool normalization = false;
967
968 private bool checkCharacters;
969 private bool prohibitDtd = false;
970 private bool closeInput = true;
971 private EntityHandling entityHandling; // 2.0
972
973 private NameTable whitespacePool;
974 private char [] whitespaceCache;
975
976 private XmlException NotWFError (string message)
977 {
978 return new XmlException (this as IXmlLineInfo, BaseURI, message);
979 }
980
981 private void Init ()
982 {
983 allowMultipleRoot = false;
984 elementNames = new TagName [10];
985 valueBuffer = new StringBuilder ();
986 binaryCharGetter = new XmlReaderBinarySupport.CharGetter (ReadChars);
987 #if USE_NAME_BUFFER
988 nameBuffer = new char [initialNameCapacity];
989 #endif
990
991 checkCharacters = true;
992 #if NET_2_0
993 if (Settings != null)
994 checkCharacters = Settings.CheckCharacters;
995 #endif
996 prohibitDtd = false;
997 closeInput = true;
998 entityHandling = EntityHandling.ExpandCharEntities;
999
1000 peekCharsIndex = 0;
1001 if (peekChars == null)
1002 peekChars = new char [peekCharCapacity];
1003 peekCharsLength = -1;
1004 curNodePeekIndex = -1; // read from start
1005
1006 line = 1;
1007 column = 1;
1008
1009 currentLinkedNodeLineNumber = currentLinkedNodeLinePosition = 0;
1010
1011 Clear ();
1012 }
1013
1014 private void Clear ()
1015 {
1016 currentToken = new XmlTokenInfo (this);
1017 cursorToken = currentToken;
1018 currentAttribute = -1;
1019 currentAttributeValue = -1;
1020 attributeCount = 0;
1021
1022 readState = ReadState.Initial;
1023
1024 depth = 0;
1025 elementDepth = 0;
1026 depthUp = false;
1027
1028 popScope = allowMultipleRoot = false;
1029 elementNameStackPos = 0;
1030
1031 isStandalone = false;
1032 returnEntityReference = false;
1033 entityReferenceName = String.Empty;
1034
1035 #if USE_NAME_BUFFER
1036 nameLength = 0;
1037 nameCapacity = initialNameCapacity;
1038 #endif
1039 useProceedingLineInfo = false;
1040
1041 currentState = XmlNodeType.None;
1042
1043 readCharsInProgress = false;
1044 }
1045
1046 private void InitializeContext (string url, XmlParserContext context, TextReader fragment, XmlNodeType fragType)
1047 {
1048 startNodeType = fragType;
1049 parserContext = context;
1050 if (context == null) {
1051 XmlNameTable nt = new NameTable ();
1052 parserContext = new XmlParserContext (nt,
1053 new XmlNamespaceManager (nt),
1054 String.Empty,
1055 XmlSpace.None);
1056 }
1057 nameTable = parserContext.NameTable;
1058 nameTable = nameTable != null ? nameTable : new NameTable ();
1059 nsmgr = parserContext.NamespaceManager;
1060 nsmgr = nsmgr != null ? nsmgr : new XmlNamespaceManager (nameTable);
1061
1062 if (url != null && url.Length > 0) {
1063 #if NET_2_1
1064 Uri uri = new Uri (url, UriKind.RelativeOrAbsolute);
1065 #else
1066 Uri uri = null;
1067 try {
1068 #if NET_2_0
1069 uri = new Uri (url, UriKind.RelativeOrAbsolute);
1070 #else
1071 uri = new Uri (url);
1072 #endif
1073 } catch (Exception) {
1074 string path = Path.GetFullPath ("./a");
1075 uri = new Uri (new Uri (path), url);
1076 }
1077 #endif
1078 parserContext.BaseURI = uri.ToString ();
1079 }
1080
1081 Init ();
1082
1083 reader = fragment;
1084
1085 switch (fragType) {
1086 case XmlNodeType.Attribute:
1087 reader = new StringReader (fragment.ReadToEnd ().Replace ("\"", "&quot;"));
1088 break;
1089 case XmlNodeType.Element:
1090 currentState = XmlNodeType.Element;
1091 allowMultipleRoot = true;
1092 break;
1093 case XmlNodeType.Document:
1094 break;
1095 default:
1096 throw new XmlException (String.Format ("NodeType {0} is not allowed to create XmlTextReader.", fragType));
1097 }
1098 }
1099
1100 #if NET_2_0
1101 internal ConformanceLevel Conformance {
1102 get { return allowMultipleRoot ? ConformanceLevel.Fragment : ConformanceLevel.Document; }
1103 set {
1104 if (value == ConformanceLevel.Fragment) {
1105 currentState = XmlNodeType.Element;
1106 allowMultipleRoot = true;
1107 }
1108 }
1109 }
1110
1111 internal void AdjustLineInfoOffset (int lineNumberOffset, int linePositionOffset)
1112 {
1113 line += lineNumberOffset;
1114 column += linePositionOffset;
1115 }
1116
1117 internal void SetNameTable (XmlNameTable nameTable)
1118 {
1119 parserContext.NameTable = nameTable;
1120 }
1121 #endif
1122
1123 // Use this method rather than setting the properties
1124 // directly so that all the necessary properties can
1125 // be changed in harmony with each other. Maybe the
1126 // fields should be in a seperate class to help enforce
1127 // this.
1128 //
1129 // Namespace URI could not be provided here.
1130 private void SetProperties (
1131 XmlNodeType nodeType,
1132 string name,
1133 string prefix,
1134 string localName,
1135 bool isEmptyElement,
1136 string value,
1137 bool clearAttributes)
1138 {
1139 SetTokenProperties (currentToken, nodeType, name, prefix, localName, isEmptyElement, value, clearAttributes);
1140 currentToken.LineNumber = this.currentLinkedNodeLineNumber;
1141 currentToken.LinePosition = this.currentLinkedNodeLinePosition;
1142 }
1143
1144 private void SetTokenProperties (
1145 XmlTokenInfo token,
1146 XmlNodeType nodeType,
1147 string name,
1148 string prefix,
1149 string localName,
1150 bool isEmptyElement,
1151 string value,
1152 bool clearAttributes)
1153 {
1154 token.NodeType = nodeType;
1155 token.Name = name;
1156 token.Prefix = prefix;
1157 token.LocalName = localName;
1158 token.IsEmptyElement = isEmptyElement;
1159 token.Value = value;
1160 this.elementDepth = depth;
1161
1162 if (clearAttributes)
1163 ClearAttributes ();
1164 }
1165
1166 private void ClearAttributes ()
1167 {
1168 //for (int i = 0; i < attributeCount; i++)
1169 // attributeTokens [i].Clear ();
1170 attributeCount = 0;
1171 currentAttribute = -1;
1172 currentAttributeValue = -1;
1173 }
1174
1175 private int PeekSurrogate (int c)
1176 {
1177 if (peekCharsLength <= peekCharsIndex + 1) {
1178 if (!ReadTextReader (c))
1179 //FIXME: copy MS.NET behaviour when unpaired surrogate found
1180 return c;
1181 }
1182
1183 int highhalfChar = peekChars [peekCharsIndex];
1184 int lowhalfChar = peekChars [peekCharsIndex+1];
1185
1186 if (((highhalfChar & 0xFC00) != 0xD800) || ((lowhalfChar & 0xFC00) != 0xDC00))
1187 //FIXME: copy MS.NET behaviour when unpaired surrogate found
1188 return highhalfChar;
1189 return 0x10000 + (highhalfChar-0xD800)*0x400 + (lowhalfChar-0xDC00);
1190 }
1191
1192 private int PeekChar ()
1193 {
1194 if (peekCharsIndex < peekCharsLength) {
1195 int c = peekChars [peekCharsIndex];
1196 if (c == 0)
1197 return -1;
1198 if (c < 0xD800 || c >= 0xDFFF)
1199 return c;
1200 return PeekSurrogate (c);
1201 } else {
1202 if (!ReadTextReader (-1))
1203 return -1;
1204 return PeekChar ();
1205 }
1206 }
1207
1208 private int ReadChar ()
1209 {
1210 int ch = PeekChar ();
1211 peekCharsIndex++;
1212
1213 if (ch >= 0x10000)
1214 peekCharsIndex++; //Increment by 2 when a compound UCS-4 character was found
1215
1216 if (ch == '\n') {
1217 line++;
1218 column = 1;
1219 } else if (ch != -1) {
1220 column++;
1221 }
1222 return ch;
1223 }
1224
1225 private void Advance (int ch) {
1226 peekCharsIndex++;
1227
1228 if (ch >= 0x10000)
1229 peekCharsIndex++; //Increment by 2 when a compound UCS-4 character was found
1230
1231 if (ch == '\n') {
1232 line++;
1233 column = 1;
1234 } else if (ch != -1) {
1235 column++;
1236 }
1237 }
1238
1239 private bool ReadTextReader (int remained)
1240 {
1241 if (peekCharsLength < 0) { // initialized buffer
1242 peekCharsLength = reader.Read (peekChars, 0, peekChars.Length);
1243 return peekCharsLength > 0;
1244 }
1245 int offset = remained >= 0 ? 1 : 0;
1246 int copysize = peekCharsLength - curNodePeekIndex;
1247
1248 // It must assure that current tag content always exists
1249 // in peekChars.
1250 if (!preserveCurrentTag) {
1251 curNodePeekIndex = 0;
1252 peekCharsIndex = 0;
1253 //copysize = 0;
1254 } else if (peekCharsLength < peekChars.Length) {
1255 // NonBlockingStreamReader returned less bytes
1256 // than the size of the buffer. In that case,
1257 // just refill the buffer.
1258 } else if (curNodePeekIndex <= (peekCharsLength >> 1)) {
1259 // extend the buffer
1260 char [] tmp = new char [peekChars.Length * 2];
1261 Array.Copy (peekChars, curNodePeekIndex,
1262 tmp, 0, copysize);
1263 peekChars = tmp;
1264 curNodePeekIndex = 0;
1265 peekCharsIndex = copysize;
1266 } else {
1267 Array.Copy (peekChars, curNodePeekIndex,
1268 peekChars, 0, copysize);
1269 curNodePeekIndex = 0;
1270 peekCharsIndex = copysize;
1271 }
1272 if (remained >= 0)
1273 peekChars [peekCharsIndex] = (char) remained;
1274 int count = peekChars.Length - peekCharsIndex - offset;
1275 if (count > peekCharCapacity)
1276 count = peekCharCapacity;
1277 int read = reader.Read (
1278 peekChars, peekCharsIndex + offset, count);
1279 int remainingSize = offset + read;
1280 peekCharsLength = peekCharsIndex + remainingSize;
1281
1282 return (remainingSize != 0);
1283 }
1284
1285 private bool ReadContent ()
1286 {
1287 if (popScope) {
1288 nsmgr.PopScope ();
1289 parserContext.PopScope ();
1290 popScope = false;
1291 }
1292
1293 if (returnEntityReference)
1294 SetEntityReferenceProperties ();
1295 else {
1296 int c = PeekChar ();
1297 if (c == -1) {
1298 readState = ReadState.EndOfFile;
1299 ClearValueBuffer ();
1300 SetProperties (
1301 XmlNodeType.None, // nodeType
1302 String.Empty, // name
1303 String.Empty, // prefix
1304 String.Empty, // localName
1305 false, // isEmptyElement
1306 null, // value
1307 true // clearAttributes
1308 );
1309 if (depth > 0)
1310 throw NotWFError ("unexpected end of file. Current depth is " + depth);
1311
1312 return false;
1313 } else {
1314 switch (c) {
1315 case '<':
1316 Advance (c);
1317 switch (PeekChar ())
1318 {
1319 case '/':
1320 Advance ('/');
1321 ReadEndTag ();
1322 break;
1323 case '?':
1324 Advance ('?');
1325 ReadProcessingInstruction ();
1326 break;
1327 case '!':
1328 Advance ('!');
1329 ReadDeclaration ();
1330 break;
1331 default:
1332 ReadStartTag ();
1333 break;
1334 }
1335 break;
1336 case '\r':
1337 case '\n':
1338 case '\t':
1339 case ' ':
1340 if (!ReadWhitespace ())
1341 // skip
1342 return ReadContent ();
1343 break;
1344 default:
1345 ReadText (true);
1346 break;
1347 }
1348 }
1349 }
1350 return this.ReadState != ReadState.EndOfFile;
1351 }
1352
1353 private void SetEntityReferenceProperties ()
1354 {
1355 DTDEntityDeclaration decl = DTD != null ? DTD.EntityDecls [entityReferenceName] : null;
1356 if (this.isStandalone)
1357 if (DTD == null || decl == null || !decl.IsInternalSubset)
1358 throw NotWFError ("Standalone document must not contain any references to an non-internally declared entity.");
1359 if (decl != null && decl.NotationName != null)
1360 throw NotWFError ("Reference to any unparsed entities is not allowed here.");
1361
1362 ClearValueBuffer ();
1363 SetProperties (
1364 XmlNodeType.EntityReference, // nodeType
1365 entityReferenceName, // name
1366 String.Empty, // prefix
1367 entityReferenceName, // localName
1368 false, // isEmptyElement
1369 null, // value
1370 true // clearAttributes
1371 );
1372
1373 returnEntityReference = false;
1374 entityReferenceName = String.Empty;
1375 }
1376
1377 // The leading '<' has already been consumed.
1378 private void ReadStartTag ()
1379 {
1380 if (currentState == XmlNodeType.EndElement)
1381 throw NotWFError ("Multiple document element was detected.");
1382 currentState = XmlNodeType.Element;
1383
1384 nsmgr.PushScope ();
1385
1386 currentLinkedNodeLineNumber = line;
1387 currentLinkedNodeLinePosition = column;
1388
1389 string prefix, localName;
1390 string name = ReadName (out prefix, out localName);
1391 if (currentState == XmlNodeType.EndElement)
1392 throw NotWFError ("document has terminated, cannot open new element");
1393
1394 bool isEmptyElement = false;
1395
1396 ClearAttributes ();
1397
1398 SkipWhitespace ();
1399 if (XmlChar.IsFirstNameChar (PeekChar ()))
1400 ReadAttributes (false);
1401 cursorToken = this.currentToken;
1402
1403 // fill namespaces
1404 for (int i = 0; i < attributeCount; i++)
1405 attributeTokens [i].FillXmlns ();
1406 for (int i = 0; i < attributeCount; i++)
1407 attributeTokens [i].FillNamespace ();
1408
1409 // quick name check
1410 if (namespaces)
1411 for (int i = 0; i < attributeCount; i++)
1412 if (attributeTokens [i].Prefix == "xmlns" &&
1413 attributeTokens [i].Value == String.Empty)
1414 throw NotWFError ("Empty namespace URI cannot be mapped to non-empty prefix.");
1415
1416 for (int i = 0; i < attributeCount; i++) {
1417 for (int j = i + 1; j < attributeCount; j++)
1418 if (Object.ReferenceEquals (attributeTokens [i].Name, attributeTokens [j].Name) ||
1419 (Object.ReferenceEquals (attributeTokens [i].LocalName, attributeTokens [j].LocalName) &&
1420 Object.ReferenceEquals (attributeTokens [i].NamespaceURI, attributeTokens [j].NamespaceURI)))
1421 throw NotWFError ("Attribute name and qualified name must be identical.");
1422 }
1423
1424 if (PeekChar () == '/') {
1425 Advance ('/');
1426 isEmptyElement = true;
1427 popScope = true;
1428 }
1429 else {
1430 depthUp = true;
1431 PushElementName (name, localName, prefix);
1432 }
1433 parserContext.PushScope ();
1434
1435 Expect ('>');
1436
1437 SetProperties (
1438 XmlNodeType.Element, // nodeType
1439 name, // name
1440 prefix, // prefix
1441 localName, // name
1442 isEmptyElement, // isEmptyElement
1443 null, // value
1444 false // clearAttributes
1445 );
1446 if (prefix.Length > 0)
1447 currentToken.NamespaceURI = LookupNamespace (prefix, true);
1448 else if (namespaces)
1449 currentToken.NamespaceURI = nsmgr.DefaultNamespace;
1450
1451 if (namespaces) {
1452 if (NamespaceURI == null)
1453 throw NotWFError (String.Format ("'{0}' is undeclared namespace.", Prefix));
1454 try {
1455 for (int i = 0; i < attributeCount; i++) {
1456 MoveToAttribute (i);
1457 if (NamespaceURI == null)
1458 throw NotWFError (String.Format ("'{0}' is undeclared namespace.", Prefix));
1459 }
1460 } finally {
1461 MoveToElement ();
1462 }
1463 }
1464
1465 for (int i = 0; i < attributeCount; i++) {
1466 if (!Object.ReferenceEquals (attributeTokens [i].Prefix, XmlNamespaceManager.PrefixXml))
1467 continue;
1468 string aname = attributeTokens [i].LocalName;
1469 string value = attributeTokens [i].Value;
1470 switch (aname) {
1471 case "base":
1472 if (this.resolver != null) {
1473 Uri buri =
1474 BaseURI != String.Empty ?
1475 new Uri (BaseURI) : null;
1476 // xml:base="" without any base URI -> pointless. However there are
1477 // some people who use such xml:base. Seealso bug #608391.
1478 if (buri == null && String.IsNullOrEmpty (value))
1479 break;
1480 Uri uri = resolver.ResolveUri (
1481 buri, value);
1482 parserContext.BaseURI =
1483 uri != null ?
1484 uri.ToString () :
1485 String.Empty;
1486 }
1487 else
1488 parserContext.BaseURI = value;
1489 break;
1490 case "lang":
1491 parserContext.XmlLang = value;
1492 break;
1493 case "space":
1494 switch (value) {
1495 case "preserve":
1496 parserContext.XmlSpace = XmlSpace.Preserve;
1497 break;
1498 case "default":
1499 parserContext.XmlSpace = XmlSpace.Default;
1500 break;
1501 default:
1502 throw NotWFError (String.Format ("Invalid xml:space value: {0}", value));
1503 }
1504 break;
1505 }
1506 }
1507
1508 if (IsEmptyElement)
1509 CheckCurrentStateUpdate ();
1510 }
1511
1512 private void PushElementName (string name, string local, string prefix)
1513 {
1514 if (elementNames.Length == elementNameStackPos) {
1515 TagName [] newArray = new TagName [elementNames.Length * 2];
1516 Array.Copy (elementNames, 0, newArray, 0, elementNameStackPos);
1517 elementNames = newArray;
1518 }
1519 elementNames [elementNameStackPos++] =
1520 new TagName (name, local, prefix);
1521 }
1522
1523 // The reader is positioned on the first character
1524 // of the element's name.
1525 private void ReadEndTag ()
1526 {
1527 if (currentState != XmlNodeType.Element)
1528 throw NotWFError ("End tag cannot appear in this state.");
1529
1530 currentLinkedNodeLineNumber = line;
1531 currentLinkedNodeLinePosition = column;
1532
1533 if (elementNameStackPos == 0)
1534 throw NotWFError ("closing element without matching opening element");
1535 TagName expected = elementNames [--elementNameStackPos];
1536 Expect (expected.Name);
1537
1538 ExpectAfterWhitespace ('>');
1539
1540 --depth;
1541
1542 SetProperties (
1543 XmlNodeType.EndElement, // nodeType
1544 expected.Name, // name
1545 expected.Prefix, // prefix
1546 expected.LocalName, // localName
1547 false, // isEmptyElement
1548 null, // value
1549 true // clearAttributes
1550 );
1551 if (expected.Prefix.Length > 0)
1552 currentToken.NamespaceURI = LookupNamespace (expected.Prefix, true);
1553 else if (namespaces)
1554 currentToken.NamespaceURI = nsmgr.DefaultNamespace;
1555
1556 popScope = true;
1557
1558 CheckCurrentStateUpdate ();
1559 }
1560
1561 private void CheckCurrentStateUpdate ()
1562 {
1563 if (depth == 0 && !allowMultipleRoot && (IsEmptyElement || NodeType == XmlNodeType.EndElement))
1564 currentState = XmlNodeType.EndElement;
1565 }
1566
1567 #if USE_NAME_BUFFER
1568 private void AppendSurrogatePairNameChar (int ch)
1569 {
1570 nameBuffer [nameLength++] = (char) ((ch - 0x10000) / 0x400 + 0xD800);
1571 if (nameLength == nameCapacity)
1572 ExpandNameCapacity ();
1573 nameBuffer [nameLength++] = (char) ((ch - 0x10000) % 0x400 + 0xDC00);
1574 }
1575
1576 private void ExpandNameCapacity ()
1577 {
1578 nameCapacity = nameCapacity * 2;
1579 char [] oldNameBuffer = nameBuffer;
1580 nameBuffer = new char [nameCapacity];
1581 Array.Copy (oldNameBuffer, nameBuffer, nameLength);
1582 }
1583 #endif
1584
1585 private void AppendValueChar (int ch)
1586 {
1587 if (ch <= Char.MaxValue)
1588 valueBuffer.Append ((char) ch);
1589 else
1590 AppendSurrogatePairValueChar (ch);
1591 }
1592
1593 private void AppendSurrogatePairValueChar (int ch)
1594 {
1595 valueBuffer.Append ((char) ((ch - 0x10000) / 0x400 + 0xD800));
1596 valueBuffer.Append ((char) ((ch - 0x10000) % 0x400 + 0xDC00));
1597 }
1598
1599 private string CreateValueString ()
1600 {
1601 // Since whitespace strings are mostly identical
1602 // depending on the Depth, we make use of NameTable
1603 // to atomize whitespace strings.
1604 switch (NodeType) {
1605 case XmlNodeType.Whitespace:
1606 case XmlNodeType.SignificantWhitespace:
1607 int len = valueBuffer.Length;
1608 if (whitespaceCache == null)
1609 whitespaceCache = new char [32];
1610 if (len >= whitespaceCache.Length)
1611 break;
1612 if (whitespacePool == null)
1613 whitespacePool = new NameTable ();
1614 #if NET_2_0 && !NET_2_1
1615 valueBuffer.CopyTo (0, whitespaceCache, 0, len);
1616 #else
1617 for (int i = 0; i < len; i++)
1618 whitespaceCache [i] = valueBuffer [i];
1619 #endif
1620 return whitespacePool.Add (whitespaceCache, 0, valueBuffer.Length);
1621 }
1622 return (valueBuffer.Capacity < 100) ?
1623 valueBuffer.ToString (0, valueBuffer.Length) :
1624 valueBuffer.ToString ();
1625 }
1626
1627 private void ClearValueBuffer ()
1628 {
1629 valueBuffer.Length = 0;
1630 }
1631
1632 // The reader is positioned on the first character
1633 // of the text.
1634 private void ReadText (bool notWhitespace)
1635 {
1636 if (currentState != XmlNodeType.Element)
1637 throw NotWFError ("Text node cannot appear in this state.");
1638 preserveCurrentTag = false;
1639
1640 if (notWhitespace)
1641 ClearValueBuffer ();
1642
1643 int ch = PeekChar ();
1644 bool previousWasCloseBracket = false;
1645
1646 while (ch != '<' && ch != -1) {
1647 if (ch == '&') {
1648 ReadChar ();
1649 ch = ReadReference (false);
1650 if (returnEntityReference) // Returns -1 if char validation should not be done
1651 break;
1652 } else if (normalization && ch == '\r') {
1653 ReadChar ();
1654 ch = PeekChar ();
1655 if (ch != '\n')
1656 // append '\n' instead of '\r'.
1657 AppendValueChar ('\n');
1658 // and in case of "\r\n", discard '\r'.
1659 continue;
1660 } else {
1661 if (CharacterChecking && XmlChar.IsInvalid (ch))
1662 throw NotWFError ("Not allowed character was found.");
1663 ch = ReadChar ();
1664 }
1665
1666 // FIXME: it might be optimized by the JIT later,
1667 // AppendValueChar (ch);
1668 {
1669 if (ch <= Char.MaxValue)
1670 valueBuffer.Append ((char) ch);
1671 else
1672 AppendSurrogatePairValueChar (ch);
1673 }
1674
1675 // Block "]]>"
1676 if (ch == ']') {
1677 if (previousWasCloseBracket)
1678 if (PeekChar () == '>')
1679 throw NotWFError ("Inside text content, character sequence ']]>' is not allowed.");
1680 previousWasCloseBracket = true;
1681 }
1682 else if (previousWasCloseBracket)
1683 previousWasCloseBracket = false;
1684 ch = PeekChar ();
1685 notWhitespace = true;
1686 }
1687
1688 if (returnEntityReference && valueBuffer.Length == 0) {
1689 SetEntityReferenceProperties ();
1690 } else {
1691 XmlNodeType nodeType = notWhitespace ? XmlNodeType.Text :
1692 this.XmlSpace == XmlSpace.Preserve ? XmlNodeType.SignificantWhitespace : XmlNodeType.Whitespace;
1693 SetProperties (
1694 nodeType, // nodeType
1695 String.Empty, // name
1696 String.Empty, // prefix
1697 String.Empty, // localName
1698 false, // isEmptyElement
1699 null, // value: create only when required
1700 true // clearAttributes
1701 );
1702 }
1703 }
1704
1705 // The leading '&' has already been consumed.
1706 // Returns true if the entity reference isn't a simple
1707 // character reference or one of the predefined entities.
1708 // This allows the ReadText method to break so that the
1709 // next call to Read will return the EntityReference node.
1710 private int ReadReference (bool ignoreEntityReferences)
1711 {
1712 if (PeekChar () == '#') {
1713 Advance ('#');
1714 return ReadCharacterReference ();
1715 } else
1716 return ReadEntityReference (ignoreEntityReferences);
1717 }
1718
1719 private int ReadCharacterReference ()
1720 {
1721 int value = 0;
1722 int ch;
1723
1724 if (PeekChar () == 'x') {
1725 Advance ('x');
1726
1727 while ((ch = PeekChar ()) != ';' && ch != -1) {
1728 Advance (ch);
1729
1730 if (ch >= '0' && ch <= '9')
1731 value = (value << 4) + ch - '0';
1732 else if (ch >= 'A' && ch <= 'F')
1733 value = (value << 4) + ch - 'A' + 10;
1734 else if (ch >= 'a' && ch <= 'f')
1735 value = (value << 4) + ch - 'a' + 10;
1736 else
1737 throw NotWFError (String.Format (CultureInfo.InvariantCulture,
1738 "invalid hexadecimal digit: {0} (#x{1:X})",
1739 (char) ch,
1740 ch));
1741 }
1742 } else {
1743 while ((ch = PeekChar ()) != ';' && ch != -1) {
1744 Advance (ch);
1745
1746 if (ch >= '0' && ch <= '9')
1747 value = value * 10 + ch - '0';
1748 else
1749 throw NotWFError (String.Format (CultureInfo.InvariantCulture,
1750 "invalid decimal digit: {0} (#x{1:X})",
1751 (char) ch,
1752 ch));
1753 }
1754 }
1755
1756 ReadChar (); // ';'
1757
1758 // There is no way to save surrogate pairs...
1759 if (CharacterChecking && Normalization &&
1760 XmlChar.IsInvalid (value))
1761 throw NotWFError ("Referenced character was not allowed in XML. Normalization is " + normalization + ", checkCharacters = " + checkCharacters);
1762 return value;
1763 }
1764
1765 // Returns -1 if it should not be validated.
1766 // Real EOF must not be detected here.
1767 private int ReadEntityReference (bool ignoreEntityReferences)
1768 {
1769 string name = ReadName ();
1770 Expect (';');
1771
1772 int predefined = XmlChar.GetPredefinedEntity (name);
1773 if (predefined >= 0)
1774 return predefined;
1775 else {
1776 if (ignoreEntityReferences) {
1777 AppendValueChar ('&');
1778 for (int i = 0; i < name.Length; i++)
1779 AppendValueChar (name [i]);
1780 AppendValueChar (';');
1781 } else {
1782 returnEntityReference = true;
1783 entityReferenceName = name;
1784 }
1785 }
1786 return -1;
1787 }
1788
1789 // The reader is positioned on the first character of
1790 // the attribute name.
1791 private void ReadAttributes (bool isXmlDecl)
1792 {
1793 int peekChar = -1;
1794 bool requireWhitespace = false;
1795 currentAttribute = -1;
1796 currentAttributeValue = -1;
1797
1798 do {
1799 if (!SkipWhitespace () && requireWhitespace)
1800 throw NotWFError ("Unexpected token. Name is required here.");
1801
1802 IncrementAttributeToken ();
1803 currentAttributeToken.LineNumber = line;
1804 currentAttributeToken.LinePosition = column;
1805
1806 string prefix, localName;
1807 currentAttributeToken.Name = ReadName (out prefix, out localName);
1808 currentAttributeToken.Prefix = prefix;
1809 currentAttributeToken.LocalName = localName;
1810 ExpectAfterWhitespace ('=');
1811 SkipWhitespace ();
1812 ReadAttributeValueTokens (-1);
1813 // This hack is required for xmldecl which has
1814 // both effective attributes and Value.
1815 string dummyValue;
1816 if (isXmlDecl)
1817 dummyValue = currentAttributeToken.Value;
1818
1819 attributeCount++;
1820
1821 if (!SkipWhitespace ())
1822 requireWhitespace = true;
1823 peekChar = PeekChar ();
1824 if (isXmlDecl) {
1825 if (peekChar == '?')
1826 break;
1827 }
1828 else if (peekChar == '/' || peekChar == '>')
1829 break;
1830 } while (peekChar != -1);
1831
1832 currentAttribute = -1;
1833 currentAttributeValue = -1;
1834 }
1835
1836 private void AddAttributeWithValue (string name, string value)
1837 {
1838 IncrementAttributeToken ();
1839 XmlAttributeTokenInfo ati = attributeTokens [currentAttribute];
1840 ati.Name = NameTable.Add (name);
1841 ati.Prefix = String.Empty;
1842 ati.NamespaceURI = String.Empty;
1843 IncrementAttributeValueToken ();
1844 XmlTokenInfo vti = attributeValueTokens [currentAttributeValue];
1845 SetTokenProperties (vti,
1846 XmlNodeType.Text,
1847 String.Empty,
1848 String.Empty,
1849 String.Empty,
1850 false,
1851 value,
1852 false);
1853 ati.Value = value;
1854 attributeCount++;
1855 }
1856
1857 private void IncrementAttributeToken ()
1858 {
1859 currentAttribute++;
1860 if (attributeTokens.Length == currentAttribute) {
1861 XmlAttributeTokenInfo [] newArray =
1862 new XmlAttributeTokenInfo [attributeTokens.Length * 2];
1863 attributeTokens.CopyTo (newArray, 0);
1864 attributeTokens = newArray;
1865 }
1866 if (attributeTokens [currentAttribute] == null)
1867 attributeTokens [currentAttribute] = new XmlAttributeTokenInfo (this);
1868 currentAttributeToken = attributeTokens [currentAttribute];
1869 currentAttributeToken.Clear ();
1870 }
1871
1872 private void IncrementAttributeValueToken ()
1873 {
1874 currentAttributeValue++;
1875 if (attributeValueTokens.Length == currentAttributeValue) {
1876 XmlTokenInfo [] newArray = new XmlTokenInfo [attributeValueTokens.Length * 2];
1877 attributeValueTokens.CopyTo (newArray, 0);
1878 attributeValueTokens = newArray;
1879 }
1880 if (attributeValueTokens [currentAttributeValue] == null)
1881 attributeValueTokens [currentAttributeValue] = new XmlTokenInfo (this);
1882 currentAttributeValueToken = attributeValueTokens [currentAttributeValue];
1883 currentAttributeValueToken.Clear ();
1884 }
1885
1886 // LAMESPEC: Orthodox XML reader should normalize attribute values
1887 private void ReadAttributeValueTokens (int dummyQuoteChar)
1888 {
1889 int quoteChar = (dummyQuoteChar < 0) ? ReadChar () : dummyQuoteChar;
1890
1891 if (quoteChar != '\'' && quoteChar != '\"')
1892 throw NotWFError ("an attribute value was not quoted");
1893 currentAttributeToken.QuoteChar = (char) quoteChar;
1894
1895 IncrementAttributeValueToken ();
1896 currentAttributeToken.ValueTokenStartIndex = currentAttributeValue;
1897 currentAttributeValueToken.LineNumber = line;
1898 currentAttributeValueToken.LinePosition = column;
1899
1900 bool incrementToken = false;
1901 bool isNewToken = true;
1902 bool loop = true;
1903 int ch = 0;
1904 currentAttributeValueToken.ValueBufferStart = valueBuffer.Length;
1905 while (loop) {
1906 ch = ReadChar ();
1907 if (ch == quoteChar)
1908 break;
1909
1910 if (incrementToken) {
1911 IncrementAttributeValueToken ();
1912 currentAttributeValueToken.ValueBufferStart = valueBuffer.Length;
1913 currentAttributeValueToken.LineNumber = line;
1914 currentAttributeValueToken.LinePosition = column;
1915 incrementToken = false;
1916 isNewToken = true;
1917 }
1918
1919 switch (ch)
1920 {
1921 case '<':
1922 throw NotWFError ("attribute values cannot contain '<'");
1923 case -1:
1924 if (dummyQuoteChar < 0)
1925 throw NotWFError ("unexpected end of file in an attribute value");
1926 else // Attribute value constructor.
1927 loop = false;
1928 break;
1929 case '\r':
1930 if (!normalization)
1931 goto default;
1932 if (PeekChar () == '\n')
1933 continue; // skip '\r'.
1934 //
1935 // The csc in MS.NET 2.0 beta 1 barfs on this goto, so work around that
1936 //
1937 //goto case '\n';
1938 if (!normalization)
1939 goto default;
1940 ch = ' ';
1941 goto default;
1942 case '\n':
1943 case '\t':
1944 // When Normalize = true, then replace
1945 // all spaces to ' '
1946 if (!normalization)
1947 goto default;
1948 ch = ' ';
1949 goto default;
1950 case '&':
1951 if (PeekChar () == '#') {
1952 Advance ('#');
1953 ch = ReadCharacterReference ();
1954 AppendValueChar (ch);
1955 break;
1956 }
1957 // Check XML 1.0 section 3.1 WFC.
1958 string entName = ReadName ();
1959 Expect (';');
1960 int predefined = XmlChar.GetPredefinedEntity (entName);
1961 if (predefined < 0) {
1962 CheckAttributeEntityReferenceWFC (entName);
1963 #if NET_2_0
1964 if (entityHandling == EntityHandling.ExpandEntities) {
1965 string value = DTD.GenerateEntityAttributeText (entName);
1966 foreach (char c in (IEnumerable<char>) value)
1967 AppendValueChar (c);
1968 } else
1969 #endif
1970 {
1971 currentAttributeValueToken.ValueBufferEnd = valueBuffer.Length;
1972 currentAttributeValueToken.NodeType = XmlNodeType.Text;
1973 if (!isNewToken)
1974 IncrementAttributeValueToken ();
1975 currentAttributeValueToken.Name = entName;
1976 currentAttributeValueToken.Value = String.Empty;
1977 currentAttributeValueToken.NodeType = XmlNodeType.EntityReference;
1978 incrementToken = true;
1979 }
1980 }
1981 else
1982 AppendValueChar (predefined);
1983 break;
1984 default:
1985 if (CharacterChecking && XmlChar.IsInvalid (ch))
1986 throw NotWFError ("Invalid character was found.");
1987 // FIXME: it might be optimized by the JIT later,
1988 // AppendValueChar (ch);
1989 {
1990 if (ch <= Char.MaxValue)
1991 valueBuffer.Append ((char) ch);
1992 else
1993 AppendSurrogatePairValueChar (ch);
1994 }
1995 break;
1996 }
1997
1998 isNewToken = false;
1999 }
2000 if (!incrementToken) {
2001 currentAttributeValueToken.ValueBufferEnd = valueBuffer.Length;
2002 currentAttributeValueToken.NodeType = XmlNodeType.Text;
2003 }
2004 currentAttributeToken.ValueTokenEndIndex = currentAttributeValue;
2005
2006 }
2007
2008 private void CheckAttributeEntityReferenceWFC (string entName)
2009 {
2010 DTDEntityDeclaration entDecl =
2011 DTD == null ? null : DTD.EntityDecls [entName];
2012 if (entDecl == null) {
2013 if (entityHandling == EntityHandling.ExpandEntities
2014 || (DTD != null && resolver != null && entDecl == null))
2015 throw NotWFError (String.Format ("Referenced entity '{0}' does not exist.", entName));
2016 else
2017 return;
2018 }
2019
2020 if (entDecl.HasExternalReference)
2021 throw NotWFError ("Reference to external entities is not allowed in the value of an attribute.");
2022 if (isStandalone && !entDecl.IsInternalSubset)
2023 throw NotWFError ("Reference to external entities is not allowed in the internal subset.");
2024 if (entDecl.EntityValue.IndexOf ('<') >= 0)
2025 throw NotWFError ("Attribute must not contain character '<' either directly or indirectly by way of entity references.");
2026 }
2027
2028 // The reader is positioned on the first character
2029 // of the target.
2030 //
2031 // It may be xml declaration or processing instruction.
2032 private void ReadProcessingInstruction ()
2033 {
2034 string target = ReadName ();
2035 if (target != "xml" && target.ToLower (CultureInfo.InvariantCulture) == "xml")
2036 throw NotWFError ("Not allowed processing instruction name which starts with 'X', 'M', 'L' was found.");
2037
2038 if (!SkipWhitespace ())
2039 if (PeekChar () != '?')
2040 throw NotWFError ("Invalid processing instruction name was found.");
2041
2042 ClearValueBuffer ();
2043
2044 int ch;
2045 while ((ch = PeekChar ()) != -1) {
2046 Advance (ch);
2047
2048 if (ch == '?' && PeekChar () == '>') {
2049 Advance ('>');
2050 break;
2051 }
2052
2053 if (CharacterChecking && XmlChar.IsInvalid (ch))
2054 throw NotWFError ("Invalid character was found.");
2055 AppendValueChar (ch);
2056 }
2057
2058 if (Object.ReferenceEquals (target, XmlNamespaceManager.PrefixXml))
2059 VerifyXmlDeclaration ();
2060 else {
2061 if (currentState == XmlNodeType.None)
2062 currentState = XmlNodeType.XmlDeclaration;
2063
2064 SetProperties (
2065 XmlNodeType.ProcessingInstruction, // nodeType
2066 target, // name
2067 String.Empty, // prefix
2068 target, // localName
2069 false, // isEmptyElement
2070 null, // value: create only when required
2071 true // clearAttributes
2072 );
2073 }
2074 }
2075
2076 void VerifyXmlDeclaration ()
2077 {
2078 if (!allowMultipleRoot && currentState != XmlNodeType.None)
2079 throw NotWFError ("XML declaration cannot appear in this state.");
2080
2081 currentState = XmlNodeType.XmlDeclaration;
2082
2083 string text = CreateValueString ();
2084
2085 ClearAttributes ();
2086
2087 int idx = 0;
2088
2089 string encoding = null, standalone = null;
2090 string name, value;
2091 ParseAttributeFromString (text, ref idx, out name, out value);
2092 if (name != "version" || value != "1.0")
2093 throw NotWFError ("'version' is expected.");
2094 name = String.Empty;
2095 if (SkipWhitespaceInString (text, ref idx) && idx < text.Length)
2096 ParseAttributeFromString (text, ref idx, out name, out value);
2097 if (name == "encoding") {
2098 if (!XmlChar.IsValidIANAEncoding (value))
2099 throw NotWFError ("'encoding' must be a valid IANA encoding name.");
2100 if (reader is XmlStreamReader)
2101 parserContext.Encoding = ((XmlStreamReader) reader).Encoding;
2102 else
2103 parserContext.Encoding = Encoding.Unicode;
2104 encoding = value;
2105 name = String.Empty;
2106 if (SkipWhitespaceInString (text, ref idx) && idx < text.Length)
2107 ParseAttributeFromString (text, ref idx, out name, out value);
2108 }
2109 if (name == "standalone") {
2110 this.isStandalone = value == "yes";
2111 if (value != "yes" && value != "no")
2112 throw NotWFError ("Only 'yes' or 'no' is allow for 'standalone'");
2113 standalone = value;
2114 SkipWhitespaceInString (text, ref idx);
2115 }
2116 else if (name.Length != 0)
2117 throw NotWFError (String.Format ("Unexpected token: '{0}'", name));
2118
2119 if (idx < text.Length)
2120 throw NotWFError ("'?' is expected.");
2121
2122 AddAttributeWithValue ("version", "1.0");
2123 if (encoding != null)
2124 AddAttributeWithValue ("encoding", encoding);
2125 if (standalone != null)
2126 AddAttributeWithValue ("standalone", standalone);
2127 currentAttribute = currentAttributeValue = -1;
2128
2129 SetProperties (
2130 XmlNodeType.XmlDeclaration, // nodeType
2131 "xml", // name
2132 String.Empty, // prefix
2133 "xml", // localName
2134 false, // isEmptyElement
2135 text, // value
2136 false // clearAttributes
2137 );
2138 }
2139
2140 bool SkipWhitespaceInString (string text, ref int idx)
2141 {
2142 int start = idx;
2143 while (idx < text.Length && XmlChar.IsWhitespace (text [idx]))
2144 idx++;
2145 return idx - start > 0;
2146 }
2147
2148 private void ParseAttributeFromString (string src,
2149 ref int idx, out string name, out string value)
2150 {
2151 while (idx < src.Length && XmlChar.IsWhitespace (src [idx]))
2152 idx++;
2153
2154 int start = idx;
2155 while (idx < src.Length && XmlChar.IsNameChar (src [idx]))
2156 idx++;
2157 name = src.Substring (start, idx - start);
2158
2159 while (idx < src.Length && XmlChar.IsWhitespace (src [idx]))
2160 idx++;
2161 if (idx == src.Length || src [idx] != '=')
2162 throw NotWFError (String.Format ("'=' is expected after {0}", name));
2163 idx++;
2164
2165 while (idx < src.Length && XmlChar.IsWhitespace (src [idx]))
2166 idx++;
2167
2168 if (idx == src.Length || src [idx] != '"' && src [idx] != '\'')
2169 throw NotWFError ("'\"' or '\'' is expected.");
2170
2171 char quote = src [idx];
2172 idx++;
2173 start = idx;
2174
2175 while (idx < src.Length && src [idx] != quote)
2176 idx++;
2177 idx++;
2178
2179 value = src.Substring (start, idx - start - 1);
2180 }
2181
2182 internal void SkipTextDeclaration ()
2183 {
2184 if (PeekChar () != '<')
2185 return;
2186
2187 ReadChar ();
2188
2189 if (PeekChar () != '?') {
2190 peekCharsIndex = 0;
2191 return;
2192 }
2193 ReadChar ();
2194
2195 while (peekCharsIndex < 6) {
2196 if (PeekChar () < 0)
2197 break;
2198 else
2199 ReadChar ();
2200 }
2201 if (new string (peekChars, 2, 4) != "xml ") {
2202 if (new string (peekChars, 2, 4).ToLower (CultureInfo.InvariantCulture) == "xml ") {
2203 throw NotWFError ("Processing instruction name must not be character sequence 'X' 'M' 'L' with case insensitivity.");
2204 }
2205 peekCharsIndex = 0;
2206 return;
2207 }
2208
2209 SkipWhitespace ();
2210
2211 // version decl
2212 if (PeekChar () == 'v') {
2213 Expect ("version");
2214 ExpectAfterWhitespace ('=');
2215 SkipWhitespace ();
2216 int quoteChar = ReadChar ();
2217 char [] expect1_0 = new char [3];
2218 int versionLength = 0;
2219 switch (quoteChar) {
2220 case '\'':
2221 case '"':
2222 while (PeekChar () != quoteChar) {
2223 if (PeekChar () == -1)
2224 throw NotWFError ("Invalid version declaration inside text declaration.");
2225 else if (versionLength == 3)
2226 throw NotWFError ("Invalid version number inside text declaration.");
2227 else {
2228 expect1_0 [versionLength] = (char) ReadChar ();
2229 versionLength++;
2230 if (versionLength == 3 && new String (expect1_0) != "1.0")
2231 throw NotWFError ("Invalid version number inside text declaration.");
2232 }
2233 }
2234 ReadChar ();
2235 SkipWhitespace ();
2236 break;
2237 default:
2238 throw NotWFError ("Invalid version declaration inside text declaration.");
2239 }
2240 }
2241
2242 if (PeekChar () == 'e') {
2243 Expect ("encoding");
2244 ExpectAfterWhitespace ('=');
2245 SkipWhitespace ();
2246 int quoteChar = ReadChar ();
2247 switch (quoteChar) {
2248 case '\'':
2249 case '"':
2250 while (PeekChar () != quoteChar)
2251 if (ReadChar () == -1)
2252 throw NotWFError ("Invalid encoding declaration inside text declaration.");
2253 ReadChar ();
2254 SkipWhitespace ();
2255 break;
2256 default:
2257 throw NotWFError ("Invalid encoding declaration inside text declaration.");
2258 }
2259 // Encoding value should be checked inside XmlInputStream.
2260 }
2261 #if NET_2_0
2262 // this condition is to check if this instance is
2263 // not created by XmlReader.Create() (which just
2264 // omits strict text declaration check).
2265 else if (Conformance == ConformanceLevel.Auto)
2266 throw NotWFError ("Encoding declaration is mandatory in text declaration.");
2267 #endif
2268
2269 Expect ("?>");
2270
2271 curNodePeekIndex = peekCharsIndex; // without this it causes incorrect value start indication.
2272 }
2273
2274 // The reader is positioned on the first character after
2275 // the leading '<!'.
2276 private void ReadDeclaration ()
2277 {
2278 int ch = PeekChar ();
2279
2280 switch (ch)
2281 {
2282 case '-':
2283 Expect ("--");
2284 ReadComment ();
2285 break;
2286 case '[':
2287 ReadChar ();
2288 Expect ("CDATA[");
2289 ReadCDATA ();
2290 break;
2291 case 'D':
2292 Expect ("DOCTYPE");
2293 ReadDoctypeDecl ();
2294 break;
2295 default:
2296 throw NotWFError ("Unexpected declaration markup was found.");
2297 }
2298 }
2299
2300 // The reader is positioned on the first character after
2301 // the leading '<!--'.
2302 private void ReadComment ()
2303 {
2304 if (currentState == XmlNodeType.None)
2305 currentState = XmlNodeType.XmlDeclaration;
2306
2307 preserveCurrentTag = false;
2308
2309 ClearValueBuffer ();
2310
2311 int ch;
2312 while ((ch = PeekChar ()) != -1) {
2313 Advance (ch);
2314
2315 if (ch == '-' && PeekChar () == '-') {
2316 Advance ('-');
2317
2318 if (PeekChar () != '>')
2319 throw NotWFError ("comments cannot contain '--'");
2320
2321 Advance ('>');
2322 break;
2323 }
2324
2325 if (XmlChar.IsInvalid (ch))
2326 throw NotWFError ("Not allowed character was found.");
2327
2328 AppendValueChar (ch);
2329 }
2330
2331 SetProperties (
2332 XmlNodeType.Comment, // nodeType
2333 String.Empty, // name
2334 String.Empty, // prefix
2335 String.Empty, // localName
2336 false, // isEmptyElement
2337 null, // value: create only when required
2338 true // clearAttributes
2339 );
2340 }
2341
2342 // The reader is positioned on the first character after
2343 // the leading '<![CDATA['.
2344 private void ReadCDATA ()
2345 {
2346 if (currentState != XmlNodeType.Element)
2347 throw NotWFError ("CDATA section cannot appear in this state.");
2348 preserveCurrentTag = false;
2349
2350 ClearValueBuffer ();
2351
2352 bool skip = false;
2353 int ch = 0;
2354 while (PeekChar () != -1) {
2355 if (!skip)
2356 ch = ReadChar ();
2357 skip = false;
2358
2359 if (ch == ']' && PeekChar () == ']') {
2360 ch = ReadChar (); // ']'
2361
2362 if (PeekChar () == '>') {
2363 ReadChar (); // '>'
2364 break;
2365 } else {
2366 skip = true;
2367 }
2368 }
2369 if (normalization && ch == '\r') {
2370 ch = PeekChar ();
2371 if (ch != '\n')
2372 // append '\n' instead of '\r'.
2373 AppendValueChar ('\n');
2374 // otherwise, discard '\r'.
2375 continue;
2376 }
2377 if (CharacterChecking && XmlChar.IsInvalid (ch))
2378 throw NotWFError ("Invalid character was found.");
2379
2380 // FIXME: it might be optimized by the JIT later,
2381 // AppendValueChar (ch);
2382 {
2383 if (ch <= Char.MaxValue)
2384 valueBuffer.Append ((char) ch);
2385 else
2386 AppendSurrogatePairValueChar (ch);
2387 }
2388 }
2389
2390 SetProperties (
2391 XmlNodeType.CDATA, // nodeType
2392 String.Empty, // name
2393 String.Empty, // prefix
2394 String.Empty, // localName
2395 false, // isEmptyElement
2396 null, // value: create only when required
2397 true // clearAttributes
2398 );
2399 }
2400
2401 // The reader is positioned on the first character after
2402 // the leading '<!DOCTYPE'.
2403 private void ReadDoctypeDecl ()
2404 {
2405 if (prohibitDtd)
2406 throw NotWFError ("Document Type Declaration (DTD) is prohibited in this XML.");
2407 switch (currentState) {
2408 case XmlNodeType.DocumentType:
2409 case XmlNodeType.Element:
2410 case XmlNodeType.EndElement:
2411 throw NotWFError ("Document type cannot appear in this state.");
2412 }
2413 currentState = XmlNodeType.DocumentType;
2414
2415 string doctypeName = null;
2416 string publicId = null;
2417 string systemId = null;
2418 int intSubsetStartLine = 0;
2419 int intSubsetStartColumn = 0;
2420
2421 SkipWhitespace ();
2422 doctypeName = ReadName ();
2423 SkipWhitespace ();
2424 switch(PeekChar ())
2425 {
2426 case 'S':
2427 systemId = ReadSystemLiteral (true);
2428 break;
2429 case 'P':
2430 publicId = ReadPubidLiteral ();
2431 if (!SkipWhitespace ())
2432 throw NotWFError ("Whitespace is required between PUBLIC id and SYSTEM id.");
2433 systemId = ReadSystemLiteral (false);
2434 break;
2435 }
2436 SkipWhitespace ();
2437
2438
2439 if(PeekChar () == '[')
2440 {
2441 // read markupdecl etc. or end of decl
2442 ReadChar ();
2443 intSubsetStartLine = this.LineNumber;
2444 intSubsetStartColumn = this.LinePosition;
2445 ClearValueBuffer ();
2446 ReadInternalSubset ();
2447 parserContext.InternalSubset = CreateValueString ();
2448 }
2449 // end of DOCTYPE decl.
2450 ExpectAfterWhitespace ('>');
2451
2452 GenerateDTDObjectModel (doctypeName, publicId,
2453 systemId, parserContext.InternalSubset,
2454 intSubsetStartLine, intSubsetStartColumn);
2455
2456 // set properties for <!DOCTYPE> node
2457 SetProperties (
2458 XmlNodeType.DocumentType, // nodeType
2459 doctypeName, // name
2460 String.Empty, // prefix
2461 doctypeName, // localName
2462 false, // isEmptyElement
2463 parserContext.InternalSubset, // value
2464 true // clearAttributes
2465 );
2466
2467 if (publicId != null)
2468 AddAttributeWithValue ("PUBLIC", publicId);
2469 if (systemId != null)
2470 AddAttributeWithValue ("SYSTEM", systemId);
2471 currentAttribute = currentAttributeValue = -1;
2472 }
2473
2474 internal DTDObjectModel GenerateDTDObjectModel (string name, string publicId,
2475 string systemId, string internalSubset)
2476 {
2477 return GenerateDTDObjectModel (name, publicId, systemId, internalSubset, 0, 0);
2478 }
2479
2480 internal DTDObjectModel GenerateDTDObjectModel (string name, string publicId,
2481 string systemId, string internalSubset, int intSubsetStartLine, int intSubsetStartColumn)
2482 {
2483 // now compile DTD
2484 parserContext.Dtd = new DTDObjectModel (this.NameTable); // merges both internal and external subsets in the meantime,
2485 DTD.BaseURI = BaseURI;
2486 DTD.Name = name;
2487 DTD.PublicId = publicId;
2488 DTD.SystemId = systemId;
2489 DTD.InternalSubset = internalSubset;
2490 DTD.XmlResolver = resolver;
2491 DTD.IsStandalone = isStandalone;
2492 DTD.LineNumber = line;
2493 DTD.LinePosition = column;
2494
2495 DTDReader dr = new DTDReader (DTD, intSubsetStartLine, intSubsetStartColumn);
2496 dr.Normalization = this.normalization;
2497 return dr.GenerateDTDObjectModel ();
2498 }
2499
2500 private enum DtdInputState
2501 {
2502 Free = 1,
2503 ElementDecl,
2504 AttlistDecl,
2505 EntityDecl,
2506 NotationDecl,
2507 PI,
2508 Comment,
2509 InsideSingleQuoted,
2510 InsideDoubleQuoted,
2511 }
2512
2513 private class DtdInputStateStack
2514 {
2515 Stack intern = new Stack ();
2516 public DtdInputStateStack ()
2517 {
2518 Push (DtdInputState.Free);
2519 }
2520
2521 public DtdInputState Peek ()
2522 {
2523 return (DtdInputState) intern.Peek ();
2524 }
2525
2526 public DtdInputState Pop ()
2527 {
2528 return (DtdInputState) intern.Pop ();
2529 }
2530
2531 public void Push (DtdInputState val)
2532 {
2533 intern.Push (val);
2534 }
2535 }
2536
2537
2538 DtdInputStateStack stateStack = new DtdInputStateStack ();
2539 DtdInputState State {
2540 get { return stateStack.Peek (); }
2541 }
2542
2543 private int ReadValueChar ()
2544 {
2545 int ret = ReadChar ();
2546 AppendValueChar (ret);
2547 return ret;
2548 }
2549
2550 private void ExpectAndAppend (string s)
2551 {
2552 Expect (s);
2553 valueBuffer.Append (s);
2554 }
2555
2556 // Simply read but not generate any result.
2557 private void ReadInternalSubset ()
2558 {
2559 bool continueParse = true;
2560
2561 while (continueParse) {
2562 switch (ReadValueChar ()) {
2563 case ']':
2564 switch (State) {
2565 case DtdInputState.Free:
2566 // chop extra ']'
2567 valueBuffer.Remove (valueBuffer.Length - 1, 1);
2568 continueParse = false;
2569 break;
2570 case DtdInputState.InsideDoubleQuoted:
2571 case DtdInputState.InsideSingleQuoted:
2572 case DtdInputState.Comment:
2573 continue;
2574 default:
2575 throw NotWFError ("unexpected end of file at DTD.");
2576 }
2577 break;
2578 case -1:
2579 throw NotWFError ("unexpected end of file at DTD.");
2580 case '<':
2581 switch (State) {
2582 case DtdInputState.InsideDoubleQuoted:
2583 case DtdInputState.InsideSingleQuoted:
2584 case DtdInputState.Comment:
2585 continue; // well-formed
2586 }
2587 int c = ReadValueChar ();
2588 switch (c) {
2589 case '?':
2590 stateStack.Push (DtdInputState.PI);
2591 break;
2592 case '!':
2593 switch (ReadValueChar ()) {
2594 case 'E':
2595 switch (ReadValueChar ()) {
2596 case 'L':
2597 ExpectAndAppend ("EMENT");
2598 stateStack.Push (DtdInputState.ElementDecl);
2599 break;
2600 case 'N':
2601 ExpectAndAppend ("TITY");
2602 stateStack.Push (DtdInputState.EntityDecl);
2603 break;
2604 default:
2605 throw NotWFError ("unexpected token '<!E'.");
2606 }
2607 break;
2608 case 'A':
2609 ExpectAndAppend ("TTLIST");
2610 stateStack.Push (DtdInputState.AttlistDecl);
2611 break;
2612 case 'N':
2613 ExpectAndAppend ("OTATION");
2614 stateStack.Push (DtdInputState.NotationDecl);
2615 break;
2616 case '-':
2617 ExpectAndAppend ("-");
2618 stateStack.Push (DtdInputState.Comment);
2619 break;
2620 }
2621 break;
2622 default:
2623 throw NotWFError (String.Format ("unexpected '<{0}'.", (char) c));
2624 }
2625 break;
2626 case '\'':
2627 if (State == DtdInputState.InsideSingleQuoted)
2628 stateStack.Pop ();
2629 else if (State != DtdInputState.InsideDoubleQuoted && State != DtdInputState.Comment)
2630 stateStack.Push (DtdInputState.InsideSingleQuoted);
2631 break;
2632 case '"':
2633 if (State == DtdInputState.InsideDoubleQuoted)
2634 stateStack.Pop ();
2635 else if (State != DtdInputState.InsideSingleQuoted && State != DtdInputState.Comment)
2636 stateStack.Push (DtdInputState.InsideDoubleQuoted);
2637 break;
2638 case '>':
2639 switch (State) {
2640 case DtdInputState.ElementDecl:
2641 goto case DtdInputState.NotationDecl;
2642 case DtdInputState.AttlistDecl:
2643 goto case DtdInputState.NotationDecl;
2644 case DtdInputState.EntityDecl:
2645 goto case DtdInputState.NotationDecl;
2646 case DtdInputState.NotationDecl:
2647 stateStack.Pop ();
2648 break;
2649 case DtdInputState.InsideDoubleQuoted:
2650 case DtdInputState.InsideSingleQuoted:
2651 case DtdInputState.Comment:
2652 continue;
2653 default:
2654 throw NotWFError ("unexpected token '>'");
2655 }
2656 break;
2657 case '?':
2658 if (State == DtdInputState.PI) {
2659 if (ReadValueChar () == '>')
2660 stateStack.Pop ();
2661 }
2662 break;
2663 case '-':
2664 if (State == DtdInputState.Comment) {
2665 if (PeekChar () == '-') {
2666 ReadValueChar ();
2667 ExpectAndAppend (">");
2668 stateStack.Pop ();
2669 }
2670 }
2671 break;
2672 case '%':
2673 if (State != DtdInputState.Free && State != DtdInputState.EntityDecl && State != DtdInputState.Comment && State != DtdInputState.InsideDoubleQuoted && State != DtdInputState.InsideSingleQuoted)
2674 throw NotWFError ("Parameter Entity Reference cannot appear as a part of markupdecl (see XML spec 2.8).");
2675 break;
2676 }
2677 }
2678 }
2679
2680 // The reader is positioned on the first 'S' of "SYSTEM".
2681 private string ReadSystemLiteral (bool expectSYSTEM)
2682 {
2683 if(expectSYSTEM) {
2684 Expect ("SYSTEM");
2685 if (!SkipWhitespace ())
2686 throw NotWFError ("Whitespace is required after 'SYSTEM'.");
2687 }
2688 else
2689 SkipWhitespace ();
2690 int quoteChar = ReadChar (); // apos or quot
2691 int c = 0;
2692 ClearValueBuffer ();
2693 while (c != quoteChar) {
2694 c = ReadChar ();
2695 if (c < 0)
2696 throw NotWFError ("Unexpected end of stream in ExternalID.");
2697 if (c != quoteChar)
2698 AppendValueChar (c);
2699 }
2700 return CreateValueString ();
2701 }
2702
2703 private string ReadPubidLiteral()
2704 {
2705 Expect ("PUBLIC");
2706 if (!SkipWhitespace ())
2707 throw NotWFError ("Whitespace is required after 'PUBLIC'.");
2708 int quoteChar = ReadChar ();
2709 int c = 0;
2710 ClearValueBuffer ();
2711 while(c != quoteChar)
2712 {
2713 c = ReadChar ();
2714 if(c < 0) throw NotWFError ("Unexpected end of stream in ExternalID.");
2715 if(c != quoteChar && !XmlChar.IsPubidChar (c))
2716 throw NotWFError (String.Format ("character '{0}' not allowed for PUBLIC ID", (char)c ));
2717 if (c != quoteChar)
2718 AppendValueChar (c);
2719 }
2720 return CreateValueString ();
2721 }
2722
2723 // The reader is positioned on the first character
2724 // of the name.
2725 private string ReadName ()
2726 {
2727 string prefix, local;
2728 return ReadName (out prefix, out local);
2729 }
2730
2731 private string ReadName (out string prefix, out string localName)
2732 {
2733 #if !USE_NAME_BUFFER
2734 bool savePreserve = preserveCurrentTag;
2735 preserveCurrentTag = true;
2736
2737 int startOffset = peekCharsIndex - curNodePeekIndex;
2738 int ch = PeekChar ();
2739 if (!XmlChar.IsFirstNameChar (ch))
2740 throw NotWFError (String.Format (CultureInfo.InvariantCulture, "a name did not start with a legal character {0} ({1})", ch, (char) ch));
2741 Advance (ch);
2742 int length = 1;
2743 int colonAt = -1;
2744
2745 while (XmlChar.IsNameChar ((ch = PeekChar ()))) {
2746 Advance (ch);
2747 if (ch == ':' && namespaces && colonAt < 0)
2748 colonAt = length;
2749 length++;
2750 }
2751
2752 int start = curNodePeekIndex + startOffset;
2753
2754 string name = NameTable.Add (
2755 peekChars, start, length);
2756
2757 if (colonAt > 0) {
2758 prefix = NameTable.Add (
2759 peekChars, start, colonAt);
2760 localName = NameTable.Add (
2761 peekChars, start + colonAt + 1, length - colonAt - 1);
2762 } else {
2763 prefix = String.Empty;
2764 localName = name;
2765 }
2766
2767 preserveCurrentTag = savePreserve;
2768
2769 return name;
2770 #else
2771 int ch = PeekChar ();
2772 if (!XmlChar.IsFirstNameChar (ch))
2773 throw NotWFError (String.Format (CultureInfo.InvariantCulture, "a name did not start with a legal character {0} ({1})", ch, (char) ch));
2774
2775 nameLength = 0;
2776
2777 Advance (ch);
2778 // AppendNameChar (ch);
2779 {
2780 // nameBuffer.Length is always non-0 so no need to ExpandNameCapacity () here
2781 if (ch <= Char.MaxValue)
2782 nameBuffer [nameLength++] = (char) ch;
2783 else
2784 AppendSurrogatePairNameChar (ch);
2785 }
2786
2787 int colonAt = -1;
2788
2789 while (XmlChar.IsNameChar ((ch = PeekChar ()))) {
2790 Advance (ch);
2791
2792 if (ch == ':' && namespaces && colonAt < 0)
2793 colonAt = nameLength;
2794 // AppendNameChar (ch);
2795 {
2796 if (nameLength == nameCapacity)
2797 ExpandNameCapacity ();
2798 if (ch <= Char.MaxValue)
2799 nameBuffer [nameLength++] = (char) ch;
2800 else
2801 AppendSurrogatePairNameChar (ch);
2802 }
2803 }
2804
2805 string name = NameTable.Add (nameBuffer, 0, nameLength);
2806
2807 if (colonAt > 0) {
2808 prefix = NameTable.Add (nameBuffer, 0, colonAt);
2809 localName = NameTable.Add (nameBuffer, colonAt + 1, nameLength - colonAt - 1);
2810 } else {
2811 prefix = String.Empty;
2812 localName = name;
2813 }
2814
2815 return name;
2816 #endif
2817 }
2818
2819 // Read the next character and compare it against the
2820 // specified character.
2821 private void Expect (int expected)
2822 {
2823 int ch = ReadChar ();
2824
2825 if (ch != expected) {
2826 throw NotWFError (String.Format (CultureInfo.InvariantCulture,
2827 "expected '{0}' ({1:X}) but found '{2}' ({3:X})",
2828 (char) expected,
2829 expected,
2830 ch < 0 ? (object) "EOF" : (char) ch,
2831 ch));
2832 }
2833 }
2834
2835 private void Expect (string expected)
2836 {
2837 for (int i = 0; i < expected.Length; i++)
2838 if (ReadChar () != expected [i])
2839 throw NotWFError (String.Format (CultureInfo.InvariantCulture,
2840 "'{0}' is expected", expected));
2841 }
2842
2843 private void ExpectAfterWhitespace (char c)
2844 {
2845 while (true) {
2846 int i = ReadChar ();
2847 if (i < 0x21 && XmlChar.IsWhitespace (i))
2848 continue;
2849 if (c != i)
2850 throw NotWFError (String.Format (CultureInfo.InvariantCulture, "Expected {0}, but found {1} [{2}]", c, i < 0 ? (object) "EOF" : (char) i, i));
2851 break;
2852 }
2853 }
2854
2855 // Does not consume the first non-whitespace character.
2856 private bool SkipWhitespace ()
2857 {
2858 // FIXME: It should be inlined by the JIT.
2859 // bool skipped = XmlChar.IsWhitespace (PeekChar ());
2860 int ch = PeekChar ();
2861 bool skipped = (ch == 0x20 || ch == 0x9 || ch == 0xA || ch == 0xD);
2862 if (!skipped)
2863 return false;
2864 Advance (ch);
2865 // FIXME: It should be inlined by the JIT.
2866 // while (XmlChar.IsWhitespace (PeekChar ()))
2867 // ReadChar ();
2868 while ((ch = PeekChar ()) == 0x20 || ch == 0x9 || ch == 0xA || ch == 0xD)
2869 Advance (ch);
2870 return skipped;
2871 }
2872
2873 private bool ReadWhitespace ()
2874 {
2875 if (currentState == XmlNodeType.None)
2876 currentState = XmlNodeType.XmlDeclaration;
2877
2878 bool savePreserve = preserveCurrentTag;
2879 preserveCurrentTag = true;
2880 int startOffset = peekCharsIndex - curNodePeekIndex; // it should be 0 for now though.
2881
2882 int ch = PeekChar ();
2883 do {
2884 Advance (ch);
2885 ch = PeekChar ();
2886 // FIXME: It should be inlined by the JIT.
2887 // } while ((ch = PeekChar ()) != -1 && XmlChar.IsWhitespace (ch));
2888 } while (ch == 0x20 || ch == 0x9 || ch == 0xA || ch == 0xD);
2889
2890 bool isText = currentState == XmlNodeType.Element && ch != -1 && ch != '<';
2891
2892 if (!isText && (whitespaceHandling == WhitespaceHandling.None ||
2893 whitespaceHandling == WhitespaceHandling.Significant && XmlSpace != XmlSpace.Preserve))
2894 return false;
2895
2896 ClearValueBuffer ();
2897 valueBuffer.Append (peekChars, curNodePeekIndex, peekCharsIndex - curNodePeekIndex - startOffset);
2898 preserveCurrentTag = savePreserve;
2899
2900 if (isText) {
2901 ReadText (false);
2902 } else {
2903 XmlNodeType nodeType = (this.XmlSpace == XmlSpace.Preserve) ?
2904 XmlNodeType.SignificantWhitespace : XmlNodeType.Whitespace;
2905 SetProperties (nodeType,
2906 String.Empty,
2907 String.Empty,
2908 String.Empty,
2909 false,
2910 null, // value: create only when required
2911 true);
2912 }
2913
2914 return true;
2915 }
2916
2917 // Returns -1 if it should throw an error.
2918 private int ReadCharsInternal (char [] buffer, int offset, int length)
2919 {
2920 int bufIndex = offset;
2921 for (int i = 0; i < length; i++) {
2922 int c = PeekChar ();
2923 switch (c) {
2924 case -1:
2925 throw NotWFError ("Unexpected end of xml.");
2926 case '<':
2927 if (i + 1 == length)
2928 // if it does not end here,
2929 // it cannot store another
2930 // character, so stop here.
2931 return i;
2932 Advance (c);
2933 if (PeekChar () != '/') {
2934 nestLevel++;
2935 buffer [bufIndex++] = '<';
2936 continue;
2937 }
2938 else if (nestLevel-- > 0) {
2939 buffer [bufIndex++] = '<';
2940 continue;
2941 }
2942 // Seems to skip immediate EndElement
2943 Expect ('/');
2944 if (depthUp) {
2945 depth++;
2946 depthUp = false;
2947 }
2948 ReadEndTag ();
2949 readCharsInProgress = false;
2950 Read (); // move to the next node
2951 return i;
2952 default:
2953 Advance (c);
2954 if (c <= Char.MaxValue)
2955 buffer [bufIndex++] = (char) c;
2956 else {
2957 buffer [bufIndex++] = (char) ((c - 0x10000) / 0x400 + 0xD800);
2958 buffer [bufIndex++] = (char) ((c - 0x10000) % 0x400 + 0xDC00);
2959 }
2960 break;
2961 }
2962 }
2963 return length;
2964 }
2965
2966 private bool ReadUntilEndTag ()
2967 {
2968 if (Depth == 0)
2969 currentState = XmlNodeType.EndElement;
2970 int ch;
2971 do {
2972 ch = ReadChar ();
2973 switch (ch) {
2974 case -1:
2975 throw NotWFError ("Unexpected end of xml.");
2976 case '<':
2977 if (PeekChar () != '/') {
2978 nestLevel++;
2979 continue;
2980 }
2981 else if (--nestLevel > 0)
2982 continue;
2983 ReadChar ();
2984 string name = ReadName ();
2985 if (name != elementNames [elementNameStackPos - 1].Name)
2986 continue;
2987 Expect ('>');
2988 depth--;
2989 return Read ();
2990 }
2991 } while (true);
2992 }
2993 #endregion
2994 }
2995 }
git-svn mirror of mcs