Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
DtdParser.cs
Go to the documentation of this file.
1using System.Collections.Generic;
2using System.Diagnostics.CodeAnalysis;
3using System.Text;
4using System.Threading.Tasks;
5using System.Xml.Schema;
6
7namespace System.Xml;
8
9internal sealed class DtdParser : IDtdParser
10{
11 private enum Token
12 {
13 CDATA,
14 ID,
15 IDREF,
16 IDREFS,
17 ENTITY,
18 ENTITIES,
19 NMTOKEN,
20 NMTOKENS,
21 NOTATION,
22 None,
23 PERef,
24 AttlistDecl,
25 ElementDecl,
26 EntityDecl,
27 NotationDecl,
28 Comment,
29 PI,
30 CondSectionStart,
31 CondSectionEnd,
32 Eof,
33 REQUIRED,
34 IMPLIED,
35 FIXED,
36 QName,
37 Name,
38 Nmtoken,
39 Quote,
40 LeftParen,
41 RightParen,
42 GreaterThan,
43 Or,
44 LeftBracket,
45 RightBracket,
46 PUBLIC,
47 SYSTEM,
48 Literal,
49 DOCTYPE,
50 NData,
51 Percent,
52 Star,
53 QMark,
54 Plus,
55 PCDATA,
56 Comma,
57 ANY,
58 EMPTY,
59 IGNORE,
60 INCLUDE
61 }
62
100
101 private enum LiteralType
102 {
103 AttributeValue,
104 EntityReplText,
105 SystemOrPublicID
106 }
107
108 private sealed class UndeclaredNotation
109 {
110 internal string name;
111
112 internal int lineNo;
113
114 internal int linePos;
115
116 internal UndeclaredNotation next;
117
118 internal UndeclaredNotation(string name, int lineNo, int linePos)
119 {
120 this.name = name;
121 this.lineNo = lineNo;
122 this.linePos = linePos;
123 next = null;
124 }
125 }
126
139
140 private IDtdParserAdapter _readerAdapter;
141
142 private IDtdParserAdapterWithValidation _readerAdapterWithValidation;
143
144 private XmlNameTable _nameTable;
145
146 private SchemaInfo _schemaInfo;
147
148 private string _systemId = string.Empty;
149
150 private string _publicId = string.Empty;
151
152 private bool _normalize = true;
153
154 private bool _validate;
155
156 private bool _supportNamespaces = true;
157
158 private bool _v1Compat;
159
160 private char[] _chars;
161
162 private int _charsUsed;
163
164 private int _curPos;
165
166 private ScanningFunction _scanningFunction;
167
168 private ScanningFunction _nextScaningFunction;
169
170 private ScanningFunction _savedScanningFunction;
171
172 private bool _whitespaceSeen;
173
174 private int _tokenStartPos;
175
176 private int _colonPos;
177
178 private StringBuilder _internalSubsetValueSb;
179
180 private int _externalEntitiesDepth;
181
182 private int _currentEntityId;
183
184 private bool _freeFloatingDtd;
185
186 private bool _hasFreeFloatingInternalSubset;
187
188 private StringBuilder _stringBuilder;
189
190 private int _condSectionDepth;
191
192 private LineInfo _literalLineInfo = new LineInfo(0, 0);
193
194 private char _literalQuoteChar = '"';
195
196 private string _documentBaseUri = string.Empty;
197
198 private string _externalDtdBaseUri = string.Empty;
199
200 private Dictionary<string, UndeclaredNotation> _undeclaredNotations;
201
202 private int[] _condSectionEntityIds;
203
204 private bool ParsingInternalSubset => _externalEntitiesDepth == 0;
205
206 private bool IgnoreEntityReferences => _scanningFunction == ScanningFunction.CondSection3;
207
208 private bool SaveInternalSubsetValue
209 {
210 get
211 {
212 if (_readerAdapter.EntityStackLength == 0)
213 {
214 return _internalSubsetValueSb != null;
215 }
216 return false;
217 }
218 }
219
220 private bool ParsingTopLevelMarkup
221 {
222 get
223 {
224 if (_scanningFunction != 0)
225 {
226 if (_scanningFunction == ScanningFunction.ParamEntitySpace)
227 {
228 return _savedScanningFunction == ScanningFunction.SubsetContent;
229 }
230 return false;
231 }
232 return true;
233 }
234 }
235
236 private bool SupportNamespaces => _supportNamespaces;
237
238 private bool Normalize => _normalize;
239
240 private int LineNo => _readerAdapter.LineNo;
241
242 private int LinePos => _curPos - _readerAdapter.LineStartPosition;
243
244 private string BaseUriStr
245 {
246 get
247 {
248 Uri baseUri = _readerAdapter.BaseUri;
249 if (!(baseUri != null))
250 {
251 return string.Empty;
252 }
253 return baseUri.ToString();
254 }
255 }
256
257 private DtdParser()
258 {
259 }
260
261 internal static IDtdParser Create()
262 {
263 return new DtdParser();
264 }
265
291
292 private void InitializeFreeFloatingDtd(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
293 {
294 Initialize(adapter);
295 if (docTypeName == null || docTypeName.Length == 0)
296 {
297 throw XmlConvert.CreateInvalidNameArgumentException(docTypeName, "docTypeName");
298 }
299 XmlConvert.VerifyName(docTypeName);
300 int num = docTypeName.IndexOf(':');
301 if (num == -1)
302 {
303 _schemaInfo.DocTypeName = new XmlQualifiedName(_nameTable.Add(docTypeName));
304 }
305 else
306 {
307 _schemaInfo.DocTypeName = new XmlQualifiedName(_nameTable.Add(docTypeName.Substring(0, num)), _nameTable.Add(docTypeName.Substring(num + 1)));
308 }
309 if (systemId != null && systemId.Length > 0)
310 {
311 int invCharPos;
312 if ((invCharPos = XmlCharType.IsOnlyCharData(systemId)) >= 0)
313 {
314 ThrowInvalidChar(_curPos, systemId, invCharPos);
315 }
316 _systemId = systemId;
317 }
318 if (publicId != null && publicId.Length > 0)
319 {
320 int invCharPos;
321 if ((invCharPos = XmlCharType.IsPublicId(publicId)) >= 0)
322 {
323 ThrowInvalidChar(_curPos, publicId, invCharPos);
324 }
325 _publicId = publicId;
326 }
327 if (internalSubset != null && internalSubset.Length > 0)
328 {
329 _readerAdapter.PushInternalDtd(baseUri, internalSubset);
330 _hasFreeFloatingInternalSubset = true;
331 }
332 Uri baseUri2 = _readerAdapter.BaseUri;
333 if (baseUri2 != null)
334 {
335 _documentBaseUri = baseUri2.ToString();
336 }
337 _freeFloatingDtd = true;
338 }
339
346
347 IDtdInfo IDtdParser.ParseFreeFloatingDtd(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
348 {
349 InitializeFreeFloatingDtd(baseUri, docTypeName, publicId, systemId, internalSubset, adapter);
350 Parse(saveInternalSubset: false);
351 return _schemaInfo;
352 }
353
354 private void Parse(bool saveInternalSubset)
355 {
356 if (_freeFloatingDtd)
357 {
358 ParseFreeFloatingDtd();
359 }
360 else
361 {
362 ParseInDocumentDtd(saveInternalSubset);
363 }
364 _schemaInfo.Finish();
365 if (!_validate || _undeclaredNotations == null)
366 {
367 return;
368 }
369 foreach (UndeclaredNotation value in _undeclaredNotations.Values)
370 {
371 for (UndeclaredNotation undeclaredNotation = value; undeclaredNotation != null; undeclaredNotation = undeclaredNotation.next)
372 {
373 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Sch_UndeclaredNotation, value.name, BaseUriStr, value.lineNo, value.linePos));
374 }
375 }
376 }
377
378 private void ParseInDocumentDtd(bool saveInternalSubset)
379 {
380 LoadParsingBuffer();
381 _scanningFunction = ScanningFunction.QName;
382 _nextScaningFunction = ScanningFunction.Doctype1;
383 if (GetToken(needWhiteSpace: false) != Token.QName)
384 {
385 OnUnexpectedError();
386 }
387 _schemaInfo.DocTypeName = GetNameQualified(canHavePrefix: true);
388 Token token = GetToken(needWhiteSpace: false);
389 if (token == Token.SYSTEM || token == Token.PUBLIC)
390 {
391 ParseExternalId(token, Token.DOCTYPE, out _publicId, out _systemId);
392 token = GetToken(needWhiteSpace: false);
393 }
394 switch (token)
395 {
396 case Token.LeftBracket:
397 if (saveInternalSubset)
398 {
399 SaveParsingBuffer();
400 _internalSubsetValueSb = new StringBuilder();
401 }
402 ParseInternalSubset();
403 break;
404 default:
405 OnUnexpectedError();
406 break;
407 case Token.GreaterThan:
408 break;
409 }
410 SaveParsingBuffer();
411 if (_systemId != null && _systemId.Length > 0)
412 {
413 ParseExternalSubset();
414 }
415 }
416
417 private void ParseFreeFloatingDtd()
418 {
419 if (_hasFreeFloatingInternalSubset)
420 {
421 LoadParsingBuffer();
422 ParseInternalSubset();
423 SaveParsingBuffer();
424 }
425 if (_systemId != null && _systemId.Length > 0)
426 {
427 ParseExternalSubset();
428 }
429 }
430
431 private void ParseInternalSubset()
432 {
433 ParseSubset();
434 }
435
436 private void ParseExternalSubset()
437 {
438 if (_readerAdapter.PushExternalSubset(_systemId, _publicId))
439 {
440 Uri baseUri = _readerAdapter.BaseUri;
441 if (baseUri != null)
442 {
443 _externalDtdBaseUri = baseUri.ToString();
444 }
445 _externalEntitiesDepth++;
446 LoadParsingBuffer();
447 ParseSubset();
448 }
449 }
450
451 private void ParseSubset()
452 {
453 while (true)
454 {
455 Token token = GetToken(needWhiteSpace: false);
456 int currentEntityId = _currentEntityId;
457 switch (token)
458 {
459 case Token.AttlistDecl:
460 ParseAttlistDecl();
461 break;
462 case Token.ElementDecl:
463 ParseElementDecl();
464 break;
465 case Token.EntityDecl:
466 ParseEntityDecl();
467 break;
468 case Token.NotationDecl:
469 ParseNotationDecl();
470 break;
471 case Token.Comment:
472 ParseComment();
473 break;
474 case Token.PI:
475 ParsePI();
476 break;
477 case Token.CondSectionStart:
478 if (ParsingInternalSubset)
479 {
480 Throw(_curPos - 3, System.SR.Xml_InvalidConditionalSection);
481 }
482 ParseCondSection();
483 currentEntityId = _currentEntityId;
484 break;
485 case Token.CondSectionEnd:
486 if (_condSectionDepth > 0)
487 {
488 _condSectionDepth--;
489 if (_validate && _currentEntityId != _condSectionEntityIds[_condSectionDepth])
490 {
491 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
492 }
493 }
494 else
495 {
496 Throw(_curPos - 3, System.SR.Xml_UnexpectedCDataEnd);
497 }
498 break;
499 case Token.RightBracket:
500 if (ParsingInternalSubset)
501 {
502 if (_condSectionDepth != 0)
503 {
504 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
505 }
506 if (_internalSubsetValueSb != null)
507 {
508 SaveParsingBuffer(_curPos - 1);
509 _schemaInfo.InternalDtdSubset = _internalSubsetValueSb.ToString();
510 _internalSubsetValueSb = null;
511 }
512 if (GetToken(needWhiteSpace: false) != Token.GreaterThan)
513 {
514 ThrowUnexpectedToken(_curPos, ">");
515 }
516 }
517 else
518 {
519 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
520 }
521 return;
522 case Token.Eof:
523 if (ParsingInternalSubset && !_freeFloatingDtd)
524 {
525 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
526 }
527 if (_condSectionDepth != 0)
528 {
529 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
530 }
531 return;
532 }
533 if (_currentEntityId != currentEntityId)
534 {
535 if (_validate)
536 {
537 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
538 }
539 else if (!_v1Compat)
540 {
541 Throw(_curPos, System.SR.Sch_ParEntityRefNesting);
542 }
543 }
544 }
545 }
546
547 private void ParseAttlistDecl()
548 {
549 if (GetToken(needWhiteSpace: true) == Token.QName)
550 {
551 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
552 if (!_schemaInfo.ElementDecls.TryGetValue(nameQualified, out var value) && !_schemaInfo.UndeclaredElementDecls.TryGetValue(nameQualified, out value))
553 {
554 value = new SchemaElementDecl(nameQualified, nameQualified.Namespace);
555 _schemaInfo.UndeclaredElementDecls.Add(nameQualified, value);
556 }
557 SchemaAttDef schemaAttDef = null;
558 while (true)
559 {
560 switch (GetToken(needWhiteSpace: false))
561 {
562 case Token.QName:
563 {
564 XmlQualifiedName nameQualified2 = GetNameQualified(canHavePrefix: true);
565 schemaAttDef = new SchemaAttDef(nameQualified2, nameQualified2.Namespace);
566 schemaAttDef.IsDeclaredInExternal = !ParsingInternalSubset;
567 schemaAttDef.LineNumber = LineNo;
568 schemaAttDef.LinePosition = LinePos - (_curPos - _tokenStartPos);
569 bool flag = value.GetAttDef(schemaAttDef.Name) != null;
570 ParseAttlistType(schemaAttDef, value, flag);
571 ParseAttlistDefault(schemaAttDef, flag);
572 if (schemaAttDef.Prefix.Length > 0 && schemaAttDef.Prefix.Equals("xml"))
573 {
574 if (schemaAttDef.Name.Name == "space")
575 {
576 if (_v1Compat)
577 {
578 string text = schemaAttDef.DefaultValueExpanded.Trim();
579 if (text.Equals("preserve") || text.Equals("default"))
580 {
581 schemaAttDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
582 }
583 }
584 else
585 {
586 schemaAttDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
587 if (schemaAttDef.TokenizedType != XmlTokenizedType.ENUMERATION)
588 {
589 Throw(System.SR.Xml_EnumerationRequired, string.Empty, schemaAttDef.LineNumber, schemaAttDef.LinePosition);
590 }
591 if (_validate)
592 {
593 schemaAttDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
594 }
595 }
596 }
597 else if (schemaAttDef.Name.Name == "lang")
598 {
599 schemaAttDef.Reserved = SchemaAttDef.Reserve.XmlLang;
600 }
601 }
602 if (!flag)
603 {
604 value.AddAttDef(schemaAttDef);
605 }
606 continue;
607 }
608 case Token.GreaterThan:
609 if (_v1Compat && schemaAttDef != null && schemaAttDef.Prefix.Length > 0 && schemaAttDef.Prefix.Equals("xml") && schemaAttDef.Name.Name == "space")
610 {
611 schemaAttDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
612 if (schemaAttDef.Datatype.TokenizedType != XmlTokenizedType.ENUMERATION)
613 {
614 Throw(System.SR.Xml_EnumerationRequired, string.Empty, schemaAttDef.LineNumber, schemaAttDef.LinePosition);
615 }
616 if (_validate)
617 {
618 schemaAttDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
619 }
620 }
621 return;
622 }
623 break;
624 }
625 }
626 OnUnexpectedError();
627 }
628
629 private void ParseAttlistType(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
630 {
631 Token token = GetToken(needWhiteSpace: true);
632 if (token != 0)
633 {
634 elementDecl.HasNonCDataAttribute = true;
635 }
636 if (IsAttributeValueType(token))
637 {
638 attrDef.TokenizedType = (XmlTokenizedType)token;
639 attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
640 switch (token)
641 {
642 default:
643 return;
644 case Token.ID:
645 if (_validate && elementDecl.IsIdDeclared)
646 {
647 SchemaAttDef attDef = elementDecl.GetAttDef(attrDef.Name);
648 if ((attDef == null || attDef.Datatype.TokenizedType != XmlTokenizedType.ID) && !ignoreErrors)
649 {
650 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_IdAttrDeclared, elementDecl.Name.ToString());
651 }
652 }
653 elementDecl.IsIdDeclared = true;
654 return;
655 case Token.NOTATION:
656 break;
657 }
658 if (_validate)
659 {
660 if (elementDecl.IsNotationDeclared && !ignoreErrors)
661 {
662 SendValidationEvent(_curPos - 8, XmlSeverityType.Error, System.SR.Sch_DupNotationAttribute, elementDecl.Name.ToString());
663 }
664 else
665 {
666 if (elementDecl.ContentValidator != null && elementDecl.ContentValidator.ContentType == XmlSchemaContentType.Empty && !ignoreErrors)
667 {
668 SendValidationEvent(_curPos - 8, XmlSeverityType.Error, System.SR.Sch_NotationAttributeOnEmptyElement, elementDecl.Name.ToString());
669 }
670 elementDecl.IsNotationDeclared = true;
671 }
672 }
673 if (GetToken(needWhiteSpace: true) == Token.LeftParen && GetToken(needWhiteSpace: false) == Token.Name)
674 {
675 do
676 {
677 string nameString = GetNameString();
678 if (!_schemaInfo.Notations.ContainsKey(nameString))
679 {
680 AddUndeclaredNotation(nameString);
681 }
682 if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(nameString) && !ignoreErrors)
683 {
684 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Xml_AttlistDuplNotationValue, nameString, BaseUriStr, LineNo, LinePos));
685 }
686 attrDef.AddValue(nameString);
687 switch (GetToken(needWhiteSpace: false))
688 {
689 case Token.Or:
690 continue;
691 case Token.RightParen:
692 return;
693 }
694 break;
695 }
696 while (GetToken(needWhiteSpace: false) == Token.Name);
697 }
698 }
699 else if (token == Token.LeftParen)
700 {
701 attrDef.TokenizedType = XmlTokenizedType.ENUMERATION;
702 attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
703 if (GetToken(needWhiteSpace: false) == Token.Nmtoken)
704 {
705 attrDef.AddValue(GetNameString());
706 while (true)
707 {
708 string nmtokenString;
709 switch (GetToken(needWhiteSpace: false))
710 {
711 case Token.Or:
712 if (GetToken(needWhiteSpace: false) == Token.Nmtoken)
713 {
714 nmtokenString = GetNmtokenString();
715 if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(nmtokenString) && !ignoreErrors)
716 {
717 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Xml_AttlistDuplEnumValue, nmtokenString, BaseUriStr, LineNo, LinePos));
718 }
719 goto IL_0278;
720 }
721 break;
722 case Token.RightParen:
723 return;
724 }
725 break;
726 IL_0278:
727 attrDef.AddValue(nmtokenString);
728 }
729 }
730 }
731 OnUnexpectedError();
732 }
733
734 private void ParseAttlistDefault(SchemaAttDef attrDef, bool ignoreErrors)
735 {
736 switch (GetToken(needWhiteSpace: true))
737 {
738 case Token.REQUIRED:
739 attrDef.Presence = SchemaDeclBase.Use.Required;
740 return;
741 case Token.IMPLIED:
742 attrDef.Presence = SchemaDeclBase.Use.Implied;
743 return;
744 case Token.FIXED:
745 attrDef.Presence = SchemaDeclBase.Use.Fixed;
746 if (GetToken(needWhiteSpace: true) != Token.Literal)
747 {
748 break;
749 }
750 goto case Token.Literal;
751 case Token.Literal:
752 if (_validate && attrDef.Datatype.TokenizedType == XmlTokenizedType.ID && !ignoreErrors)
753 {
754 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_AttListPresence, string.Empty);
755 }
756 if (attrDef.TokenizedType != 0)
757 {
758 attrDef.DefaultValueExpanded = GetValueWithStrippedSpaces();
759 }
760 else
761 {
762 attrDef.DefaultValueExpanded = GetValue();
763 }
764 attrDef.ValueLineNumber = _literalLineInfo.lineNo;
765 attrDef.ValueLinePosition = _literalLineInfo.linePos + 1;
766 DtdValidator.SetDefaultTypedValue(attrDef, _readerAdapter);
767 return;
768 }
769 OnUnexpectedError();
770 }
771
772 private void ParseElementDecl()
773 {
774 if (GetToken(needWhiteSpace: true) == Token.QName)
775 {
776 SchemaElementDecl value = null;
777 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
778 if (_schemaInfo.ElementDecls.TryGetValue(nameQualified, out value))
779 {
780 if (_validate)
781 {
782 SendValidationEvent(_curPos - nameQualified.Name.Length, XmlSeverityType.Error, System.SR.Sch_DupElementDecl, GetNameString());
783 }
784 }
785 else
786 {
787 if (_schemaInfo.UndeclaredElementDecls.TryGetValue(nameQualified, out value))
788 {
789 _schemaInfo.UndeclaredElementDecls.Remove(nameQualified);
790 }
791 else
792 {
793 value = new SchemaElementDecl(nameQualified, nameQualified.Namespace);
794 }
795 _schemaInfo.ElementDecls.Add(nameQualified, value);
796 }
797 value.IsDeclaredInExternal = !ParsingInternalSubset;
798 Token token = GetToken(needWhiteSpace: true);
799 if (token != Token.LeftParen)
800 {
801 if (token != Token.ANY)
802 {
803 if (token != Token.EMPTY)
804 {
805 goto IL_0181;
806 }
807 value.ContentValidator = ContentValidator.Empty;
808 }
809 else
810 {
811 value.ContentValidator = ContentValidator.Any;
812 }
813 }
814 else
815 {
816 int currentEntityId = _currentEntityId;
817 Token token2 = GetToken(needWhiteSpace: false);
818 if (token2 != Token.None)
819 {
820 if (token2 != Token.PCDATA)
821 {
822 goto IL_0181;
823 }
824 ParticleContentValidator particleContentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
825 particleContentValidator.Start();
826 particleContentValidator.OpenGroup();
827 ParseElementMixedContent(particleContentValidator, currentEntityId);
828 value.ContentValidator = particleContentValidator.Finish(useDFA: true);
829 }
830 else
831 {
832 ParticleContentValidator particleContentValidator2 = null;
833 particleContentValidator2 = new ParticleContentValidator(XmlSchemaContentType.ElementOnly);
834 particleContentValidator2.Start();
835 particleContentValidator2.OpenGroup();
836 ParseElementOnlyContent(particleContentValidator2, currentEntityId);
837 value.ContentValidator = particleContentValidator2.Finish(useDFA: true);
838 }
839 }
840 if (GetToken(needWhiteSpace: false) != Token.GreaterThan)
841 {
842 ThrowUnexpectedToken(_curPos, ">");
843 }
844 return;
845 }
846 goto IL_0181;
847 IL_0181:
848 OnUnexpectedError();
849 }
850
851 private void ParseElementOnlyContent(ParticleContentValidator pcv, int startParenEntityId)
852 {
853 Stack<ParseElementOnlyContent_LocalFrame> stack = new Stack<ParseElementOnlyContent_LocalFrame>();
854 ParseElementOnlyContent_LocalFrame parseElementOnlyContent_LocalFrame = new ParseElementOnlyContent_LocalFrame(startParenEntityId);
855 stack.Push(parseElementOnlyContent_LocalFrame);
856 while (true)
857 {
858 Token token = GetToken(needWhiteSpace: false);
859 if (token != Token.QName)
860 {
861 if (token != Token.LeftParen)
862 {
863 if (token != Token.GreaterThan)
864 {
865 goto IL_0148;
866 }
867 Throw(_curPos, System.SR.Xml_InvalidContentModel);
868 goto IL_014e;
869 }
870 pcv.OpenGroup();
871 parseElementOnlyContent_LocalFrame = new ParseElementOnlyContent_LocalFrame(_currentEntityId);
872 stack.Push(parseElementOnlyContent_LocalFrame);
873 continue;
874 }
875 pcv.AddName(GetNameQualified(canHavePrefix: true), null);
876 ParseHowMany(pcv);
877 goto IL_0078;
878 IL_0148:
879 OnUnexpectedError();
880 goto IL_014e;
881 IL_00f9:
882 pcv.CloseGroup();
883 if (_validate && _currentEntityId != parseElementOnlyContent_LocalFrame.startParenEntityId)
884 {
885 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
886 }
887 ParseHowMany(pcv);
888 goto IL_014e;
889 IL_00cb:
890 if (parseElementOnlyContent_LocalFrame.parsingSchema == Token.Comma)
891 {
892 Throw(_curPos, System.SR.Xml_InvalidContentModel);
893 }
894 pcv.AddChoice();
895 parseElementOnlyContent_LocalFrame.parsingSchema = Token.Or;
896 continue;
897 IL_014e:
898 stack.Pop();
899 if (stack.Count > 0)
900 {
901 parseElementOnlyContent_LocalFrame = stack.Peek();
902 goto IL_0078;
903 }
904 break;
905 IL_0135:
906 Throw(_curPos, System.SR.Xml_InvalidContentModel);
907 goto IL_014e;
908 IL_0078:
909 switch (GetToken(needWhiteSpace: false))
910 {
911 case Token.Comma:
912 break;
913 case Token.Or:
914 goto IL_00cb;
915 case Token.RightParen:
916 goto IL_00f9;
917 case Token.GreaterThan:
918 goto IL_0135;
919 default:
920 goto IL_0148;
921 }
922 if (parseElementOnlyContent_LocalFrame.parsingSchema == Token.Or)
923 {
924 Throw(_curPos, System.SR.Xml_InvalidContentModel);
925 }
926 pcv.AddSequence();
927 parseElementOnlyContent_LocalFrame.parsingSchema = Token.Comma;
928 }
929 }
930
931 private void ParseHowMany(ParticleContentValidator pcv)
932 {
933 switch (GetToken(needWhiteSpace: false))
934 {
935 case Token.Star:
936 pcv.AddStar();
937 break;
938 case Token.QMark:
939 pcv.AddQMark();
940 break;
941 case Token.Plus:
942 pcv.AddPlus();
943 break;
944 }
945 }
946
947 private void ParseElementMixedContent(ParticleContentValidator pcv, int startParenEntityId)
948 {
949 bool flag = false;
950 int num = -1;
951 int currentEntityId = _currentEntityId;
952 while (true)
953 {
954 switch (GetToken(needWhiteSpace: false))
955 {
956 case Token.RightParen:
957 pcv.CloseGroup();
958 if (_validate && _currentEntityId != startParenEntityId)
959 {
960 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
961 }
962 if (GetToken(needWhiteSpace: false) == Token.Star && flag)
963 {
964 pcv.AddStar();
965 }
966 else if (flag)
967 {
968 ThrowUnexpectedToken(_curPos, "*");
969 }
970 return;
971 case Token.Or:
972 {
973 if (!flag)
974 {
975 flag = true;
976 }
977 else
978 {
979 pcv.AddChoice();
980 }
981 if (_validate)
982 {
983 num = _currentEntityId;
984 if (currentEntityId < num)
985 {
986 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
987 }
988 }
989 if (GetToken(needWhiteSpace: false) != Token.QName)
990 {
991 break;
992 }
993 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
994 if (pcv.Exists(nameQualified) && _validate)
995 {
996 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_DupElement, nameQualified.ToString());
997 }
998 pcv.AddName(nameQualified, null);
999 if (_validate)
1000 {
1001 currentEntityId = _currentEntityId;
1002 if (currentEntityId < num)
1003 {
1004 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
1005 }
1006 }
1007 continue;
1008 }
1009 }
1010 OnUnexpectedError();
1011 }
1012 }
1013
1014 private void ParseEntityDecl()
1015 {
1016 bool flag = false;
1017 SchemaEntity schemaEntity = null;
1018 Token token = GetToken(needWhiteSpace: true);
1019 if (token == Token.Name)
1020 {
1021 goto IL_002c;
1022 }
1023 if (token == Token.Percent)
1024 {
1025 flag = true;
1026 if (GetToken(needWhiteSpace: true) == Token.Name)
1027 {
1028 goto IL_002c;
1029 }
1030 }
1031 goto IL_01d6;
1032 IL_002c:
1033 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: false);
1034 schemaEntity = new SchemaEntity(nameQualified, flag);
1035 schemaEntity.BaseURI = BaseUriStr;
1036 schemaEntity.DeclaredURI = ((_externalDtdBaseUri.Length == 0) ? _documentBaseUri : _externalDtdBaseUri);
1037 if (flag)
1038 {
1039 if (!_schemaInfo.ParameterEntities.ContainsKey(nameQualified))
1040 {
1041 _schemaInfo.ParameterEntities.Add(nameQualified, schemaEntity);
1042 }
1043 }
1044 else if (!_schemaInfo.GeneralEntities.ContainsKey(nameQualified))
1045 {
1046 _schemaInfo.GeneralEntities.Add(nameQualified, schemaEntity);
1047 }
1048 schemaEntity.DeclaredInExternal = !ParsingInternalSubset;
1049 schemaEntity.ParsingInProgress = true;
1050 Token token2 = GetToken(needWhiteSpace: true);
1051 if ((uint)(token2 - 33) > 1u)
1052 {
1053 if (token2 != Token.Literal)
1054 {
1055 goto IL_01d6;
1056 }
1057 schemaEntity.Text = GetValue();
1058 schemaEntity.Line = _literalLineInfo.lineNo;
1059 schemaEntity.Pos = _literalLineInfo.linePos;
1060 }
1061 else
1062 {
1063 ParseExternalId(token2, Token.EntityDecl, out var publicId, out var systemId);
1064 schemaEntity.IsExternal = true;
1065 schemaEntity.Url = systemId;
1066 schemaEntity.Pubid = publicId;
1067 if (GetToken(needWhiteSpace: false) == Token.NData)
1068 {
1069 if (flag)
1070 {
1071 ThrowUnexpectedToken(_curPos - 5, ">");
1072 }
1073 if (!_whitespaceSeen)
1074 {
1075 Throw(_curPos - 5, System.SR.Xml_ExpectingWhiteSpace, "NDATA");
1076 }
1077 if (GetToken(needWhiteSpace: true) != Token.Name)
1078 {
1079 goto IL_01d6;
1080 }
1081 schemaEntity.NData = GetNameQualified(canHavePrefix: false);
1082 string name = schemaEntity.NData.Name;
1083 if (!_schemaInfo.Notations.ContainsKey(name))
1084 {
1085 AddUndeclaredNotation(name);
1086 }
1087 }
1088 }
1089 if (GetToken(needWhiteSpace: false) == Token.GreaterThan)
1090 {
1091 schemaEntity.ParsingInProgress = false;
1092 return;
1093 }
1094 goto IL_01d6;
1095 IL_01d6:
1096 OnUnexpectedError();
1097 }
1098
1099 private void ParseNotationDecl()
1100 {
1101 if (GetToken(needWhiteSpace: true) != Token.Name)
1102 {
1103 OnUnexpectedError();
1104 }
1105 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: false);
1106 SchemaNotation schemaNotation = null;
1107 if (!_schemaInfo.Notations.ContainsKey(nameQualified.Name))
1108 {
1109 if (_undeclaredNotations != null)
1110 {
1111 _undeclaredNotations.Remove(nameQualified.Name);
1112 }
1113 schemaNotation = new SchemaNotation(nameQualified);
1114 _schemaInfo.Notations.Add(schemaNotation.Name.Name, schemaNotation);
1115 }
1116 else if (_validate)
1117 {
1118 SendValidationEvent(_curPos - nameQualified.Name.Length, XmlSeverityType.Error, System.SR.Sch_DupNotation, nameQualified.Name);
1119 }
1120 Token token = GetToken(needWhiteSpace: true);
1121 if (token == Token.SYSTEM || token == Token.PUBLIC)
1122 {
1123 ParseExternalId(token, Token.NOTATION, out var publicId, out var systemId);
1124 if (schemaNotation != null)
1125 {
1126 schemaNotation.SystemLiteral = systemId;
1127 schemaNotation.Pubid = publicId;
1128 }
1129 }
1130 else
1131 {
1132 OnUnexpectedError();
1133 }
1134 if (GetToken(needWhiteSpace: false) != Token.GreaterThan)
1135 {
1136 OnUnexpectedError();
1137 }
1138 }
1139
1157
1158 private void ParseComment()
1159 {
1160 SaveParsingBuffer();
1161 try
1162 {
1163 if (SaveInternalSubsetValue)
1164 {
1165 _readerAdapter.ParseComment(_internalSubsetValueSb);
1166 _internalSubsetValueSb.Append("-->");
1167 }
1168 else
1169 {
1170 _readerAdapter.ParseComment(null);
1171 }
1172 }
1173 catch (XmlException ex)
1174 {
1175 if (!(ex.ResString == System.SR.Xml_UnexpectedEOF) || _currentEntityId == 0)
1176 {
1177 throw;
1178 }
1179 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, null);
1180 }
1181 LoadParsingBuffer();
1182 }
1183
1184 private void ParsePI()
1185 {
1186 SaveParsingBuffer();
1187 if (SaveInternalSubsetValue)
1188 {
1189 _readerAdapter.ParsePI(_internalSubsetValueSb);
1190 _internalSubsetValueSb.Append("?>");
1191 }
1192 else
1193 {
1194 _readerAdapter.ParsePI(null);
1195 }
1196 LoadParsingBuffer();
1197 }
1198
1199 private void ParseCondSection()
1200 {
1201 int currentEntityId = _currentEntityId;
1202 switch (GetToken(needWhiteSpace: false))
1203 {
1204 case Token.INCLUDE:
1205 if (GetToken(needWhiteSpace: false) == Token.LeftBracket)
1206 {
1207 if (_validate && currentEntityId != _currentEntityId)
1208 {
1209 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
1210 }
1211 if (_validate)
1212 {
1213 if (_condSectionEntityIds == null)
1214 {
1215 _condSectionEntityIds = new int[2];
1216 }
1217 else if (_condSectionEntityIds.Length == _condSectionDepth)
1218 {
1219 int[] array = new int[_condSectionEntityIds.Length * 2];
1220 Array.Copy(_condSectionEntityIds, array, _condSectionEntityIds.Length);
1221 _condSectionEntityIds = array;
1222 }
1223 _condSectionEntityIds[_condSectionDepth] = currentEntityId;
1224 }
1225 _condSectionDepth++;
1226 break;
1227 }
1228 goto default;
1229 case Token.IGNORE:
1230 if (GetToken(needWhiteSpace: false) == Token.LeftBracket)
1231 {
1232 if (_validate && currentEntityId != _currentEntityId)
1233 {
1234 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
1235 }
1236 if (GetToken(needWhiteSpace: false) == Token.CondSectionEnd)
1237 {
1238 if (_validate && currentEntityId != _currentEntityId)
1239 {
1240 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
1241 }
1242 break;
1243 }
1244 }
1245 goto default;
1246 default:
1247 OnUnexpectedError();
1248 break;
1249 }
1250 }
1251
1252 private void ParseExternalId(Token idTokenType, Token declType, out string publicId, out string systemId)
1253 {
1254 LineInfo keywordLineInfo = new LineInfo(LineNo, LinePos - 6);
1255 publicId = null;
1256 systemId = null;
1257 if (GetToken(needWhiteSpace: true) != Token.Literal)
1258 {
1259 ThrowUnexpectedToken(_curPos, "\"", "'");
1260 }
1261 if (idTokenType == Token.SYSTEM)
1262 {
1263 systemId = GetValue();
1264 if (systemId.Contains('#'))
1265 {
1266 Throw(_curPos - systemId.Length - 1, System.SR.Xml_FragmentId, new string[2]
1267 {
1268 systemId.Substring(systemId.IndexOf('#')),
1269 systemId
1270 });
1271 }
1272 if (declType == Token.DOCTYPE && !_freeFloatingDtd)
1273 {
1274 _literalLineInfo.linePos++;
1275 _readerAdapter.OnSystemId(systemId, keywordLineInfo, _literalLineInfo);
1276 }
1277 return;
1278 }
1279 publicId = GetValue();
1280 int num;
1281 if ((num = XmlCharType.IsPublicId(publicId)) >= 0)
1282 {
1283 ThrowInvalidChar(_curPos - 1 - publicId.Length + num, publicId, num);
1284 }
1285 if (declType == Token.DOCTYPE && !_freeFloatingDtd)
1286 {
1287 _literalLineInfo.linePos++;
1288 _readerAdapter.OnPublicId(publicId, keywordLineInfo, _literalLineInfo);
1289 if (GetToken(needWhiteSpace: false) == Token.Literal)
1290 {
1291 if (!_whitespaceSeen)
1292 {
1293 Throw(System.SR.Xml_ExpectingWhiteSpace, char.ToString(_literalQuoteChar), _literalLineInfo.lineNo, _literalLineInfo.linePos);
1294 }
1295 systemId = GetValue();
1296 _literalLineInfo.linePos++;
1297 _readerAdapter.OnSystemId(systemId, keywordLineInfo, _literalLineInfo);
1298 }
1299 else
1300 {
1301 ThrowUnexpectedToken(_curPos, "\"", "'");
1302 }
1303 }
1304 else if (GetToken(needWhiteSpace: false) == Token.Literal)
1305 {
1306 if (!_whitespaceSeen)
1307 {
1308 Throw(System.SR.Xml_ExpectingWhiteSpace, char.ToString(_literalQuoteChar), _literalLineInfo.lineNo, _literalLineInfo.linePos);
1309 }
1310 systemId = GetValue();
1311 }
1312 else if (declType != Token.NOTATION)
1313 {
1314 ThrowUnexpectedToken(_curPos, "\"", "'");
1315 }
1316 }
1317
1318 private Token GetToken(bool needWhiteSpace)
1319 {
1320 _whitespaceSeen = false;
1321 while (true)
1322 {
1323 switch (_chars[_curPos])
1324 {
1325 case '\0':
1326 if (_curPos != _charsUsed)
1327 {
1328 ThrowInvalidChar(_chars, _charsUsed, _curPos);
1329 }
1330 break;
1331 case '\n':
1332 _whitespaceSeen = true;
1333 _curPos++;
1334 _readerAdapter.OnNewLine(_curPos);
1335 continue;
1336 case '\r':
1337 _whitespaceSeen = true;
1338 if (_chars[_curPos + 1] == '\n')
1339 {
1340 if (Normalize)
1341 {
1342 SaveParsingBuffer();
1343 _readerAdapter.CurrentPosition++;
1344 }
1345 _curPos += 2;
1346 }
1347 else
1348 {
1349 if (_curPos + 1 >= _charsUsed && !_readerAdapter.IsEof)
1350 {
1351 break;
1352 }
1353 _chars[_curPos] = '\n';
1354 _curPos++;
1355 }
1356 _readerAdapter.OnNewLine(_curPos);
1357 continue;
1358 case '\t':
1359 case ' ':
1360 _whitespaceSeen = true;
1361 _curPos++;
1362 continue;
1363 case '%':
1364 if (_charsUsed - _curPos < 2)
1365 {
1366 break;
1367 }
1368 if (!XmlCharType.IsWhiteSpace(_chars[_curPos + 1]))
1369 {
1370 if (IgnoreEntityReferences)
1371 {
1372 _curPos++;
1373 }
1374 else
1375 {
1376 HandleEntityReference(paramEntity: true, inLiteral: false, inAttribute: false);
1377 }
1378 continue;
1379 }
1380 goto default;
1381 default:
1382 if (needWhiteSpace && !_whitespaceSeen && _scanningFunction != ScanningFunction.ParamEntitySpace)
1383 {
1384 Throw(_curPos, System.SR.Xml_ExpectingWhiteSpace, ParseUnexpectedToken(_curPos));
1385 }
1386 _tokenStartPos = _curPos;
1387 while (true)
1388 {
1389 switch (_scanningFunction)
1390 {
1391 case ScanningFunction.Name:
1392 return ScanNameExpected();
1393 case ScanningFunction.QName:
1394 return ScanQNameExpected();
1395 case ScanningFunction.Nmtoken:
1396 return ScanNmtokenExpected();
1397 case ScanningFunction.SubsetContent:
1398 return ScanSubsetContent();
1399 case ScanningFunction.Doctype1:
1400 return ScanDoctype1();
1401 case ScanningFunction.Doctype2:
1402 return ScanDoctype2();
1403 case ScanningFunction.Element1:
1404 return ScanElement1();
1405 case ScanningFunction.Element2:
1406 return ScanElement2();
1407 case ScanningFunction.Element3:
1408 return ScanElement3();
1409 case ScanningFunction.Element4:
1410 return ScanElement4();
1411 case ScanningFunction.Element5:
1412 return ScanElement5();
1413 case ScanningFunction.Element6:
1414 return ScanElement6();
1415 case ScanningFunction.Element7:
1416 return ScanElement7();
1417 case ScanningFunction.Attlist1:
1418 return ScanAttlist1();
1419 case ScanningFunction.Attlist2:
1420 return ScanAttlist2();
1421 case ScanningFunction.Attlist3:
1422 return ScanAttlist3();
1423 case ScanningFunction.Attlist4:
1424 return ScanAttlist4();
1425 case ScanningFunction.Attlist5:
1426 return ScanAttlist5();
1427 case ScanningFunction.Attlist6:
1428 return ScanAttlist6();
1429 case ScanningFunction.Attlist7:
1430 return ScanAttlist7();
1431 case ScanningFunction.Notation1:
1432 return ScanNotation1();
1433 case ScanningFunction.SystemId:
1434 return ScanSystemId();
1435 case ScanningFunction.PublicId1:
1436 return ScanPublicId1();
1437 case ScanningFunction.PublicId2:
1438 return ScanPublicId2();
1439 case ScanningFunction.Entity1:
1440 return ScanEntity1();
1441 case ScanningFunction.Entity2:
1442 return ScanEntity2();
1443 case ScanningFunction.Entity3:
1444 return ScanEntity3();
1445 case ScanningFunction.CondSection1:
1446 return ScanCondSection1();
1447 case ScanningFunction.CondSection2:
1448 return ScanCondSection2();
1449 case ScanningFunction.CondSection3:
1450 return ScanCondSection3();
1451 case ScanningFunction.ClosingTag:
1452 return ScanClosingTag();
1453 case ScanningFunction.ParamEntitySpace:
1454 break;
1455 default:
1456 return Token.None;
1457 }
1458 _whitespaceSeen = true;
1459 _scanningFunction = _savedScanningFunction;
1460 }
1461 }
1462 if ((_readerAdapter.IsEof || ReadData() == 0) && !HandleEntityEnd(inLiteral: false))
1463 {
1464 if (_scanningFunction == ScanningFunction.SubsetContent)
1465 {
1466 break;
1467 }
1468 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
1469 }
1470 }
1471 return Token.Eof;
1472 }
1473
1474 private Token ScanSubsetContent()
1475 {
1476 while (true)
1477 {
1478 char c = _chars[_curPos];
1479 if (c != '<')
1480 {
1481 if (c != ']')
1482 {
1483 goto IL_04f3;
1484 }
1485 if (_charsUsed - _curPos >= 2 || _readerAdapter.IsEof)
1486 {
1487 if (_chars[_curPos + 1] != ']')
1488 {
1489 _curPos++;
1490 _scanningFunction = ScanningFunction.ClosingTag;
1491 return Token.RightBracket;
1492 }
1493 if (_charsUsed - _curPos >= 3 || _readerAdapter.IsEof)
1494 {
1495 if (_chars[_curPos + 1] == ']' && _chars[_curPos + 2] == '>')
1496 {
1497 break;
1498 }
1499 goto IL_04f3;
1500 }
1501 }
1502 }
1503 else
1504 {
1505 switch (_chars[_curPos + 1])
1506 {
1507 case '!':
1508 switch (_chars[_curPos + 2])
1509 {
1510 case 'E':
1511 if (_chars[_curPos + 3] == 'L')
1512 {
1513 if (_charsUsed - _curPos >= 9)
1514 {
1515 if (_chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'M' || _chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'N' || _chars[_curPos + 8] != 'T')
1516 {
1517 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1518 }
1519 _curPos += 9;
1520 _scanningFunction = ScanningFunction.QName;
1521 _nextScaningFunction = ScanningFunction.Element1;
1522 return Token.ElementDecl;
1523 }
1524 }
1525 else if (_chars[_curPos + 3] == 'N')
1526 {
1527 if (_charsUsed - _curPos >= 8)
1528 {
1529 if (_chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'T' || _chars[_curPos + 7] != 'Y')
1530 {
1531 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1532 }
1533 _curPos += 8;
1534 _scanningFunction = ScanningFunction.Entity1;
1535 return Token.EntityDecl;
1536 }
1537 }
1538 else if (_charsUsed - _curPos >= 4)
1539 {
1540 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1541 return Token.None;
1542 }
1543 break;
1544 case 'A':
1545 if (_charsUsed - _curPos >= 9)
1546 {
1547 if (_chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'L' || _chars[_curPos + 6] != 'I' || _chars[_curPos + 7] != 'S' || _chars[_curPos + 8] != 'T')
1548 {
1549 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1550 }
1551 _curPos += 9;
1552 _scanningFunction = ScanningFunction.QName;
1553 _nextScaningFunction = ScanningFunction.Attlist1;
1554 return Token.AttlistDecl;
1555 }
1556 break;
1557 case 'N':
1558 if (_charsUsed - _curPos >= 10)
1559 {
1560 if (_chars[_curPos + 3] != 'O' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'A' || _chars[_curPos + 6] != 'T' || _chars[_curPos + 7] != 'I' || _chars[_curPos + 8] != 'O' || _chars[_curPos + 9] != 'N')
1561 {
1562 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1563 }
1564 _curPos += 10;
1565 _scanningFunction = ScanningFunction.Name;
1566 _nextScaningFunction = ScanningFunction.Notation1;
1567 return Token.NotationDecl;
1568 }
1569 break;
1570 case '[':
1571 _curPos += 3;
1572 _scanningFunction = ScanningFunction.CondSection1;
1573 return Token.CondSectionStart;
1574 case '-':
1575 if (_chars[_curPos + 3] == '-')
1576 {
1577 _curPos += 4;
1578 return Token.Comment;
1579 }
1580 if (_charsUsed - _curPos >= 4)
1581 {
1582 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1583 }
1584 break;
1585 default:
1586 if (_charsUsed - _curPos >= 3)
1587 {
1588 Throw(_curPos + 2, System.SR.Xml_ExpectDtdMarkup);
1589 }
1590 break;
1591 }
1592 break;
1593 case '?':
1594 _curPos += 2;
1595 return Token.PI;
1596 default:
1597 if (_charsUsed - _curPos >= 2)
1598 {
1599 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1600 return Token.None;
1601 }
1602 break;
1603 }
1604 }
1605 goto IL_0513;
1606 IL_0513:
1607 if (ReadData() == 0)
1608 {
1609 Throw(_charsUsed, System.SR.Xml_IncompleteDtdContent);
1610 }
1611 continue;
1612 IL_04f3:
1613 if (_charsUsed - _curPos != 0)
1614 {
1615 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
1616 }
1617 goto IL_0513;
1618 }
1619 _curPos += 3;
1620 return Token.CondSectionEnd;
1621 }
1622
1623 private Token ScanNameExpected()
1624 {
1625 ScanName();
1626 _scanningFunction = _nextScaningFunction;
1627 return Token.Name;
1628 }
1629
1630 private Token ScanQNameExpected()
1631 {
1632 ScanQName();
1633 _scanningFunction = _nextScaningFunction;
1634 return Token.QName;
1635 }
1636
1637 private Token ScanNmtokenExpected()
1638 {
1639 ScanNmtoken();
1640 _scanningFunction = _nextScaningFunction;
1641 return Token.Nmtoken;
1642 }
1643
1644 private Token ScanDoctype1()
1645 {
1646 switch (_chars[_curPos])
1647 {
1648 case 'P':
1649 if (!EatPublicKeyword())
1650 {
1651 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
1652 }
1653 _nextScaningFunction = ScanningFunction.Doctype2;
1654 _scanningFunction = ScanningFunction.PublicId1;
1655 return Token.PUBLIC;
1656 case 'S':
1657 if (!EatSystemKeyword())
1658 {
1659 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
1660 }
1661 _nextScaningFunction = ScanningFunction.Doctype2;
1662 _scanningFunction = ScanningFunction.SystemId;
1663 return Token.SYSTEM;
1664 case '[':
1665 _curPos++;
1666 _scanningFunction = ScanningFunction.SubsetContent;
1667 return Token.LeftBracket;
1668 case '>':
1669 _curPos++;
1670 _scanningFunction = ScanningFunction.SubsetContent;
1671 return Token.GreaterThan;
1672 default:
1673 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
1674 return Token.None;
1675 }
1676 }
1677
1678 private Token ScanDoctype2()
1679 {
1680 switch (_chars[_curPos])
1681 {
1682 case '[':
1683 _curPos++;
1684 _scanningFunction = ScanningFunction.SubsetContent;
1685 return Token.LeftBracket;
1686 case '>':
1687 _curPos++;
1688 _scanningFunction = ScanningFunction.SubsetContent;
1689 return Token.GreaterThan;
1690 default:
1691 Throw(_curPos, System.SR.Xml_ExpectSubOrClose);
1692 return Token.None;
1693 }
1694 }
1695
1696 private Token ScanClosingTag()
1697 {
1698 if (_chars[_curPos] != '>')
1699 {
1700 ThrowUnexpectedToken(_curPos, ">");
1701 }
1702 _curPos++;
1703 _scanningFunction = ScanningFunction.SubsetContent;
1704 return Token.GreaterThan;
1705 }
1706
1707 private Token ScanElement1()
1708 {
1709 while (true)
1710 {
1711 char c = _chars[_curPos];
1712 if (c != '(')
1713 {
1714 if (c != 'A')
1715 {
1716 if (c == 'E')
1717 {
1718 if (_charsUsed - _curPos < 5)
1719 {
1720 goto IL_011b;
1721 }
1722 if (_chars[_curPos + 1] == 'M' && _chars[_curPos + 2] == 'P' && _chars[_curPos + 3] == 'T' && _chars[_curPos + 4] == 'Y')
1723 {
1724 _curPos += 5;
1725 _scanningFunction = ScanningFunction.ClosingTag;
1726 return Token.EMPTY;
1727 }
1728 }
1729 }
1730 else
1731 {
1732 if (_charsUsed - _curPos < 3)
1733 {
1734 goto IL_011b;
1735 }
1736 if (_chars[_curPos + 1] == 'N' && _chars[_curPos + 2] == 'Y')
1737 {
1738 break;
1739 }
1740 }
1741 Throw(_curPos, System.SR.Xml_InvalidContentModel);
1742 goto IL_011b;
1743 }
1744 _scanningFunction = ScanningFunction.Element2;
1745 _curPos++;
1746 return Token.LeftParen;
1747 IL_011b:
1748 if (ReadData() == 0)
1749 {
1750 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
1751 }
1752 }
1753 _curPos += 3;
1754 _scanningFunction = ScanningFunction.ClosingTag;
1755 return Token.ANY;
1756 }
1757
1758 private Token ScanElement2()
1759 {
1760 if (_chars[_curPos] == '#')
1761 {
1762 while (_charsUsed - _curPos < 7)
1763 {
1764 if (ReadData() == 0)
1765 {
1766 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
1767 }
1768 }
1769 if (_chars[_curPos + 1] == 'P' && _chars[_curPos + 2] == 'C' && _chars[_curPos + 3] == 'D' && _chars[_curPos + 4] == 'A' && _chars[_curPos + 5] == 'T' && _chars[_curPos + 6] == 'A')
1770 {
1771 _curPos += 7;
1772 _scanningFunction = ScanningFunction.Element6;
1773 return Token.PCDATA;
1774 }
1775 Throw(_curPos + 1, System.SR.Xml_ExpectPcData);
1776 }
1777 _scanningFunction = ScanningFunction.Element3;
1778 return Token.None;
1779 }
1780
1781 private Token ScanElement3()
1782 {
1783 switch (_chars[_curPos])
1784 {
1785 case '(':
1786 _curPos++;
1787 return Token.LeftParen;
1788 case '>':
1789 _curPos++;
1790 _scanningFunction = ScanningFunction.SubsetContent;
1791 return Token.GreaterThan;
1792 default:
1793 ScanQName();
1794 _scanningFunction = ScanningFunction.Element4;
1795 return Token.QName;
1796 }
1797 }
1798
1799 private Token ScanElement4()
1800 {
1801 _scanningFunction = ScanningFunction.Element5;
1802 Token result;
1803 switch (_chars[_curPos])
1804 {
1805 case '*':
1806 result = Token.Star;
1807 break;
1808 case '?':
1809 result = Token.QMark;
1810 break;
1811 case '+':
1812 result = Token.Plus;
1813 break;
1814 default:
1815 return Token.None;
1816 }
1817 if (_whitespaceSeen)
1818 {
1819 Throw(_curPos, System.SR.Xml_ExpectNoWhitespace);
1820 }
1821 _curPos++;
1822 return result;
1823 }
1824
1825 private Token ScanElement5()
1826 {
1827 switch (_chars[_curPos])
1828 {
1829 case ',':
1830 _curPos++;
1831 _scanningFunction = ScanningFunction.Element3;
1832 return Token.Comma;
1833 case '|':
1834 _curPos++;
1835 _scanningFunction = ScanningFunction.Element3;
1836 return Token.Or;
1837 case ')':
1838 _curPos++;
1839 _scanningFunction = ScanningFunction.Element4;
1840 return Token.RightParen;
1841 case '>':
1842 _curPos++;
1843 _scanningFunction = ScanningFunction.SubsetContent;
1844 return Token.GreaterThan;
1845 default:
1846 Throw(_curPos, System.SR.Xml_ExpectOp);
1847 return Token.None;
1848 }
1849 }
1850
1851 private Token ScanElement6()
1852 {
1853 switch (_chars[_curPos])
1854 {
1855 case ')':
1856 _curPos++;
1857 _scanningFunction = ScanningFunction.Element7;
1858 return Token.RightParen;
1859 case '|':
1860 _curPos++;
1861 _nextScaningFunction = ScanningFunction.Element6;
1862 _scanningFunction = ScanningFunction.QName;
1863 return Token.Or;
1864 default:
1865 ThrowUnexpectedToken(_curPos, ")", "|");
1866 return Token.None;
1867 }
1868 }
1869
1870 private Token ScanElement7()
1871 {
1872 _scanningFunction = ScanningFunction.ClosingTag;
1873 if (_chars[_curPos] == '*' && !_whitespaceSeen)
1874 {
1875 _curPos++;
1876 return Token.Star;
1877 }
1878 return Token.None;
1879 }
1880
1881 private Token ScanAttlist1()
1882 {
1883 char c = _chars[_curPos];
1884 if (c == '>')
1885 {
1886 _curPos++;
1887 _scanningFunction = ScanningFunction.SubsetContent;
1888 return Token.GreaterThan;
1889 }
1890 if (!_whitespaceSeen)
1891 {
1892 Throw(_curPos, System.SR.Xml_ExpectingWhiteSpace, ParseUnexpectedToken(_curPos));
1893 }
1894 ScanQName();
1895 _scanningFunction = ScanningFunction.Attlist2;
1896 return Token.QName;
1897 }
1898
1899 private Token ScanAttlist2()
1900 {
1901 while (true)
1902 {
1903 switch (_chars[_curPos])
1904 {
1905 case '(':
1906 _curPos++;
1907 _scanningFunction = ScanningFunction.Nmtoken;
1908 _nextScaningFunction = ScanningFunction.Attlist5;
1909 return Token.LeftParen;
1910 case 'C':
1911 if (_charsUsed - _curPos >= 5)
1912 {
1913 if (_chars[_curPos + 1] != 'D' || _chars[_curPos + 2] != 'A' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'A')
1914 {
1915 Throw(_curPos, System.SR.Xml_InvalidAttributeType1);
1916 }
1917 _curPos += 5;
1918 _scanningFunction = ScanningFunction.Attlist6;
1919 return Token.CDATA;
1920 }
1921 break;
1922 case 'E':
1923 if (_charsUsed - _curPos < 9)
1924 {
1925 break;
1926 }
1927 _scanningFunction = ScanningFunction.Attlist6;
1928 if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'I' || _chars[_curPos + 4] != 'T')
1929 {
1930 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1931 }
1932 switch (_chars[_curPos + 5])
1933 {
1934 case 'I':
1935 if (_chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'S')
1936 {
1937 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1938 }
1939 _curPos += 8;
1940 return Token.ENTITIES;
1941 case 'Y':
1942 _curPos += 6;
1943 return Token.ENTITY;
1944 }
1945 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1946 break;
1947 case 'I':
1948 if (_charsUsed - _curPos >= 6)
1949 {
1950 _scanningFunction = ScanningFunction.Attlist6;
1951 if (_chars[_curPos + 1] != 'D')
1952 {
1953 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1954 }
1955 if (_chars[_curPos + 2] != 'R')
1956 {
1957 _curPos += 2;
1958 return Token.ID;
1959 }
1960 if (_chars[_curPos + 3] != 'E' || _chars[_curPos + 4] != 'F')
1961 {
1962 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1963 }
1964 if (_chars[_curPos + 5] != 'S')
1965 {
1966 _curPos += 5;
1967 return Token.IDREF;
1968 }
1969 _curPos += 6;
1970 return Token.IDREFS;
1971 }
1972 break;
1973 case 'N':
1974 if (_charsUsed - _curPos < 8 && !_readerAdapter.IsEof)
1975 {
1976 break;
1977 }
1978 switch (_chars[_curPos + 1])
1979 {
1980 case 'O':
1981 if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'A' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'O' || _chars[_curPos + 7] != 'N')
1982 {
1983 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1984 }
1985 _curPos += 8;
1986 _scanningFunction = ScanningFunction.Attlist3;
1987 return Token.NOTATION;
1988 case 'M':
1989 if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'O' || _chars[_curPos + 4] != 'K' || _chars[_curPos + 5] != 'E' || _chars[_curPos + 6] != 'N')
1990 {
1991 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
1992 }
1993 _scanningFunction = ScanningFunction.Attlist6;
1994 if (_chars[_curPos + 7] == 'S')
1995 {
1996 _curPos += 8;
1997 return Token.NMTOKENS;
1998 }
1999 _curPos += 7;
2000 return Token.NMTOKEN;
2001 }
2002 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
2003 break;
2004 default:
2005 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
2006 break;
2007 }
2008 if (ReadData() == 0)
2009 {
2010 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
2011 }
2012 }
2013 }
2014
2015 private Token ScanAttlist3()
2016 {
2017 if (_chars[_curPos] == '(')
2018 {
2019 _curPos++;
2020 _scanningFunction = ScanningFunction.Name;
2021 _nextScaningFunction = ScanningFunction.Attlist4;
2022 return Token.LeftParen;
2023 }
2024 ThrowUnexpectedToken(_curPos, "(");
2025 return Token.None;
2026 }
2027
2028 private Token ScanAttlist4()
2029 {
2030 switch (_chars[_curPos])
2031 {
2032 case ')':
2033 _curPos++;
2034 _scanningFunction = ScanningFunction.Attlist6;
2035 return Token.RightParen;
2036 case '|':
2037 _curPos++;
2038 _scanningFunction = ScanningFunction.Name;
2039 _nextScaningFunction = ScanningFunction.Attlist4;
2040 return Token.Or;
2041 default:
2042 ThrowUnexpectedToken(_curPos, ")", "|");
2043 return Token.None;
2044 }
2045 }
2046
2047 private Token ScanAttlist5()
2048 {
2049 switch (_chars[_curPos])
2050 {
2051 case ')':
2052 _curPos++;
2053 _scanningFunction = ScanningFunction.Attlist6;
2054 return Token.RightParen;
2055 case '|':
2056 _curPos++;
2057 _scanningFunction = ScanningFunction.Nmtoken;
2058 _nextScaningFunction = ScanningFunction.Attlist5;
2059 return Token.Or;
2060 default:
2061 ThrowUnexpectedToken(_curPos, ")", "|");
2062 return Token.None;
2063 }
2064 }
2065
2066 private Token ScanAttlist6()
2067 {
2068 while (true)
2069 {
2070 switch (_chars[_curPos])
2071 {
2072 case '"':
2073 case '\'':
2074 ScanLiteral(LiteralType.AttributeValue);
2075 _scanningFunction = ScanningFunction.Attlist1;
2076 return Token.Literal;
2077 case '#':
2078 if (_charsUsed - _curPos < 6)
2079 {
2080 break;
2081 }
2082 switch (_chars[_curPos + 1])
2083 {
2084 case 'R':
2085 if (_charsUsed - _curPos >= 9)
2086 {
2087 if (_chars[_curPos + 2] != 'E' || _chars[_curPos + 3] != 'Q' || _chars[_curPos + 4] != 'U' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'R' || _chars[_curPos + 7] != 'E' || _chars[_curPos + 8] != 'D')
2088 {
2089 Throw(_curPos, System.SR.Xml_ExpectAttType);
2090 }
2091 _curPos += 9;
2092 _scanningFunction = ScanningFunction.Attlist1;
2093 return Token.REQUIRED;
2094 }
2095 break;
2096 case 'I':
2097 if (_charsUsed - _curPos >= 8)
2098 {
2099 if (_chars[_curPos + 2] != 'M' || _chars[_curPos + 3] != 'P' || _chars[_curPos + 4] != 'L' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'D')
2100 {
2101 Throw(_curPos, System.SR.Xml_ExpectAttType);
2102 }
2103 _curPos += 8;
2104 _scanningFunction = ScanningFunction.Attlist1;
2105 return Token.IMPLIED;
2106 }
2107 break;
2108 case 'F':
2109 if (_chars[_curPos + 2] != 'I' || _chars[_curPos + 3] != 'X' || _chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'D')
2110 {
2111 Throw(_curPos, System.SR.Xml_ExpectAttType);
2112 }
2113 _curPos += 6;
2114 _scanningFunction = ScanningFunction.Attlist7;
2115 return Token.FIXED;
2116 default:
2117 Throw(_curPos, System.SR.Xml_ExpectAttType);
2118 break;
2119 }
2120 break;
2121 default:
2122 Throw(_curPos, System.SR.Xml_ExpectAttType);
2123 break;
2124 }
2125 if (ReadData() == 0)
2126 {
2127 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
2128 }
2129 }
2130 }
2131
2132 private Token ScanAttlist7()
2133 {
2134 char c = _chars[_curPos];
2135 if (c == '"' || c == '\'')
2136 {
2137 ScanLiteral(LiteralType.AttributeValue);
2138 _scanningFunction = ScanningFunction.Attlist1;
2139 return Token.Literal;
2140 }
2141 ThrowUnexpectedToken(_curPos, "\"", "'");
2142 return Token.None;
2143 }
2144
2145 private Token ScanLiteral(LiteralType literalType)
2146 {
2147 char c = _chars[_curPos];
2148 char value = ((literalType == LiteralType.AttributeValue) ? ' ' : '\n');
2149 int currentEntityId = _currentEntityId;
2150 _literalLineInfo.Set(LineNo, LinePos);
2151 _curPos++;
2152 _tokenStartPos = _curPos;
2153 _stringBuilder.Length = 0;
2154 while (true)
2155 {
2156 if (XmlCharType.IsAttributeValueChar(_chars[_curPos]) && _chars[_curPos] != '%')
2157 {
2158 _curPos++;
2159 continue;
2160 }
2161 if (_chars[_curPos] == c && _currentEntityId == currentEntityId)
2162 {
2163 break;
2164 }
2165 int num = _curPos - _tokenStartPos;
2166 if (num > 0)
2167 {
2168 _stringBuilder.Append(_chars, _tokenStartPos, num);
2169 _tokenStartPos = _curPos;
2170 }
2171 switch (_chars[_curPos])
2172 {
2173 case '"':
2174 case '\'':
2175 case '>':
2176 _curPos++;
2177 continue;
2178 case '\n':
2179 _curPos++;
2180 if (Normalize)
2181 {
2182 _stringBuilder.Append(value);
2183 _tokenStartPos = _curPos;
2184 }
2185 _readerAdapter.OnNewLine(_curPos);
2186 continue;
2187 case '\r':
2188 if (_chars[_curPos + 1] == '\n')
2189 {
2190 if (Normalize)
2191 {
2192 if (literalType == LiteralType.AttributeValue)
2193 {
2194 _stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? " " : " ");
2195 }
2196 else
2197 {
2198 _stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? "\r\n" : "\n");
2199 }
2200 _tokenStartPos = _curPos + 2;
2201 SaveParsingBuffer();
2202 _readerAdapter.CurrentPosition++;
2203 }
2204 _curPos += 2;
2205 }
2206 else
2207 {
2208 if (_curPos + 1 == _charsUsed)
2209 {
2210 break;
2211 }
2212 _curPos++;
2213 if (Normalize)
2214 {
2215 _stringBuilder.Append(value);
2216 _tokenStartPos = _curPos;
2217 }
2218 }
2219 _readerAdapter.OnNewLine(_curPos);
2220 continue;
2221 case '\t':
2222 if (literalType == LiteralType.AttributeValue && Normalize)
2223 {
2224 _stringBuilder.Append(' ');
2225 _tokenStartPos++;
2226 }
2227 _curPos++;
2228 continue;
2229 case '<':
2230 if (literalType == LiteralType.AttributeValue)
2231 {
2232 Throw(_curPos, System.SR.Xml_BadAttributeChar, XmlException.BuildCharExceptionArgs('<', '\0'));
2233 }
2234 _curPos++;
2235 continue;
2236 case '%':
2237 if (literalType != LiteralType.EntityReplText)
2238 {
2239 _curPos++;
2240 continue;
2241 }
2242 HandleEntityReference(paramEntity: true, inLiteral: true, literalType == LiteralType.AttributeValue);
2243 _tokenStartPos = _curPos;
2244 continue;
2245 case '&':
2246 {
2247 if (literalType == LiteralType.SystemOrPublicID)
2248 {
2249 _curPos++;
2250 continue;
2251 }
2252 if (_curPos + 1 == _charsUsed)
2253 {
2254 break;
2255 }
2256 if (_chars[_curPos + 1] == '#')
2257 {
2258 SaveParsingBuffer();
2259 int num2 = _readerAdapter.ParseNumericCharRef(SaveInternalSubsetValue ? _internalSubsetValueSb : null);
2260 LoadParsingBuffer();
2261 _stringBuilder.Append(_chars, _curPos, num2 - _curPos);
2262 _readerAdapter.CurrentPosition = num2;
2263 _tokenStartPos = num2;
2264 _curPos = num2;
2265 continue;
2266 }
2267 SaveParsingBuffer();
2268 if (literalType == LiteralType.AttributeValue)
2269 {
2270 int num3 = _readerAdapter.ParseNamedCharRef(expand: true, SaveInternalSubsetValue ? _internalSubsetValueSb : null);
2271 LoadParsingBuffer();
2272 if (num3 >= 0)
2273 {
2274 _stringBuilder.Append(_chars, _curPos, num3 - _curPos);
2275 _readerAdapter.CurrentPosition = num3;
2276 _tokenStartPos = num3;
2277 _curPos = num3;
2278 }
2279 else
2280 {
2281 HandleEntityReference(paramEntity: false, inLiteral: true, inAttribute: true);
2282 _tokenStartPos = _curPos;
2283 }
2284 continue;
2285 }
2286 int num4 = _readerAdapter.ParseNamedCharRef(expand: false, null);
2287 LoadParsingBuffer();
2288 if (num4 >= 0)
2289 {
2290 _tokenStartPos = _curPos;
2291 _curPos = num4;
2292 continue;
2293 }
2294 _stringBuilder.Append('&');
2295 _curPos++;
2296 _tokenStartPos = _curPos;
2297 XmlQualifiedName entityName = ScanEntityName();
2298 VerifyEntityReference(entityName, paramEntity: false, mustBeDeclared: false, inAttribute: false);
2299 continue;
2300 }
2301 default:
2302 {
2303 if (_curPos == _charsUsed)
2304 {
2305 break;
2306 }
2307 char ch = _chars[_curPos];
2308 if (XmlCharType.IsHighSurrogate(ch))
2309 {
2310 if (_curPos + 1 == _charsUsed)
2311 {
2312 break;
2313 }
2314 _curPos++;
2315 if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
2316 {
2317 _curPos++;
2318 continue;
2319 }
2320 }
2321 ThrowInvalidChar(_chars, _charsUsed, _curPos);
2322 return Token.None;
2323 }
2324 }
2325 if ((_readerAdapter.IsEof || ReadData() == 0) && (literalType == LiteralType.SystemOrPublicID || !HandleEntityEnd(inLiteral: true)))
2326 {
2327 Throw(_curPos, System.SR.Xml_UnclosedQuote);
2328 }
2329 _tokenStartPos = _curPos;
2330 }
2331 if (_stringBuilder.Length > 0)
2332 {
2333 _stringBuilder.Append(_chars, _tokenStartPos, _curPos - _tokenStartPos);
2334 }
2335 _curPos++;
2336 _literalQuoteChar = c;
2337 return Token.Literal;
2338 }
2339
2340 private XmlQualifiedName ScanEntityName()
2341 {
2342 try
2343 {
2344 ScanName();
2345 }
2346 catch (XmlException ex)
2347 {
2348 Throw(System.SR.Xml_ErrorParsingEntityName, string.Empty, ex.LineNumber, ex.LinePosition);
2349 }
2350 if (_chars[_curPos] != ';')
2351 {
2352 ThrowUnexpectedToken(_curPos, ";");
2353 }
2354 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: false);
2355 _curPos++;
2356 return nameQualified;
2357 }
2358
2359 private Token ScanNotation1()
2360 {
2361 switch (_chars[_curPos])
2362 {
2363 case 'P':
2364 if (!EatPublicKeyword())
2365 {
2366 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
2367 }
2368 _nextScaningFunction = ScanningFunction.ClosingTag;
2369 _scanningFunction = ScanningFunction.PublicId1;
2370 return Token.PUBLIC;
2371 case 'S':
2372 if (!EatSystemKeyword())
2373 {
2374 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
2375 }
2376 _nextScaningFunction = ScanningFunction.ClosingTag;
2377 _scanningFunction = ScanningFunction.SystemId;
2378 return Token.SYSTEM;
2379 default:
2380 Throw(_curPos, System.SR.Xml_ExpectExternalOrPublicId);
2381 return Token.None;
2382 }
2383 }
2384
2385 private Token ScanSystemId()
2386 {
2387 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
2388 {
2389 ThrowUnexpectedToken(_curPos, "\"", "'");
2390 }
2391 ScanLiteral(LiteralType.SystemOrPublicID);
2392 _scanningFunction = _nextScaningFunction;
2393 return Token.Literal;
2394 }
2395
2396 private Token ScanEntity1()
2397 {
2398 if (_chars[_curPos] == '%')
2399 {
2400 _curPos++;
2401 _nextScaningFunction = ScanningFunction.Entity2;
2402 _scanningFunction = ScanningFunction.Name;
2403 return Token.Percent;
2404 }
2405 ScanName();
2406 _scanningFunction = ScanningFunction.Entity2;
2407 return Token.Name;
2408 }
2409
2410 private Token ScanEntity2()
2411 {
2412 switch (_chars[_curPos])
2413 {
2414 case 'P':
2415 if (!EatPublicKeyword())
2416 {
2417 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
2418 }
2419 _nextScaningFunction = ScanningFunction.Entity3;
2420 _scanningFunction = ScanningFunction.PublicId1;
2421 return Token.PUBLIC;
2422 case 'S':
2423 if (!EatSystemKeyword())
2424 {
2425 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
2426 }
2427 _nextScaningFunction = ScanningFunction.Entity3;
2428 _scanningFunction = ScanningFunction.SystemId;
2429 return Token.SYSTEM;
2430 case '"':
2431 case '\'':
2432 ScanLiteral(LiteralType.EntityReplText);
2433 _scanningFunction = ScanningFunction.ClosingTag;
2434 return Token.Literal;
2435 default:
2436 Throw(_curPos, System.SR.Xml_ExpectExternalIdOrEntityValue);
2437 return Token.None;
2438 }
2439 }
2440
2441 private Token ScanEntity3()
2442 {
2443 if (_chars[_curPos] == 'N')
2444 {
2445 do
2446 {
2447 if (_charsUsed - _curPos >= 5)
2448 {
2449 if (_chars[_curPos + 1] != 'D' || _chars[_curPos + 2] != 'A' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'A')
2450 {
2451 break;
2452 }
2453 _curPos += 5;
2454 _scanningFunction = ScanningFunction.Name;
2455 _nextScaningFunction = ScanningFunction.ClosingTag;
2456 return Token.NData;
2457 }
2458 }
2459 while (ReadData() != 0);
2460 }
2461 _scanningFunction = ScanningFunction.ClosingTag;
2462 return Token.None;
2463 }
2464
2465 private Token ScanPublicId1()
2466 {
2467 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
2468 {
2469 ThrowUnexpectedToken(_curPos, "\"", "'");
2470 }
2471 ScanLiteral(LiteralType.SystemOrPublicID);
2472 _scanningFunction = ScanningFunction.PublicId2;
2473 return Token.Literal;
2474 }
2475
2476 private Token ScanPublicId2()
2477 {
2478 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
2479 {
2480 _scanningFunction = _nextScaningFunction;
2481 return Token.None;
2482 }
2483 ScanLiteral(LiteralType.SystemOrPublicID);
2484 _scanningFunction = _nextScaningFunction;
2485 return Token.Literal;
2486 }
2487
2488 private Token ScanCondSection1()
2489 {
2490 if (_chars[_curPos] != 'I')
2491 {
2492 Throw(_curPos, System.SR.Xml_ExpectIgnoreOrInclude);
2493 }
2494 _curPos++;
2495 while (true)
2496 {
2497 if (_charsUsed - _curPos >= 5)
2498 {
2499 char c = _chars[_curPos];
2500 if (c == 'G')
2501 {
2502 if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'O' || _chars[_curPos + 3] != 'R' || _chars[_curPos + 4] != 'E' || XmlCharType.IsNameSingleChar(_chars[_curPos + 5]))
2503 {
2504 break;
2505 }
2506 _nextScaningFunction = ScanningFunction.CondSection3;
2507 _scanningFunction = ScanningFunction.CondSection2;
2508 _curPos += 5;
2509 return Token.IGNORE;
2510 }
2511 if (c != 'N')
2512 {
2513 break;
2514 }
2515 if (_charsUsed - _curPos >= 6)
2516 {
2517 if (_chars[_curPos + 1] != 'C' || _chars[_curPos + 2] != 'L' || _chars[_curPos + 3] != 'U' || _chars[_curPos + 4] != 'D' || _chars[_curPos + 5] != 'E' || XmlCharType.IsNameSingleChar(_chars[_curPos + 6]))
2518 {
2519 break;
2520 }
2521 _nextScaningFunction = ScanningFunction.SubsetContent;
2522 _scanningFunction = ScanningFunction.CondSection2;
2523 _curPos += 6;
2524 return Token.INCLUDE;
2525 }
2526 }
2527 if (ReadData() == 0)
2528 {
2529 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
2530 }
2531 }
2532 Throw(_curPos - 1, System.SR.Xml_ExpectIgnoreOrInclude);
2533 return Token.None;
2534 }
2535
2536 private Token ScanCondSection2()
2537 {
2538 if (_chars[_curPos] != '[')
2539 {
2540 ThrowUnexpectedToken(_curPos, "[");
2541 }
2542 _curPos++;
2543 _scanningFunction = _nextScaningFunction;
2544 return Token.LeftBracket;
2545 }
2546
2547 private Token ScanCondSection3()
2548 {
2549 int num = 0;
2550 while (true)
2551 {
2552 if (XmlCharType.IsTextChar(_chars[_curPos]) && _chars[_curPos] != ']')
2553 {
2554 _curPos++;
2555 continue;
2556 }
2557 switch (_chars[_curPos])
2558 {
2559 case '\t':
2560 case '"':
2561 case '&':
2562 case '\'':
2563 _curPos++;
2564 continue;
2565 case '\n':
2566 _curPos++;
2567 _readerAdapter.OnNewLine(_curPos);
2568 continue;
2569 case '\r':
2570 if (_chars[_curPos + 1] == '\n')
2571 {
2572 _curPos += 2;
2573 }
2574 else
2575 {
2576 if (_curPos + 1 >= _charsUsed && !_readerAdapter.IsEof)
2577 {
2578 break;
2579 }
2580 _curPos++;
2581 }
2582 _readerAdapter.OnNewLine(_curPos);
2583 continue;
2584 case '<':
2585 if (_charsUsed - _curPos >= 3)
2586 {
2587 if (_chars[_curPos + 1] != '!' || _chars[_curPos + 2] != '[')
2588 {
2589 _curPos++;
2590 continue;
2591 }
2592 num++;
2593 _curPos += 3;
2594 continue;
2595 }
2596 break;
2597 case ']':
2598 if (_charsUsed - _curPos < 3)
2599 {
2600 break;
2601 }
2602 if (_chars[_curPos + 1] != ']' || _chars[_curPos + 2] != '>')
2603 {
2604 _curPos++;
2605 continue;
2606 }
2607 if (num > 0)
2608 {
2609 num--;
2610 _curPos += 3;
2611 continue;
2612 }
2613 _curPos += 3;
2614 _scanningFunction = ScanningFunction.SubsetContent;
2615 return Token.CondSectionEnd;
2616 default:
2617 {
2618 if (_curPos == _charsUsed)
2619 {
2620 break;
2621 }
2622 char ch = _chars[_curPos];
2623 if (XmlCharType.IsHighSurrogate(ch))
2624 {
2625 if (_curPos + 1 == _charsUsed)
2626 {
2627 break;
2628 }
2629 _curPos++;
2630 if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
2631 {
2632 _curPos++;
2633 continue;
2634 }
2635 }
2636 ThrowInvalidChar(_chars, _charsUsed, _curPos);
2637 return Token.None;
2638 }
2639 }
2640 if (_readerAdapter.IsEof || ReadData() == 0)
2641 {
2642 if (HandleEntityEnd(inLiteral: false))
2643 {
2644 continue;
2645 }
2646 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
2647 }
2648 _tokenStartPos = _curPos;
2649 }
2650 }
2651
2652 private void ScanName()
2653 {
2654 ScanQName(isQName: false);
2655 }
2656
2657 private void ScanQName()
2658 {
2659 ScanQName(SupportNamespaces);
2660 }
2661
2662 private void ScanQName(bool isQName)
2663 {
2664 _tokenStartPos = _curPos;
2665 int num = -1;
2666 while (true)
2667 {
2668 if (XmlCharType.IsStartNCNameSingleChar(_chars[_curPos]) || _chars[_curPos] == ':')
2669 {
2670 _curPos++;
2671 }
2672 else if (_curPos + 1 >= _charsUsed)
2673 {
2674 if (ReadDataInName())
2675 {
2676 continue;
2677 }
2678 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "Name");
2679 }
2680 else
2681 {
2682 Throw(_curPos, System.SR.Xml_BadStartNameChar, XmlException.BuildCharExceptionArgs(_chars, _charsUsed, _curPos));
2683 }
2684 while (true)
2685 {
2686 if (XmlCharType.IsNCNameSingleChar(_chars[_curPos]))
2687 {
2688 _curPos++;
2689 continue;
2690 }
2691 if (_chars[_curPos] == ':')
2692 {
2693 if (isQName)
2694 {
2695 break;
2696 }
2697 _curPos++;
2698 continue;
2699 }
2700 if (_curPos == _charsUsed)
2701 {
2702 if (ReadDataInName())
2703 {
2704 continue;
2705 }
2706 if (_tokenStartPos == _curPos)
2707 {
2708 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "Name");
2709 }
2710 }
2711 _colonPos = ((num == -1) ? (-1) : (_tokenStartPos + num));
2712 return;
2713 }
2714 if (num != -1)
2715 {
2716 Throw(_curPos, System.SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(':', '\0'));
2717 }
2718 num = _curPos - _tokenStartPos;
2719 _curPos++;
2720 }
2721 }
2722
2723 private bool ReadDataInName()
2724 {
2725 int num = _curPos - _tokenStartPos;
2726 _curPos = _tokenStartPos;
2727 bool result = ReadData() != 0;
2728 _tokenStartPos = _curPos;
2729 _curPos += num;
2730 return result;
2731 }
2732
2733 private void ScanNmtoken()
2734 {
2735 _tokenStartPos = _curPos;
2736 int num;
2737 while (true)
2738 {
2739 if (XmlCharType.IsNCNameSingleChar(_chars[_curPos]) || _chars[_curPos] == ':')
2740 {
2741 _curPos++;
2742 continue;
2743 }
2744 if (_curPos < _charsUsed)
2745 {
2746 if (_curPos - _tokenStartPos == 0)
2747 {
2748 Throw(_curPos, System.SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(_chars, _charsUsed, _curPos));
2749 }
2750 return;
2751 }
2752 num = _curPos - _tokenStartPos;
2753 _curPos = _tokenStartPos;
2754 if (ReadData() == 0)
2755 {
2756 if (num > 0)
2757 {
2758 break;
2759 }
2760 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "NmToken");
2761 }
2762 _tokenStartPos = _curPos;
2763 _curPos += num;
2764 }
2765 _tokenStartPos = _curPos;
2766 _curPos += num;
2767 }
2768
2769 private bool EatPublicKeyword()
2770 {
2771 while (_charsUsed - _curPos < 6)
2772 {
2773 if (ReadData() == 0)
2774 {
2775 return false;
2776 }
2777 }
2778 if (_chars[_curPos + 1] != 'U' || _chars[_curPos + 2] != 'B' || _chars[_curPos + 3] != 'L' || _chars[_curPos + 4] != 'I' || _chars[_curPos + 5] != 'C')
2779 {
2780 return false;
2781 }
2782 _curPos += 6;
2783 return true;
2784 }
2785
2786 private bool EatSystemKeyword()
2787 {
2788 while (_charsUsed - _curPos < 6)
2789 {
2790 if (ReadData() == 0)
2791 {
2792 return false;
2793 }
2794 }
2795 if (_chars[_curPos + 1] != 'Y' || _chars[_curPos + 2] != 'S' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'M')
2796 {
2797 return false;
2798 }
2799 _curPos += 6;
2800 return true;
2801 }
2802
2816
2817 private string GetNameString()
2818 {
2819 return new string(_chars, _tokenStartPos, _curPos - _tokenStartPos);
2820 }
2821
2822 private string GetNmtokenString()
2823 {
2824 return GetNameString();
2825 }
2826
2827 private string GetValue()
2828 {
2829 if (_stringBuilder.Length == 0)
2830 {
2831 return new string(_chars, _tokenStartPos, _curPos - _tokenStartPos - 1);
2832 }
2833 return _stringBuilder.ToString();
2834 }
2835
2836 private string GetValueWithStrippedSpaces()
2837 {
2838 string value = ((_stringBuilder.Length == 0) ? new string(_chars, _tokenStartPos, _curPos - _tokenStartPos - 1) : _stringBuilder.ToString());
2839 return StripSpaces(value);
2840 }
2841
2842 private int ReadData()
2843 {
2844 SaveParsingBuffer();
2845 int result = _readerAdapter.ReadData();
2846 LoadParsingBuffer();
2847 return result;
2848 }
2849
2856
2857 private void SaveParsingBuffer()
2858 {
2859 SaveParsingBuffer(_curPos);
2860 }
2861
2874
2880
2881 private bool HandleEntityReference(XmlQualifiedName entityName, bool paramEntity, bool inLiteral, bool inAttribute)
2882 {
2883 SaveParsingBuffer();
2884 if (paramEntity && ParsingInternalSubset && !ParsingTopLevelMarkup)
2885 {
2886 Throw(_curPos - entityName.Name.Length - 1, System.SR.Xml_InvalidParEntityRef);
2887 }
2888 SchemaEntity schemaEntity = VerifyEntityReference(entityName, paramEntity, mustBeDeclared: true, inAttribute);
2889 if (schemaEntity == null)
2890 {
2891 return false;
2892 }
2893 if (schemaEntity.ParsingInProgress)
2894 {
2895 Throw(_curPos - entityName.Name.Length - 1, paramEntity ? System.SR.Xml_RecursiveParEntity : System.SR.Xml_RecursiveGenEntity, entityName.Name);
2896 }
2897 int entityId;
2898 if (schemaEntity.IsExternal)
2899 {
2900 if (!_readerAdapter.PushEntity(schemaEntity, out entityId))
2901 {
2902 return false;
2903 }
2904 _externalEntitiesDepth++;
2905 }
2906 else
2907 {
2908 if (schemaEntity.Text.Length == 0)
2909 {
2910 return false;
2911 }
2912 if (!_readerAdapter.PushEntity(schemaEntity, out entityId))
2913 {
2914 return false;
2915 }
2916 }
2917 _currentEntityId = entityId;
2918 if (paramEntity && !inLiteral && _scanningFunction != ScanningFunction.ParamEntitySpace)
2919 {
2920 _savedScanningFunction = _scanningFunction;
2921 _scanningFunction = ScanningFunction.ParamEntitySpace;
2922 }
2923 LoadParsingBuffer();
2924 return true;
2925 }
2926
2927 private bool HandleEntityEnd(bool inLiteral)
2928 {
2929 SaveParsingBuffer();
2930 if (!_readerAdapter.PopEntity(out var oldEntity, out _currentEntityId))
2931 {
2932 return false;
2933 }
2934 LoadParsingBuffer();
2935 if (oldEntity == null)
2936 {
2937 if (_scanningFunction == ScanningFunction.ParamEntitySpace)
2938 {
2939 _scanningFunction = _savedScanningFunction;
2940 }
2941 return false;
2942 }
2943 if (oldEntity.IsExternal)
2944 {
2945 _externalEntitiesDepth--;
2946 }
2947 if (!inLiteral && _scanningFunction != ScanningFunction.ParamEntitySpace)
2948 {
2949 _savedScanningFunction = _scanningFunction;
2950 _scanningFunction = ScanningFunction.ParamEntitySpace;
2951 }
2952 return true;
2953 }
2954
2955 private SchemaEntity VerifyEntityReference(XmlQualifiedName entityName, bool paramEntity, bool mustBeDeclared, bool inAttribute)
2956 {
2957 SchemaEntity value;
2958 if (paramEntity)
2959 {
2960 _schemaInfo.ParameterEntities.TryGetValue(entityName, out value);
2961 }
2962 else
2963 {
2964 _schemaInfo.GeneralEntities.TryGetValue(entityName, out value);
2965 }
2966 if (value == null)
2967 {
2968 if (paramEntity)
2969 {
2970 if (_validate)
2971 {
2972 SendValidationEvent(_curPos - entityName.Name.Length - 1, XmlSeverityType.Error, System.SR.Xml_UndeclaredParEntity, entityName.Name);
2973 }
2974 }
2975 else if (mustBeDeclared)
2976 {
2977 if (!ParsingInternalSubset)
2978 {
2979 if (_validate)
2980 {
2981 SendValidationEvent(_curPos - entityName.Name.Length - 1, XmlSeverityType.Error, System.SR.Xml_UndeclaredEntity, entityName.Name);
2982 }
2983 }
2984 else
2985 {
2986 Throw(_curPos - entityName.Name.Length - 1, System.SR.Xml_UndeclaredEntity, entityName.Name);
2987 }
2988 }
2989 return null;
2990 }
2991 if (!value.NData.IsEmpty)
2992 {
2993 Throw(_curPos - entityName.Name.Length - 1, System.SR.Xml_UnparsedEntityRef, entityName.Name);
2994 }
2995 if (inAttribute && value.IsExternal)
2996 {
2997 Throw(_curPos - entityName.Name.Length - 1, System.SR.Xml_ExternalEntityInAttValue, entityName.Name);
2998 }
2999 return value;
3000 }
3001
3002 private void SendValidationEvent(int pos, XmlSeverityType severity, string code, string arg)
3003 {
3004 SendValidationEvent(severity, new XmlSchemaException(code, arg, BaseUriStr, LineNo, LinePos + (pos - _curPos)));
3005 }
3006
3011
3016
3017 private bool IsAttributeValueType(Token token)
3018 {
3019 if (token >= Token.CDATA)
3020 {
3021 return token <= Token.NOTATION;
3022 }
3023 return false;
3024 }
3025
3026 private void OnUnexpectedError()
3027 {
3028 Throw(_curPos, System.SR.Xml_InternalError);
3029 }
3030
3031 private void Throw(int curPos, string res)
3032 {
3033 Throw(curPos, res, string.Empty);
3034 }
3035
3036 [DoesNotReturn]
3037 private void Throw(int curPos, string res, string arg)
3038 {
3039 _curPos = curPos;
3040 Uri baseUri = _readerAdapter.BaseUri;
3041 _readerAdapter.Throw(new XmlException(res, arg, LineNo, LinePos, (baseUri == null) ? null : baseUri.ToString()));
3042 }
3043
3044 [DoesNotReturn]
3045 private void Throw(int curPos, string res, string[] args)
3046 {
3047 _curPos = curPos;
3048 Uri baseUri = _readerAdapter.BaseUri;
3049 _readerAdapter.Throw(new XmlException(res, args, LineNo, LinePos, (baseUri == null) ? null : baseUri.ToString()));
3050 }
3051
3052 [DoesNotReturn]
3053 private void Throw(string res, string arg, int lineNo, int linePos)
3054 {
3055 Uri baseUri = _readerAdapter.BaseUri;
3056 _readerAdapter.Throw(new XmlException(res, arg, lineNo, linePos, (baseUri == null) ? null : baseUri.ToString()));
3057 }
3058
3059 private void ThrowInvalidChar(int pos, string data, int invCharPos)
3060 {
3061 Throw(pos, System.SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(data, invCharPos));
3062 }
3063
3068
3069 private void ThrowUnexpectedToken(int pos, string expectedToken)
3070 {
3071 ThrowUnexpectedToken(pos, expectedToken, null);
3072 }
3073
3074 private void ThrowUnexpectedToken(int pos, string expectedToken1, string expectedToken2)
3075 {
3076 string text = ParseUnexpectedToken(pos);
3077 if (expectedToken2 != null)
3078 {
3079 Throw(_curPos, System.SR.Xml_UnexpectedTokens2, new string[3] { text, expectedToken1, expectedToken2 });
3080 }
3081 else
3082 {
3083 Throw(_curPos, System.SR.Xml_UnexpectedTokenEx, new string[2] { text, expectedToken1 });
3084 }
3085 }
3086
3087 private string ParseUnexpectedToken(int startPos)
3088 {
3089 if (XmlCharType.IsNCNameSingleChar(_chars[startPos]))
3090 {
3091 int i;
3092 for (i = startPos; XmlCharType.IsNCNameSingleChar(_chars[i]); i++)
3093 {
3094 }
3095 int num = i - startPos;
3096 return new string(_chars, startPos, (num <= 0) ? 1 : num);
3097 }
3098 return new string(_chars, startPos, 1);
3099 }
3100
3101 internal static string StripSpaces(string value)
3102 {
3103 int length = value.Length;
3104 if (length <= 0)
3105 {
3106 return string.Empty;
3107 }
3108 int num = 0;
3109 StringBuilder stringBuilder = null;
3110 while (value[num] == ' ')
3111 {
3112 num++;
3113 if (num == length)
3114 {
3115 return " ";
3116 }
3117 }
3118 int i;
3119 for (i = num; i < length; i++)
3120 {
3121 if (value[i] != ' ')
3122 {
3123 continue;
3124 }
3125 int j;
3126 for (j = i + 1; j < length && value[j] == ' '; j++)
3127 {
3128 }
3129 if (j == length)
3130 {
3131 if (stringBuilder == null)
3132 {
3133 return value.Substring(num, i - num);
3134 }
3135 stringBuilder.Append(value, num, i - num);
3136 return stringBuilder.ToString();
3137 }
3138 if (j > i + 1)
3139 {
3140 if (stringBuilder == null)
3141 {
3142 stringBuilder = new StringBuilder(length);
3143 }
3144 stringBuilder.Append(value, num, i - num + 1);
3145 num = j;
3146 i = j - 1;
3147 }
3148 }
3149 if (stringBuilder == null)
3150 {
3151 if (num != 0)
3152 {
3153 return value.Substring(num, length - num);
3154 }
3155 return value;
3156 }
3157 if (i > num)
3158 {
3159 stringBuilder.Append(value, num, i - num);
3160 }
3161 return stringBuilder.ToString();
3162 }
3163
3170
3171 async Task<IDtdInfo> IDtdParser.ParseFreeFloatingDtdAsync(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
3172 {
3173 InitializeFreeFloatingDtd(baseUri, docTypeName, publicId, systemId, internalSubset, adapter);
3174 await ParseAsync(saveInternalSubset: false).ConfigureAwait(continueOnCapturedContext: false);
3175 return _schemaInfo;
3176 }
3177
3178 private async Task ParseAsync(bool saveInternalSubset)
3179 {
3180 if (!_freeFloatingDtd)
3181 {
3182 await ParseInDocumentDtdAsync(saveInternalSubset).ConfigureAwait(continueOnCapturedContext: false);
3183 }
3184 else
3185 {
3186 await ParseFreeFloatingDtdAsync().ConfigureAwait(continueOnCapturedContext: false);
3187 }
3188 _schemaInfo.Finish();
3189 if (!_validate || _undeclaredNotations == null)
3190 {
3191 return;
3192 }
3193 foreach (UndeclaredNotation value in _undeclaredNotations.Values)
3194 {
3195 for (UndeclaredNotation undeclaredNotation = value; undeclaredNotation != null; undeclaredNotation = undeclaredNotation.next)
3196 {
3197 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Sch_UndeclaredNotation, value.name, BaseUriStr, value.lineNo, value.linePos));
3198 }
3199 }
3200 }
3201
3202 private async Task ParseInDocumentDtdAsync(bool saveInternalSubset)
3203 {
3204 LoadParsingBuffer();
3205 _scanningFunction = ScanningFunction.QName;
3206 _nextScaningFunction = ScanningFunction.Doctype1;
3207 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) != Token.QName)
3208 {
3209 OnUnexpectedError();
3210 }
3211 _schemaInfo.DocTypeName = GetNameQualified(canHavePrefix: true);
3212 Token token = await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false);
3213 if (token == Token.SYSTEM || token == Token.PUBLIC)
3214 {
3215 (string, string) tuple = await ParseExternalIdAsync(token, Token.DOCTYPE).ConfigureAwait(continueOnCapturedContext: false);
3216 _publicId = tuple.Item1;
3217 _systemId = tuple.Item2;
3218 token = await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false);
3219 }
3220 switch (token)
3221 {
3222 case Token.LeftBracket:
3223 if (saveInternalSubset)
3224 {
3225 SaveParsingBuffer();
3226 _internalSubsetValueSb = new StringBuilder();
3227 }
3228 await ParseInternalSubsetAsync().ConfigureAwait(continueOnCapturedContext: false);
3229 break;
3230 default:
3231 OnUnexpectedError();
3232 break;
3233 case Token.GreaterThan:
3234 break;
3235 }
3236 SaveParsingBuffer();
3237 if (_systemId != null && _systemId.Length > 0)
3238 {
3239 await ParseExternalSubsetAsync().ConfigureAwait(continueOnCapturedContext: false);
3240 }
3241 }
3242
3243 private async Task ParseFreeFloatingDtdAsync()
3244 {
3245 if (_hasFreeFloatingInternalSubset)
3246 {
3247 LoadParsingBuffer();
3248 await ParseInternalSubsetAsync().ConfigureAwait(continueOnCapturedContext: false);
3249 SaveParsingBuffer();
3250 }
3251 if (_systemId != null && _systemId.Length > 0)
3252 {
3253 await ParseExternalSubsetAsync().ConfigureAwait(continueOnCapturedContext: false);
3254 }
3255 }
3256
3257 private Task ParseInternalSubsetAsync()
3258 {
3259 return ParseSubsetAsync();
3260 }
3261
3262 private async Task ParseExternalSubsetAsync()
3263 {
3264 if (await _readerAdapter.PushExternalSubsetAsync(_systemId, _publicId).ConfigureAwait(continueOnCapturedContext: false))
3265 {
3266 Uri baseUri = _readerAdapter.BaseUri;
3267 if (baseUri != null)
3268 {
3269 _externalDtdBaseUri = baseUri.ToString();
3270 }
3271 _externalEntitiesDepth++;
3272 LoadParsingBuffer();
3273 await ParseSubsetAsync().ConfigureAwait(continueOnCapturedContext: false);
3274 }
3275 }
3276
3277 private async Task ParseSubsetAsync()
3278 {
3279 while (true)
3280 {
3281 Token token = await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false);
3282 int startTagEntityId = _currentEntityId;
3283 switch (token)
3284 {
3285 case Token.AttlistDecl:
3286 await ParseAttlistDeclAsync().ConfigureAwait(continueOnCapturedContext: false);
3287 break;
3288 case Token.ElementDecl:
3289 await ParseElementDeclAsync().ConfigureAwait(continueOnCapturedContext: false);
3290 break;
3291 case Token.EntityDecl:
3292 await ParseEntityDeclAsync().ConfigureAwait(continueOnCapturedContext: false);
3293 break;
3294 case Token.NotationDecl:
3295 await ParseNotationDeclAsync().ConfigureAwait(continueOnCapturedContext: false);
3296 break;
3297 case Token.Comment:
3298 await ParseCommentAsync().ConfigureAwait(continueOnCapturedContext: false);
3299 break;
3300 case Token.PI:
3301 await ParsePIAsync().ConfigureAwait(continueOnCapturedContext: false);
3302 break;
3303 case Token.CondSectionStart:
3304 if (ParsingInternalSubset)
3305 {
3306 Throw(_curPos - 3, System.SR.Xml_InvalidConditionalSection);
3307 }
3308 await ParseCondSectionAsync().ConfigureAwait(continueOnCapturedContext: false);
3309 startTagEntityId = _currentEntityId;
3310 break;
3311 case Token.CondSectionEnd:
3312 if (_condSectionDepth > 0)
3313 {
3314 _condSectionDepth--;
3315 if (_validate && _currentEntityId != _condSectionEntityIds[_condSectionDepth])
3316 {
3317 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3318 }
3319 }
3320 else
3321 {
3322 Throw(_curPos - 3, System.SR.Xml_UnexpectedCDataEnd);
3323 }
3324 break;
3325 case Token.RightBracket:
3326 if (ParsingInternalSubset)
3327 {
3328 if (_condSectionDepth != 0)
3329 {
3330 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
3331 }
3332 if (_internalSubsetValueSb != null)
3333 {
3334 SaveParsingBuffer(_curPos - 1);
3335 _schemaInfo.InternalDtdSubset = _internalSubsetValueSb.ToString();
3336 _internalSubsetValueSb = null;
3337 }
3338 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) != Token.GreaterThan)
3339 {
3340 ThrowUnexpectedToken(_curPos, ">");
3341 }
3342 }
3343 else
3344 {
3345 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
3346 }
3347 return;
3348 case Token.Eof:
3349 if (ParsingInternalSubset && !_freeFloatingDtd)
3350 {
3351 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
3352 }
3353 if (_condSectionDepth != 0)
3354 {
3355 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
3356 }
3357 return;
3358 }
3359 if (_currentEntityId != startTagEntityId)
3360 {
3361 if (_validate)
3362 {
3363 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3364 }
3365 else if (!_v1Compat)
3366 {
3367 Throw(_curPos, System.SR.Sch_ParEntityRefNesting);
3368 }
3369 }
3370 }
3371 }
3372
3373 private async Task ParseAttlistDeclAsync()
3374 {
3375 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) == Token.QName)
3376 {
3377 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
3378 if (!_schemaInfo.ElementDecls.TryGetValue(nameQualified, out var elementDecl) && !_schemaInfo.UndeclaredElementDecls.TryGetValue(nameQualified, out elementDecl))
3379 {
3380 elementDecl = new SchemaElementDecl(nameQualified, nameQualified.Namespace);
3381 _schemaInfo.UndeclaredElementDecls.Add(nameQualified, elementDecl);
3382 }
3383 SchemaAttDef attrDef = null;
3384 while (true)
3385 {
3386 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3387 {
3388 case Token.QName:
3389 {
3390 XmlQualifiedName nameQualified2 = GetNameQualified(canHavePrefix: true);
3391 attrDef = new SchemaAttDef(nameQualified2, nameQualified2.Namespace)
3392 {
3393 IsDeclaredInExternal = !ParsingInternalSubset,
3394 LineNumber = LineNo,
3395 LinePosition = LinePos - (_curPos - _tokenStartPos)
3396 };
3397 bool attrDefAlreadyExists = elementDecl.GetAttDef(attrDef.Name) != null;
3398 await ParseAttlistTypeAsync(attrDef, elementDecl, attrDefAlreadyExists).ConfigureAwait(continueOnCapturedContext: false);
3399 await ParseAttlistDefaultAsync(attrDef, attrDefAlreadyExists).ConfigureAwait(continueOnCapturedContext: false);
3400 if (attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml"))
3401 {
3402 if (attrDef.Name.Name == "space")
3403 {
3404 if (_v1Compat)
3405 {
3406 string text = attrDef.DefaultValueExpanded.Trim();
3407 if (text.Equals("preserve") || text.Equals("default"))
3408 {
3409 attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
3410 }
3411 }
3412 else
3413 {
3414 attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
3415 if (attrDef.TokenizedType != XmlTokenizedType.ENUMERATION)
3416 {
3417 Throw(System.SR.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition);
3418 }
3419 if (_validate)
3420 {
3421 attrDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
3422 }
3423 }
3424 }
3425 else if (attrDef.Name.Name == "lang")
3426 {
3427 attrDef.Reserved = SchemaAttDef.Reserve.XmlLang;
3428 }
3429 }
3430 if (!attrDefAlreadyExists)
3431 {
3432 elementDecl.AddAttDef(attrDef);
3433 }
3434 continue;
3435 }
3436 case Token.GreaterThan:
3437 if (_v1Compat && attrDef != null && attrDef.Prefix.Length > 0 && attrDef.Prefix.Equals("xml") && attrDef.Name.Name == "space")
3438 {
3439 attrDef.Reserved = SchemaAttDef.Reserve.XmlSpace;
3440 if (attrDef.Datatype.TokenizedType != XmlTokenizedType.ENUMERATION)
3441 {
3442 Throw(System.SR.Xml_EnumerationRequired, string.Empty, attrDef.LineNumber, attrDef.LinePosition);
3443 }
3444 if (_validate)
3445 {
3446 attrDef.CheckXmlSpace(_readerAdapterWithValidation.ValidationEventHandling);
3447 }
3448 }
3449 return;
3450 }
3451 break;
3452 }
3453 }
3454 OnUnexpectedError();
3455 }
3456
3457 private async Task ParseAttlistTypeAsync(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
3458 {
3459 Token token = await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false);
3460 if (token != 0)
3461 {
3462 elementDecl.HasNonCDataAttribute = true;
3463 }
3464 if (IsAttributeValueType(token))
3465 {
3466 attrDef.TokenizedType = (XmlTokenizedType)token;
3467 attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
3468 switch (token)
3469 {
3470 default:
3471 return;
3472 case Token.ID:
3473 if (_validate && elementDecl.IsIdDeclared)
3474 {
3475 SchemaAttDef attDef = elementDecl.GetAttDef(attrDef.Name);
3476 if ((attDef == null || attDef.Datatype.TokenizedType != XmlTokenizedType.ID) && !ignoreErrors)
3477 {
3478 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_IdAttrDeclared, elementDecl.Name.ToString());
3479 }
3480 }
3481 elementDecl.IsIdDeclared = true;
3482 return;
3483 case Token.NOTATION:
3484 break;
3485 }
3486 if (_validate)
3487 {
3488 if (elementDecl.IsNotationDeclared && !ignoreErrors)
3489 {
3490 SendValidationEvent(_curPos - 8, XmlSeverityType.Error, System.SR.Sch_DupNotationAttribute, elementDecl.Name.ToString());
3491 }
3492 else
3493 {
3494 if (elementDecl.ContentValidator != null && elementDecl.ContentValidator.ContentType == XmlSchemaContentType.Empty && !ignoreErrors)
3495 {
3496 SendValidationEvent(_curPos - 8, XmlSeverityType.Error, System.SR.Sch_NotationAttributeOnEmptyElement, elementDecl.Name.ToString());
3497 }
3498 elementDecl.IsNotationDeclared = true;
3499 }
3500 }
3501 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) == Token.LeftParen && await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Name)
3502 {
3503 do
3504 {
3505 string nameString = GetNameString();
3506 if (!_schemaInfo.Notations.ContainsKey(nameString))
3507 {
3508 AddUndeclaredNotation(nameString);
3509 }
3510 if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(nameString) && !ignoreErrors)
3511 {
3512 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Xml_AttlistDuplNotationValue, nameString, BaseUriStr, LineNo, LinePos));
3513 }
3514 attrDef.AddValue(nameString);
3515 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3516 {
3517 case Token.Or:
3518 continue;
3519 case Token.RightParen:
3520 return;
3521 }
3522 break;
3523 }
3524 while (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Name);
3525 }
3526 }
3527 else if (token == Token.LeftParen)
3528 {
3529 attrDef.TokenizedType = XmlTokenizedType.ENUMERATION;
3530 attrDef.SchemaType = XmlSchemaType.GetBuiltInSimpleType(attrDef.Datatype.TypeCode);
3531 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Nmtoken)
3532 {
3533 attrDef.AddValue(GetNameString());
3534 while (true)
3535 {
3536 string nmtokenString;
3537 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3538 {
3539 case Token.Or:
3540 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Nmtoken)
3541 {
3542 nmtokenString = GetNmtokenString();
3543 if (_validate && !_v1Compat && attrDef.Values != null && attrDef.Values.Contains(nmtokenString) && !ignoreErrors)
3544 {
3545 SendValidationEvent(XmlSeverityType.Error, new XmlSchemaException(System.SR.Xml_AttlistDuplEnumValue, nmtokenString, BaseUriStr, LineNo, LinePos));
3546 }
3547 goto IL_068c;
3548 }
3549 break;
3550 case Token.RightParen:
3551 return;
3552 }
3553 break;
3554 IL_068c:
3555 attrDef.AddValue(nmtokenString);
3556 }
3557 }
3558 }
3559 OnUnexpectedError();
3560 }
3561
3562 private async Task ParseAttlistDefaultAsync(SchemaAttDef attrDef, bool ignoreErrors)
3563 {
3564 switch (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false))
3565 {
3566 case Token.REQUIRED:
3567 attrDef.Presence = SchemaDeclBase.Use.Required;
3568 return;
3569 case Token.IMPLIED:
3570 attrDef.Presence = SchemaDeclBase.Use.Implied;
3571 return;
3572 case Token.FIXED:
3573 attrDef.Presence = SchemaDeclBase.Use.Fixed;
3574 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) != Token.Literal)
3575 {
3576 break;
3577 }
3578 goto case Token.Literal;
3579 case Token.Literal:
3580 if (_validate && attrDef.Datatype.TokenizedType == XmlTokenizedType.ID && !ignoreErrors)
3581 {
3582 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_AttListPresence, string.Empty);
3583 }
3584 if (attrDef.TokenizedType != 0)
3585 {
3586 attrDef.DefaultValueExpanded = GetValueWithStrippedSpaces();
3587 }
3588 else
3589 {
3590 attrDef.DefaultValueExpanded = GetValue();
3591 }
3592 attrDef.ValueLineNumber = _literalLineInfo.lineNo;
3593 attrDef.ValueLinePosition = _literalLineInfo.linePos + 1;
3594 DtdValidator.SetDefaultTypedValue(attrDef, _readerAdapter);
3595 return;
3596 }
3597 OnUnexpectedError();
3598 }
3599
3600 private async Task ParseElementDeclAsync()
3601 {
3602 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) == Token.QName)
3603 {
3604 SchemaElementDecl elementDecl = null;
3605 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
3606 if (_schemaInfo.ElementDecls.TryGetValue(nameQualified, out elementDecl))
3607 {
3608 if (_validate)
3609 {
3610 SendValidationEvent(_curPos - nameQualified.Name.Length, XmlSeverityType.Error, System.SR.Sch_DupElementDecl, GetNameString());
3611 }
3612 }
3613 else
3614 {
3615 if (_schemaInfo.UndeclaredElementDecls.TryGetValue(nameQualified, out elementDecl))
3616 {
3617 _schemaInfo.UndeclaredElementDecls.Remove(nameQualified);
3618 }
3619 else
3620 {
3621 elementDecl = new SchemaElementDecl(nameQualified, nameQualified.Namespace);
3622 }
3623 _schemaInfo.ElementDecls.Add(nameQualified, elementDecl);
3624 }
3625 elementDecl.IsDeclaredInExternal = !ParsingInternalSubset;
3626 Token token = await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false);
3627 if (token != Token.LeftParen)
3628 {
3629 if (token != Token.ANY)
3630 {
3631 if (token != Token.EMPTY)
3632 {
3633 goto IL_0483;
3634 }
3635 elementDecl.ContentValidator = ContentValidator.Empty;
3636 }
3637 else
3638 {
3639 elementDecl.ContentValidator = ContentValidator.Any;
3640 }
3641 }
3642 else
3643 {
3644 int startParenEntityId = _currentEntityId;
3645 Token token2 = await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false);
3646 if (token2 != Token.None)
3647 {
3648 if (token2 != Token.PCDATA)
3649 {
3650 goto IL_0483;
3651 }
3652 ParticleContentValidator pcv = new ParticleContentValidator(XmlSchemaContentType.Mixed);
3653 pcv.Start();
3654 pcv.OpenGroup();
3655 await ParseElementMixedContentAsync(pcv, startParenEntityId).ConfigureAwait(continueOnCapturedContext: false);
3656 elementDecl.ContentValidator = pcv.Finish(useDFA: true);
3657 }
3658 else
3659 {
3660 ParticleContentValidator pcv = new ParticleContentValidator(XmlSchemaContentType.ElementOnly);
3661 pcv.Start();
3662 pcv.OpenGroup();
3663 await ParseElementOnlyContentAsync(pcv, startParenEntityId).ConfigureAwait(continueOnCapturedContext: false);
3664 elementDecl.ContentValidator = pcv.Finish(useDFA: true);
3665 }
3666 }
3667 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) != Token.GreaterThan)
3668 {
3669 ThrowUnexpectedToken(_curPos, ">");
3670 }
3671 return;
3672 }
3673 goto IL_0483;
3674 IL_0483:
3675 OnUnexpectedError();
3676 }
3677
3678 private async Task ParseElementOnlyContentAsync(ParticleContentValidator pcv, int startParenEntityId)
3679 {
3680 Stack<ParseElementOnlyContent_LocalFrame> localFrames = new Stack<ParseElementOnlyContent_LocalFrame>();
3681 ParseElementOnlyContent_LocalFrame currentFrame = new ParseElementOnlyContent_LocalFrame(startParenEntityId);
3682 localFrames.Push(currentFrame);
3683 while (true)
3684 {
3685 Token token = await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false);
3686 if (token != Token.QName)
3687 {
3688 if (token != Token.LeftParen)
3689 {
3690 if (token != Token.GreaterThan)
3691 {
3692 goto IL_036a;
3693 }
3694 Throw(_curPos, System.SR.Xml_InvalidContentModel);
3695 goto IL_0370;
3696 }
3697 pcv.OpenGroup();
3698 currentFrame = new ParseElementOnlyContent_LocalFrame(_currentEntityId);
3699 localFrames.Push(currentFrame);
3700 continue;
3701 }
3702 pcv.AddName(GetNameQualified(canHavePrefix: true), null);
3703 await ParseHowManyAsync(pcv).ConfigureAwait(continueOnCapturedContext: false);
3704 goto IL_01a2;
3705 IL_036a:
3706 OnUnexpectedError();
3707 goto IL_0370;
3708 IL_02aa:
3709 pcv.CloseGroup();
3710 if (_validate && _currentEntityId != currentFrame.startParenEntityId)
3711 {
3712 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3713 }
3714 await ParseHowManyAsync(pcv).ConfigureAwait(continueOnCapturedContext: false);
3715 goto IL_0370;
3716 IL_026d:
3717 if (currentFrame.parsingSchema == Token.Comma)
3718 {
3719 Throw(_curPos, System.SR.Xml_InvalidContentModel);
3720 }
3721 pcv.AddChoice();
3722 currentFrame.parsingSchema = Token.Or;
3723 continue;
3724 IL_0370:
3725 localFrames.Pop();
3726 if (localFrames.Count > 0)
3727 {
3728 currentFrame = localFrames.Peek();
3729 goto IL_01a2;
3730 }
3731 break;
3732 IL_0357:
3733 Throw(_curPos, System.SR.Xml_InvalidContentModel);
3734 goto IL_0370;
3735 IL_01a2:
3736 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3737 {
3738 case Token.Comma:
3739 break;
3740 case Token.Or:
3741 goto IL_026d;
3742 case Token.RightParen:
3743 goto IL_02aa;
3744 case Token.GreaterThan:
3745 goto IL_0357;
3746 default:
3747 goto IL_036a;
3748 }
3749 if (currentFrame.parsingSchema == Token.Or)
3750 {
3751 Throw(_curPos, System.SR.Xml_InvalidContentModel);
3752 }
3753 pcv.AddSequence();
3754 currentFrame.parsingSchema = Token.Comma;
3755 }
3756 }
3757
3758 private async Task ParseHowManyAsync(ParticleContentValidator pcv)
3759 {
3760 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3761 {
3762 case Token.Star:
3763 pcv.AddStar();
3764 break;
3765 case Token.QMark:
3766 pcv.AddQMark();
3767 break;
3768 case Token.Plus:
3769 pcv.AddPlus();
3770 break;
3771 }
3772 }
3773
3774 private async Task ParseElementMixedContentAsync(ParticleContentValidator pcv, int startParenEntityId)
3775 {
3776 bool hasNames = false;
3777 int connectorEntityId = -1;
3778 int contentEntityId = _currentEntityId;
3779 while (true)
3780 {
3781 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
3782 {
3783 case Token.RightParen:
3784 pcv.CloseGroup();
3785 if (_validate && _currentEntityId != startParenEntityId)
3786 {
3787 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3788 }
3789 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Star && hasNames)
3790 {
3791 pcv.AddStar();
3792 }
3793 else if (hasNames)
3794 {
3795 ThrowUnexpectedToken(_curPos, "*");
3796 }
3797 return;
3798 case Token.Or:
3799 {
3800 if (!hasNames)
3801 {
3802 hasNames = true;
3803 }
3804 else
3805 {
3806 pcv.AddChoice();
3807 }
3808 if (_validate)
3809 {
3810 connectorEntityId = _currentEntityId;
3811 if (contentEntityId < connectorEntityId)
3812 {
3813 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3814 }
3815 }
3816 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) != Token.QName)
3817 {
3818 break;
3819 }
3820 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: true);
3821 if (pcv.Exists(nameQualified) && _validate)
3822 {
3823 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_DupElement, nameQualified.ToString());
3824 }
3825 pcv.AddName(nameQualified, null);
3826 if (_validate)
3827 {
3828 contentEntityId = _currentEntityId;
3829 if (contentEntityId < connectorEntityId)
3830 {
3831 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
3832 }
3833 }
3834 continue;
3835 }
3836 }
3837 OnUnexpectedError();
3838 }
3839 }
3840
3841 private async Task ParseEntityDeclAsync()
3842 {
3843 bool isParamEntity = false;
3844 Token token = await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false);
3845 if (token == Token.Name)
3846 {
3847 goto IL_013a;
3848 }
3849 if (token == Token.Percent)
3850 {
3851 isParamEntity = true;
3852 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) == Token.Name)
3853 {
3854 goto IL_013a;
3855 }
3856 }
3857 goto IL_0552;
3858 IL_013a:
3859 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: false);
3860 SchemaEntity entity = new SchemaEntity(nameQualified, isParamEntity)
3861 {
3862 BaseURI = BaseUriStr,
3863 DeclaredURI = ((_externalDtdBaseUri.Length == 0) ? _documentBaseUri : _externalDtdBaseUri)
3864 };
3865 if (isParamEntity)
3866 {
3867 if (!_schemaInfo.ParameterEntities.ContainsKey(nameQualified))
3868 {
3869 _schemaInfo.ParameterEntities.Add(nameQualified, entity);
3870 }
3871 }
3872 else if (!_schemaInfo.GeneralEntities.ContainsKey(nameQualified))
3873 {
3874 _schemaInfo.GeneralEntities.Add(nameQualified, entity);
3875 }
3876 entity.DeclaredInExternal = !ParsingInternalSubset;
3877 entity.ParsingInProgress = true;
3878 Token token2 = await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false);
3879 if ((uint)(token2 - 33) > 1u)
3880 {
3881 if (token2 != Token.Literal)
3882 {
3883 goto IL_0552;
3884 }
3885 entity.Text = GetValue();
3886 entity.Line = _literalLineInfo.lineNo;
3887 entity.Pos = _literalLineInfo.linePos;
3888 }
3889 else
3890 {
3891 (string, string) tuple = await ParseExternalIdAsync(token2, Token.EntityDecl).ConfigureAwait(continueOnCapturedContext: false);
3892 string item = tuple.Item1;
3893 string item2 = tuple.Item2;
3894 entity.IsExternal = true;
3895 entity.Url = item2;
3896 entity.Pubid = item;
3897 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.NData)
3898 {
3899 if (isParamEntity)
3900 {
3901 ThrowUnexpectedToken(_curPos - 5, ">");
3902 }
3903 if (!_whitespaceSeen)
3904 {
3905 Throw(_curPos - 5, System.SR.Xml_ExpectingWhiteSpace, "NDATA");
3906 }
3907 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) != Token.Name)
3908 {
3909 goto IL_0552;
3910 }
3911 entity.NData = GetNameQualified(canHavePrefix: false);
3912 string name = entity.NData.Name;
3913 if (!_schemaInfo.Notations.ContainsKey(name))
3914 {
3915 AddUndeclaredNotation(name);
3916 }
3917 }
3918 }
3919 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.GreaterThan)
3920 {
3921 entity.ParsingInProgress = false;
3922 return;
3923 }
3924 goto IL_0552;
3925 IL_0552:
3926 OnUnexpectedError();
3927 }
3928
3929 private async Task ParseNotationDeclAsync()
3930 {
3931 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) != Token.Name)
3932 {
3933 OnUnexpectedError();
3934 }
3935 XmlQualifiedName nameQualified = GetNameQualified(canHavePrefix: false);
3936 SchemaNotation notation = null;
3937 if (!_schemaInfo.Notations.ContainsKey(nameQualified.Name))
3938 {
3939 if (_undeclaredNotations != null)
3940 {
3941 _undeclaredNotations.Remove(nameQualified.Name);
3942 }
3943 notation = new SchemaNotation(nameQualified);
3944 _schemaInfo.Notations.Add(notation.Name.Name, notation);
3945 }
3946 else if (_validate)
3947 {
3948 SendValidationEvent(_curPos - nameQualified.Name.Length, XmlSeverityType.Error, System.SR.Sch_DupNotation, nameQualified.Name);
3949 }
3950 Token token = await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false);
3951 if (token == Token.SYSTEM || token == Token.PUBLIC)
3952 {
3953 var (pubid, systemLiteral) = await ParseExternalIdAsync(token, Token.NOTATION).ConfigureAwait(continueOnCapturedContext: false);
3954 if (notation != null)
3955 {
3956 notation.SystemLiteral = systemLiteral;
3957 notation.Pubid = pubid;
3958 }
3959 }
3960 else
3961 {
3962 OnUnexpectedError();
3963 }
3964 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) != Token.GreaterThan)
3965 {
3966 OnUnexpectedError();
3967 }
3968 }
3969
3970 private async Task ParseCommentAsync()
3971 {
3972 SaveParsingBuffer();
3973 try
3974 {
3975 if (!SaveInternalSubsetValue)
3976 {
3977 await _readerAdapter.ParseCommentAsync(null).ConfigureAwait(continueOnCapturedContext: false);
3978 }
3979 else
3980 {
3981 await _readerAdapter.ParseCommentAsync(_internalSubsetValueSb).ConfigureAwait(continueOnCapturedContext: false);
3982 _internalSubsetValueSb.Append("-->");
3983 }
3984 }
3985 catch (XmlException ex)
3986 {
3987 if (!(ex.ResString == System.SR.Xml_UnexpectedEOF) || _currentEntityId == 0)
3988 {
3989 throw;
3990 }
3991 SendValidationEvent(XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, null);
3992 }
3993 LoadParsingBuffer();
3994 }
3995
4010
4011 private async Task ParseCondSectionAsync()
4012 {
4013 int csEntityId = _currentEntityId;
4014 switch (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false))
4015 {
4016 case Token.INCLUDE:
4017 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.LeftBracket)
4018 {
4019 if (_validate && csEntityId != _currentEntityId)
4020 {
4021 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
4022 }
4023 if (_validate)
4024 {
4025 if (_condSectionEntityIds == null)
4026 {
4027 _condSectionEntityIds = new int[2];
4028 }
4029 else if (_condSectionEntityIds.Length == _condSectionDepth)
4030 {
4031 int[] array = new int[_condSectionEntityIds.Length * 2];
4032 Array.Copy(_condSectionEntityIds, array, _condSectionEntityIds.Length);
4033 _condSectionEntityIds = array;
4034 }
4035 _condSectionEntityIds[_condSectionDepth] = csEntityId;
4036 }
4037 _condSectionDepth++;
4038 break;
4039 }
4040 goto default;
4041 case Token.IGNORE:
4042 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.LeftBracket)
4043 {
4044 if (_validate && csEntityId != _currentEntityId)
4045 {
4046 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
4047 }
4048 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.CondSectionEnd)
4049 {
4050 if (_validate && csEntityId != _currentEntityId)
4051 {
4052 SendValidationEvent(_curPos, XmlSeverityType.Error, System.SR.Sch_ParEntityRefNesting, string.Empty);
4053 }
4054 break;
4055 }
4056 }
4057 goto default;
4058 default:
4059 OnUnexpectedError();
4060 break;
4061 }
4062 }
4063
4064 private async Task<(string, string)> ParseExternalIdAsync(Token idTokenType, Token declType)
4065 {
4066 LineInfo keywordLineInfo = new LineInfo(LineNo, LinePos - 6);
4067 string publicId = null;
4068 string systemId = null;
4069 if (await GetTokenAsync(needWhiteSpace: true).ConfigureAwait(continueOnCapturedContext: false) != Token.Literal)
4070 {
4071 ThrowUnexpectedToken(_curPos, "\"", "'");
4072 }
4073 if (idTokenType == Token.SYSTEM)
4074 {
4075 systemId = GetValue();
4076 if (systemId.Contains('#'))
4077 {
4078 Throw(_curPos - systemId.Length - 1, System.SR.Xml_FragmentId, new string[2]
4079 {
4080 systemId.Substring(systemId.IndexOf('#')),
4081 systemId
4082 });
4083 }
4084 if (declType == Token.DOCTYPE && !_freeFloatingDtd)
4085 {
4086 _literalLineInfo.linePos++;
4087 _readerAdapter.OnSystemId(systemId, keywordLineInfo, _literalLineInfo);
4088 }
4089 }
4090 else
4091 {
4092 publicId = GetValue();
4093 int num;
4094 if ((num = XmlCharType.IsPublicId(publicId)) >= 0)
4095 {
4096 ThrowInvalidChar(_curPos - 1 - publicId.Length + num, publicId, num);
4097 }
4098 if (declType == Token.DOCTYPE && !_freeFloatingDtd)
4099 {
4100 _literalLineInfo.linePos++;
4101 _readerAdapter.OnPublicId(publicId, keywordLineInfo, _literalLineInfo);
4102 if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Literal)
4103 {
4104 if (!_whitespaceSeen)
4105 {
4106 Throw(System.SR.Xml_ExpectingWhiteSpace, char.ToString(_literalQuoteChar), _literalLineInfo.lineNo, _literalLineInfo.linePos);
4107 }
4108 systemId = GetValue();
4109 _literalLineInfo.linePos++;
4110 _readerAdapter.OnSystemId(systemId, keywordLineInfo, _literalLineInfo);
4111 }
4112 else
4113 {
4114 ThrowUnexpectedToken(_curPos, "\"", "'");
4115 }
4116 }
4117 else if (await GetTokenAsync(needWhiteSpace: false).ConfigureAwait(continueOnCapturedContext: false) == Token.Literal)
4118 {
4119 if (!_whitespaceSeen)
4120 {
4121 Throw(System.SR.Xml_ExpectingWhiteSpace, char.ToString(_literalQuoteChar), _literalLineInfo.lineNo, _literalLineInfo.linePos);
4122 }
4123 systemId = GetValue();
4124 }
4125 else if (declType != Token.NOTATION)
4126 {
4127 ThrowUnexpectedToken(_curPos, "\"", "'");
4128 }
4129 }
4130 return (publicId, systemId);
4131 }
4132
4133 private async Task<Token> GetTokenAsync(bool needWhiteSpace)
4134 {
4135 _whitespaceSeen = false;
4136 while (true)
4137 {
4138 switch (_chars[_curPos])
4139 {
4140 case '\0':
4141 if (_curPos != _charsUsed)
4142 {
4143 ThrowInvalidChar(_chars, _charsUsed, _curPos);
4144 }
4145 break;
4146 case '\n':
4147 _whitespaceSeen = true;
4148 _curPos++;
4149 _readerAdapter.OnNewLine(_curPos);
4150 continue;
4151 case '\r':
4152 _whitespaceSeen = true;
4153 if (_chars[_curPos + 1] == '\n')
4154 {
4155 if (Normalize)
4156 {
4157 SaveParsingBuffer();
4158 _readerAdapter.CurrentPosition++;
4159 }
4160 _curPos += 2;
4161 }
4162 else
4163 {
4164 if (_curPos + 1 >= _charsUsed && !_readerAdapter.IsEof)
4165 {
4166 break;
4167 }
4168 _chars[_curPos] = '\n';
4169 _curPos++;
4170 }
4171 _readerAdapter.OnNewLine(_curPos);
4172 continue;
4173 case '\t':
4174 case ' ':
4175 _whitespaceSeen = true;
4176 _curPos++;
4177 continue;
4178 case '%':
4179 if (_charsUsed - _curPos < 2)
4180 {
4181 break;
4182 }
4183 if (!XmlCharType.IsWhiteSpace(_chars[_curPos + 1]))
4184 {
4185 if (IgnoreEntityReferences)
4186 {
4187 _curPos++;
4188 }
4189 else
4190 {
4191 await HandleEntityReferenceAsync(paramEntity: true, inLiteral: false, inAttribute: false).ConfigureAwait(continueOnCapturedContext: false);
4192 }
4193 continue;
4194 }
4195 goto default;
4196 default:
4197 if (needWhiteSpace && !_whitespaceSeen && _scanningFunction != ScanningFunction.ParamEntitySpace)
4198 {
4199 Throw(_curPos, System.SR.Xml_ExpectingWhiteSpace, ParseUnexpectedToken(_curPos));
4200 }
4201 _tokenStartPos = _curPos;
4202 while (true)
4203 {
4204 switch (_scanningFunction)
4205 {
4206 case ScanningFunction.Name:
4207 return await ScanNameExpectedAsync().ConfigureAwait(continueOnCapturedContext: false);
4208 case ScanningFunction.QName:
4209 return await ScanQNameExpectedAsync().ConfigureAwait(continueOnCapturedContext: false);
4210 case ScanningFunction.Nmtoken:
4211 return await ScanNmtokenExpectedAsync().ConfigureAwait(continueOnCapturedContext: false);
4212 case ScanningFunction.SubsetContent:
4213 return await ScanSubsetContentAsync().ConfigureAwait(continueOnCapturedContext: false);
4214 case ScanningFunction.Doctype1:
4215 return await ScanDoctype1Async().ConfigureAwait(continueOnCapturedContext: false);
4216 case ScanningFunction.Doctype2:
4217 return ScanDoctype2();
4218 case ScanningFunction.Element1:
4219 return await ScanElement1Async().ConfigureAwait(continueOnCapturedContext: false);
4220 case ScanningFunction.Element2:
4221 return await ScanElement2Async().ConfigureAwait(continueOnCapturedContext: false);
4222 case ScanningFunction.Element3:
4223 return await ScanElement3Async().ConfigureAwait(continueOnCapturedContext: false);
4224 case ScanningFunction.Element4:
4225 return ScanElement4();
4226 case ScanningFunction.Element5:
4227 return ScanElement5();
4228 case ScanningFunction.Element6:
4229 return ScanElement6();
4230 case ScanningFunction.Element7:
4231 return ScanElement7();
4232 case ScanningFunction.Attlist1:
4233 return await ScanAttlist1Async().ConfigureAwait(continueOnCapturedContext: false);
4234 case ScanningFunction.Attlist2:
4235 return await ScanAttlist2Async().ConfigureAwait(continueOnCapturedContext: false);
4236 case ScanningFunction.Attlist3:
4237 return ScanAttlist3();
4238 case ScanningFunction.Attlist4:
4239 return ScanAttlist4();
4240 case ScanningFunction.Attlist5:
4241 return ScanAttlist5();
4242 case ScanningFunction.Attlist6:
4243 return await ScanAttlist6Async().ConfigureAwait(continueOnCapturedContext: false);
4244 case ScanningFunction.Attlist7:
4245 return ScanAttlist7();
4246 case ScanningFunction.Notation1:
4247 return await ScanNotation1Async().ConfigureAwait(continueOnCapturedContext: false);
4248 case ScanningFunction.SystemId:
4249 return await ScanSystemIdAsync().ConfigureAwait(continueOnCapturedContext: false);
4250 case ScanningFunction.PublicId1:
4251 return await ScanPublicId1Async().ConfigureAwait(continueOnCapturedContext: false);
4252 case ScanningFunction.PublicId2:
4253 return await ScanPublicId2Async().ConfigureAwait(continueOnCapturedContext: false);
4254 case ScanningFunction.Entity1:
4255 return await ScanEntity1Async().ConfigureAwait(continueOnCapturedContext: false);
4256 case ScanningFunction.Entity2:
4257 return await ScanEntity2Async().ConfigureAwait(continueOnCapturedContext: false);
4258 case ScanningFunction.Entity3:
4259 return await ScanEntity3Async().ConfigureAwait(continueOnCapturedContext: false);
4260 case ScanningFunction.CondSection1:
4261 return await ScanCondSection1Async().ConfigureAwait(continueOnCapturedContext: false);
4262 case ScanningFunction.CondSection2:
4263 return ScanCondSection2();
4264 case ScanningFunction.CondSection3:
4265 return await ScanCondSection3Async().ConfigureAwait(continueOnCapturedContext: false);
4266 case ScanningFunction.ClosingTag:
4267 return ScanClosingTag();
4268 case ScanningFunction.ParamEntitySpace:
4269 break;
4270 default:
4271 return Token.None;
4272 }
4273 _whitespaceSeen = true;
4274 _scanningFunction = _savedScanningFunction;
4275 }
4276 }
4277 bool isEof = _readerAdapter.IsEof;
4278 bool flag = isEof;
4279 if (!flag)
4280 {
4281 flag = await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0;
4282 }
4283 if (flag && !HandleEntityEnd(inLiteral: false))
4284 {
4285 if (_scanningFunction == ScanningFunction.SubsetContent)
4286 {
4287 break;
4288 }
4289 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
4290 }
4291 }
4292 return Token.Eof;
4293 }
4294
4295 private async Task<Token> ScanSubsetContentAsync()
4296 {
4297 while (true)
4298 {
4299 char c = _chars[_curPos];
4300 if (c != '<')
4301 {
4302 if (c != ']')
4303 {
4304 goto IL_0548;
4305 }
4306 if (_charsUsed - _curPos >= 2 || _readerAdapter.IsEof)
4307 {
4308 if (_chars[_curPos + 1] != ']')
4309 {
4310 _curPos++;
4311 _scanningFunction = ScanningFunction.ClosingTag;
4312 return Token.RightBracket;
4313 }
4314 if (_charsUsed - _curPos >= 3 || _readerAdapter.IsEof)
4315 {
4316 if (_chars[_curPos + 1] == ']' && _chars[_curPos + 2] == '>')
4317 {
4318 break;
4319 }
4320 goto IL_0548;
4321 }
4322 }
4323 }
4324 else
4325 {
4326 switch (_chars[_curPos + 1])
4327 {
4328 case '!':
4329 switch (_chars[_curPos + 2])
4330 {
4331 case 'E':
4332 if (_chars[_curPos + 3] == 'L')
4333 {
4334 if (_charsUsed - _curPos >= 9)
4335 {
4336 if (_chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'M' || _chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'N' || _chars[_curPos + 8] != 'T')
4337 {
4338 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4339 }
4340 _curPos += 9;
4341 _scanningFunction = ScanningFunction.QName;
4342 _nextScaningFunction = ScanningFunction.Element1;
4343 return Token.ElementDecl;
4344 }
4345 }
4346 else if (_chars[_curPos + 3] == 'N')
4347 {
4348 if (_charsUsed - _curPos >= 8)
4349 {
4350 if (_chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'T' || _chars[_curPos + 7] != 'Y')
4351 {
4352 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4353 }
4354 _curPos += 8;
4355 _scanningFunction = ScanningFunction.Entity1;
4356 return Token.EntityDecl;
4357 }
4358 }
4359 else if (_charsUsed - _curPos >= 4)
4360 {
4361 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4362 return Token.None;
4363 }
4364 break;
4365 case 'A':
4366 if (_charsUsed - _curPos >= 9)
4367 {
4368 if (_chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'L' || _chars[_curPos + 6] != 'I' || _chars[_curPos + 7] != 'S' || _chars[_curPos + 8] != 'T')
4369 {
4370 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4371 }
4372 _curPos += 9;
4373 _scanningFunction = ScanningFunction.QName;
4374 _nextScaningFunction = ScanningFunction.Attlist1;
4375 return Token.AttlistDecl;
4376 }
4377 break;
4378 case 'N':
4379 if (_charsUsed - _curPos >= 10)
4380 {
4381 if (_chars[_curPos + 3] != 'O' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'A' || _chars[_curPos + 6] != 'T' || _chars[_curPos + 7] != 'I' || _chars[_curPos + 8] != 'O' || _chars[_curPos + 9] != 'N')
4382 {
4383 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4384 }
4385 _curPos += 10;
4386 _scanningFunction = ScanningFunction.Name;
4387 _nextScaningFunction = ScanningFunction.Notation1;
4388 return Token.NotationDecl;
4389 }
4390 break;
4391 case '[':
4392 _curPos += 3;
4393 _scanningFunction = ScanningFunction.CondSection1;
4394 return Token.CondSectionStart;
4395 case '-':
4396 if (_chars[_curPos + 3] == '-')
4397 {
4398 _curPos += 4;
4399 return Token.Comment;
4400 }
4401 if (_charsUsed - _curPos >= 4)
4402 {
4403 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4404 }
4405 break;
4406 default:
4407 if (_charsUsed - _curPos >= 3)
4408 {
4409 Throw(_curPos + 2, System.SR.Xml_ExpectDtdMarkup);
4410 }
4411 break;
4412 }
4413 break;
4414 case '?':
4415 _curPos += 2;
4416 return Token.PI;
4417 default:
4418 if (_charsUsed - _curPos >= 2)
4419 {
4420 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4421 return Token.None;
4422 }
4423 break;
4424 }
4425 }
4426 goto IL_0568;
4427 IL_0568:
4428 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
4429 {
4430 Throw(_charsUsed, System.SR.Xml_IncompleteDtdContent);
4431 }
4432 continue;
4433 IL_0548:
4434 if (_charsUsed - _curPos != 0)
4435 {
4436 Throw(_curPos, System.SR.Xml_ExpectDtdMarkup);
4437 }
4438 goto IL_0568;
4439 }
4440 _curPos += 3;
4441 return Token.CondSectionEnd;
4442 }
4443
4450
4457
4458 private async Task<Token> ScanNmtokenExpectedAsync()
4459 {
4460 await ScanNmtokenAsync().ConfigureAwait(continueOnCapturedContext: false);
4461 _scanningFunction = _nextScaningFunction;
4462 return Token.Nmtoken;
4463 }
4464
4465 private async Task<Token> ScanDoctype1Async()
4466 {
4467 switch (_chars[_curPos])
4468 {
4469 case 'P':
4470 if (!(await EatPublicKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
4471 {
4472 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
4473 }
4474 _nextScaningFunction = ScanningFunction.Doctype2;
4475 _scanningFunction = ScanningFunction.PublicId1;
4476 return Token.PUBLIC;
4477 case 'S':
4478 if (!(await EatSystemKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
4479 {
4480 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
4481 }
4482 _nextScaningFunction = ScanningFunction.Doctype2;
4483 _scanningFunction = ScanningFunction.SystemId;
4484 return Token.SYSTEM;
4485 case '[':
4486 _curPos++;
4487 _scanningFunction = ScanningFunction.SubsetContent;
4488 return Token.LeftBracket;
4489 case '>':
4490 _curPos++;
4491 _scanningFunction = ScanningFunction.SubsetContent;
4492 return Token.GreaterThan;
4493 default:
4494 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
4495 return Token.None;
4496 }
4497 }
4498
4499 private async Task<Token> ScanElement1Async()
4500 {
4501 while (true)
4502 {
4503 char c = _chars[_curPos];
4504 if (c != '(')
4505 {
4506 if (c != 'A')
4507 {
4508 if (c == 'E')
4509 {
4510 if (_charsUsed - _curPos < 5)
4511 {
4512 goto IL_0141;
4513 }
4514 if (_chars[_curPos + 1] == 'M' && _chars[_curPos + 2] == 'P' && _chars[_curPos + 3] == 'T' && _chars[_curPos + 4] == 'Y')
4515 {
4516 _curPos += 5;
4517 _scanningFunction = ScanningFunction.ClosingTag;
4518 return Token.EMPTY;
4519 }
4520 }
4521 }
4522 else
4523 {
4524 if (_charsUsed - _curPos < 3)
4525 {
4526 goto IL_0141;
4527 }
4528 if (_chars[_curPos + 1] == 'N' && _chars[_curPos + 2] == 'Y')
4529 {
4530 break;
4531 }
4532 }
4533 Throw(_curPos, System.SR.Xml_InvalidContentModel);
4534 goto IL_0141;
4535 }
4536 _scanningFunction = ScanningFunction.Element2;
4537 _curPos++;
4538 return Token.LeftParen;
4539 IL_0141:
4540 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
4541 {
4542 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
4543 }
4544 }
4545 _curPos += 3;
4546 _scanningFunction = ScanningFunction.ClosingTag;
4547 return Token.ANY;
4548 }
4549
4550 private async Task<Token> ScanElement2Async()
4551 {
4552 if (_chars[_curPos] == '#')
4553 {
4554 while (_charsUsed - _curPos < 7)
4555 {
4556 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
4557 {
4558 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
4559 }
4560 }
4561 if (_chars[_curPos + 1] == 'P' && _chars[_curPos + 2] == 'C' && _chars[_curPos + 3] == 'D' && _chars[_curPos + 4] == 'A' && _chars[_curPos + 5] == 'T' && _chars[_curPos + 6] == 'A')
4562 {
4563 _curPos += 7;
4564 _scanningFunction = ScanningFunction.Element6;
4565 return Token.PCDATA;
4566 }
4567 Throw(_curPos + 1, System.SR.Xml_ExpectPcData);
4568 }
4569 _scanningFunction = ScanningFunction.Element3;
4570 return Token.None;
4571 }
4572
4573 private async Task<Token> ScanElement3Async()
4574 {
4575 switch (_chars[_curPos])
4576 {
4577 case '(':
4578 _curPos++;
4579 return Token.LeftParen;
4580 case '>':
4581 _curPos++;
4582 _scanningFunction = ScanningFunction.SubsetContent;
4583 return Token.GreaterThan;
4584 default:
4585 await ScanQNameAsync().ConfigureAwait(continueOnCapturedContext: false);
4586 _scanningFunction = ScanningFunction.Element4;
4587 return Token.QName;
4588 }
4589 }
4590
4591 private async Task<Token> ScanAttlist1Async()
4592 {
4593 char c = _chars[_curPos];
4594 if (c == '>')
4595 {
4596 _curPos++;
4597 _scanningFunction = ScanningFunction.SubsetContent;
4598 return Token.GreaterThan;
4599 }
4600 if (!_whitespaceSeen)
4601 {
4602 Throw(_curPos, System.SR.Xml_ExpectingWhiteSpace, ParseUnexpectedToken(_curPos));
4603 }
4604 await ScanQNameAsync().ConfigureAwait(continueOnCapturedContext: false);
4605 _scanningFunction = ScanningFunction.Attlist2;
4606 return Token.QName;
4607 }
4608
4609 private async Task<Token> ScanAttlist2Async()
4610 {
4611 while (true)
4612 {
4613 switch (_chars[_curPos])
4614 {
4615 case '(':
4616 _curPos++;
4617 _scanningFunction = ScanningFunction.Nmtoken;
4618 _nextScaningFunction = ScanningFunction.Attlist5;
4619 return Token.LeftParen;
4620 case 'C':
4621 if (_charsUsed - _curPos >= 5)
4622 {
4623 if (_chars[_curPos + 1] != 'D' || _chars[_curPos + 2] != 'A' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'A')
4624 {
4625 Throw(_curPos, System.SR.Xml_InvalidAttributeType1);
4626 }
4627 _curPos += 5;
4628 _scanningFunction = ScanningFunction.Attlist6;
4629 return Token.CDATA;
4630 }
4631 break;
4632 case 'E':
4633 if (_charsUsed - _curPos < 9)
4634 {
4635 break;
4636 }
4637 _scanningFunction = ScanningFunction.Attlist6;
4638 if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'I' || _chars[_curPos + 4] != 'T')
4639 {
4640 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4641 }
4642 switch (_chars[_curPos + 5])
4643 {
4644 case 'I':
4645 if (_chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'S')
4646 {
4647 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4648 }
4649 _curPos += 8;
4650 return Token.ENTITIES;
4651 case 'Y':
4652 _curPos += 6;
4653 return Token.ENTITY;
4654 }
4655 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4656 break;
4657 case 'I':
4658 if (_charsUsed - _curPos >= 6)
4659 {
4660 _scanningFunction = ScanningFunction.Attlist6;
4661 if (_chars[_curPos + 1] != 'D')
4662 {
4663 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4664 }
4665 if (_chars[_curPos + 2] != 'R')
4666 {
4667 _curPos += 2;
4668 return Token.ID;
4669 }
4670 if (_chars[_curPos + 3] != 'E' || _chars[_curPos + 4] != 'F')
4671 {
4672 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4673 }
4674 if (_chars[_curPos + 5] != 'S')
4675 {
4676 _curPos += 5;
4677 return Token.IDREF;
4678 }
4679 _curPos += 6;
4680 return Token.IDREFS;
4681 }
4682 break;
4683 case 'N':
4684 if (_charsUsed - _curPos < 8 && !_readerAdapter.IsEof)
4685 {
4686 break;
4687 }
4688 switch (_chars[_curPos + 1])
4689 {
4690 case 'O':
4691 if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'A' || _chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'O' || _chars[_curPos + 7] != 'N')
4692 {
4693 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4694 }
4695 _curPos += 8;
4696 _scanningFunction = ScanningFunction.Attlist3;
4697 return Token.NOTATION;
4698 case 'M':
4699 if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'O' || _chars[_curPos + 4] != 'K' || _chars[_curPos + 5] != 'E' || _chars[_curPos + 6] != 'N')
4700 {
4701 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4702 }
4703 _scanningFunction = ScanningFunction.Attlist6;
4704 if (_chars[_curPos + 7] == 'S')
4705 {
4706 _curPos += 8;
4707 return Token.NMTOKENS;
4708 }
4709 _curPos += 7;
4710 return Token.NMTOKEN;
4711 }
4712 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4713 break;
4714 default:
4715 Throw(_curPos, System.SR.Xml_InvalidAttributeType);
4716 break;
4717 }
4718 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
4719 {
4720 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
4721 }
4722 }
4723 }
4724
4725 private async Task<Token> ScanAttlist6Async()
4726 {
4727 while (true)
4728 {
4729 switch (_chars[_curPos])
4730 {
4731 case '"':
4732 case '\'':
4733 await ScanLiteralAsync(LiteralType.AttributeValue).ConfigureAwait(continueOnCapturedContext: false);
4734 _scanningFunction = ScanningFunction.Attlist1;
4735 return Token.Literal;
4736 case '#':
4737 if (_charsUsed - _curPos < 6)
4738 {
4739 break;
4740 }
4741 switch (_chars[_curPos + 1])
4742 {
4743 case 'R':
4744 if (_charsUsed - _curPos >= 9)
4745 {
4746 if (_chars[_curPos + 2] != 'E' || _chars[_curPos + 3] != 'Q' || _chars[_curPos + 4] != 'U' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'R' || _chars[_curPos + 7] != 'E' || _chars[_curPos + 8] != 'D')
4747 {
4748 Throw(_curPos, System.SR.Xml_ExpectAttType);
4749 }
4750 _curPos += 9;
4751 _scanningFunction = ScanningFunction.Attlist1;
4752 return Token.REQUIRED;
4753 }
4754 break;
4755 case 'I':
4756 if (_charsUsed - _curPos >= 8)
4757 {
4758 if (_chars[_curPos + 2] != 'M' || _chars[_curPos + 3] != 'P' || _chars[_curPos + 4] != 'L' || _chars[_curPos + 5] != 'I' || _chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'D')
4759 {
4760 Throw(_curPos, System.SR.Xml_ExpectAttType);
4761 }
4762 _curPos += 8;
4763 _scanningFunction = ScanningFunction.Attlist1;
4764 return Token.IMPLIED;
4765 }
4766 break;
4767 case 'F':
4768 if (_chars[_curPos + 2] != 'I' || _chars[_curPos + 3] != 'X' || _chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'D')
4769 {
4770 Throw(_curPos, System.SR.Xml_ExpectAttType);
4771 }
4772 _curPos += 6;
4773 _scanningFunction = ScanningFunction.Attlist7;
4774 return Token.FIXED;
4775 default:
4776 Throw(_curPos, System.SR.Xml_ExpectAttType);
4777 break;
4778 }
4779 break;
4780 default:
4781 Throw(_curPos, System.SR.Xml_ExpectAttType);
4782 break;
4783 }
4784 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
4785 {
4786 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
4787 }
4788 }
4789 }
4790
4791 private async Task<Token> ScanLiteralAsync(LiteralType literalType)
4792 {
4793 char quoteChar = _chars[_curPos];
4794 char replaceChar = ((literalType == LiteralType.AttributeValue) ? ' ' : '\n');
4795 int startQuoteEntityId = _currentEntityId;
4796 _literalLineInfo.Set(LineNo, LinePos);
4797 _curPos++;
4798 _tokenStartPos = _curPos;
4799 _stringBuilder.Length = 0;
4800 while (true)
4801 {
4802 if (XmlCharType.IsAttributeValueChar(_chars[_curPos]) && _chars[_curPos] != '%')
4803 {
4804 _curPos++;
4805 continue;
4806 }
4807 if (_chars[_curPos] == quoteChar && _currentEntityId == startQuoteEntityId)
4808 {
4809 break;
4810 }
4811 int num = _curPos - _tokenStartPos;
4812 if (num > 0)
4813 {
4814 _stringBuilder.Append(_chars, _tokenStartPos, num);
4815 _tokenStartPos = _curPos;
4816 }
4817 switch (_chars[_curPos])
4818 {
4819 case '"':
4820 case '\'':
4821 case '>':
4822 _curPos++;
4823 continue;
4824 case '\n':
4825 _curPos++;
4826 if (Normalize)
4827 {
4828 _stringBuilder.Append(replaceChar);
4829 _tokenStartPos = _curPos;
4830 }
4831 _readerAdapter.OnNewLine(_curPos);
4832 continue;
4833 case '\r':
4834 if (_chars[_curPos + 1] == '\n')
4835 {
4836 if (Normalize)
4837 {
4838 if (literalType == LiteralType.AttributeValue)
4839 {
4840 _stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? " " : " ");
4841 }
4842 else
4843 {
4844 _stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? "\r\n" : "\n");
4845 }
4846 _tokenStartPos = _curPos + 2;
4847 SaveParsingBuffer();
4848 _readerAdapter.CurrentPosition++;
4849 }
4850 _curPos += 2;
4851 }
4852 else
4853 {
4854 if (_curPos + 1 == _charsUsed)
4855 {
4856 break;
4857 }
4858 _curPos++;
4859 if (Normalize)
4860 {
4861 _stringBuilder.Append(replaceChar);
4862 _tokenStartPos = _curPos;
4863 }
4864 }
4865 _readerAdapter.OnNewLine(_curPos);
4866 continue;
4867 case '\t':
4868 if (literalType == LiteralType.AttributeValue && Normalize)
4869 {
4870 _stringBuilder.Append(' ');
4871 _tokenStartPos++;
4872 }
4873 _curPos++;
4874 continue;
4875 case '<':
4876 if (literalType == LiteralType.AttributeValue)
4877 {
4878 Throw(_curPos, System.SR.Xml_BadAttributeChar, XmlException.BuildCharExceptionArgs('<', '\0'));
4879 }
4880 _curPos++;
4881 continue;
4882 case '%':
4883 if (literalType != LiteralType.EntityReplText)
4884 {
4885 _curPos++;
4886 continue;
4887 }
4888 await HandleEntityReferenceAsync(paramEntity: true, inLiteral: true, literalType == LiteralType.AttributeValue).ConfigureAwait(continueOnCapturedContext: false);
4889 _tokenStartPos = _curPos;
4890 continue;
4891 case '&':
4892 {
4893 if (literalType == LiteralType.SystemOrPublicID)
4894 {
4895 _curPos++;
4896 continue;
4897 }
4898 if (_curPos + 1 == _charsUsed)
4899 {
4900 break;
4901 }
4902 if (_chars[_curPos + 1] == '#')
4903 {
4904 SaveParsingBuffer();
4905 int num2 = await _readerAdapter.ParseNumericCharRefAsync(SaveInternalSubsetValue ? _internalSubsetValueSb : null).ConfigureAwait(continueOnCapturedContext: false);
4906 LoadParsingBuffer();
4907 _stringBuilder.Append(_chars, _curPos, num2 - _curPos);
4908 _readerAdapter.CurrentPosition = num2;
4909 _tokenStartPos = num2;
4910 _curPos = num2;
4911 continue;
4912 }
4913 SaveParsingBuffer();
4914 if (literalType == LiteralType.AttributeValue)
4915 {
4916 int num3 = await _readerAdapter.ParseNamedCharRefAsync(expand: true, SaveInternalSubsetValue ? _internalSubsetValueSb : null).ConfigureAwait(continueOnCapturedContext: false);
4917 LoadParsingBuffer();
4918 if (num3 >= 0)
4919 {
4920 _stringBuilder.Append(_chars, _curPos, num3 - _curPos);
4921 _readerAdapter.CurrentPosition = num3;
4922 _tokenStartPos = num3;
4923 _curPos = num3;
4924 }
4925 else
4926 {
4927 await HandleEntityReferenceAsync(paramEntity: false, inLiteral: true, inAttribute: true).ConfigureAwait(continueOnCapturedContext: false);
4928 _tokenStartPos = _curPos;
4929 }
4930 continue;
4931 }
4932 int num4 = await _readerAdapter.ParseNamedCharRefAsync(expand: false, null).ConfigureAwait(continueOnCapturedContext: false);
4933 LoadParsingBuffer();
4934 if (num4 >= 0)
4935 {
4936 _tokenStartPos = _curPos;
4937 _curPos = num4;
4938 continue;
4939 }
4940 _stringBuilder.Append('&');
4941 _curPos++;
4942 _tokenStartPos = _curPos;
4943 XmlQualifiedName entityName = ScanEntityName();
4944 VerifyEntityReference(entityName, paramEntity: false, mustBeDeclared: false, inAttribute: false);
4945 continue;
4946 }
4947 default:
4948 {
4949 if (_curPos == _charsUsed)
4950 {
4951 break;
4952 }
4953 char ch = _chars[_curPos];
4954 if (XmlCharType.IsHighSurrogate(ch))
4955 {
4956 if (_curPos + 1 == _charsUsed)
4957 {
4958 break;
4959 }
4960 _curPos++;
4961 if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
4962 {
4963 _curPos++;
4964 continue;
4965 }
4966 }
4967 ThrowInvalidChar(_chars, _charsUsed, _curPos);
4968 return Token.None;
4969 }
4970 }
4971 bool isEof = _readerAdapter.IsEof;
4972 bool flag = isEof;
4973 if (!flag)
4974 {
4975 flag = await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0;
4976 }
4977 if (flag && (literalType == LiteralType.SystemOrPublicID || !HandleEntityEnd(inLiteral: true)))
4978 {
4979 Throw(_curPos, System.SR.Xml_UnclosedQuote);
4980 }
4981 _tokenStartPos = _curPos;
4982 }
4983 if (_stringBuilder.Length > 0)
4984 {
4985 _stringBuilder.Append(_chars, _tokenStartPos, _curPos - _tokenStartPos);
4986 }
4987 _curPos++;
4988 _literalQuoteChar = quoteChar;
4989 return Token.Literal;
4990 }
4991
4992 private async Task<Token> ScanNotation1Async()
4993 {
4994 switch (_chars[_curPos])
4995 {
4996 case 'P':
4997 if (!(await EatPublicKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
4998 {
4999 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
5000 }
5001 _nextScaningFunction = ScanningFunction.ClosingTag;
5002 _scanningFunction = ScanningFunction.PublicId1;
5003 return Token.PUBLIC;
5004 case 'S':
5005 if (!(await EatSystemKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
5006 {
5007 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
5008 }
5009 _nextScaningFunction = ScanningFunction.ClosingTag;
5010 _scanningFunction = ScanningFunction.SystemId;
5011 return Token.SYSTEM;
5012 default:
5013 Throw(_curPos, System.SR.Xml_ExpectExternalOrPublicId);
5014 return Token.None;
5015 }
5016 }
5017
5018 private async Task<Token> ScanSystemIdAsync()
5019 {
5020 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
5021 {
5022 ThrowUnexpectedToken(_curPos, "\"", "'");
5023 }
5024 await ScanLiteralAsync(LiteralType.SystemOrPublicID).ConfigureAwait(continueOnCapturedContext: false);
5025 _scanningFunction = _nextScaningFunction;
5026 return Token.Literal;
5027 }
5028
5029 private async Task<Token> ScanEntity1Async()
5030 {
5031 if (_chars[_curPos] == '%')
5032 {
5033 _curPos++;
5034 _nextScaningFunction = ScanningFunction.Entity2;
5035 _scanningFunction = ScanningFunction.Name;
5036 return Token.Percent;
5037 }
5038 await ScanNameAsync().ConfigureAwait(continueOnCapturedContext: false);
5039 _scanningFunction = ScanningFunction.Entity2;
5040 return Token.Name;
5041 }
5042
5043 private async Task<Token> ScanEntity2Async()
5044 {
5045 switch (_chars[_curPos])
5046 {
5047 case 'P':
5048 if (!(await EatPublicKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
5049 {
5050 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
5051 }
5052 _nextScaningFunction = ScanningFunction.Entity3;
5053 _scanningFunction = ScanningFunction.PublicId1;
5054 return Token.PUBLIC;
5055 case 'S':
5056 if (!(await EatSystemKeywordAsync().ConfigureAwait(continueOnCapturedContext: false)))
5057 {
5058 Throw(_curPos, System.SR.Xml_ExpectExternalOrClose);
5059 }
5060 _nextScaningFunction = ScanningFunction.Entity3;
5061 _scanningFunction = ScanningFunction.SystemId;
5062 return Token.SYSTEM;
5063 case '"':
5064 case '\'':
5065 await ScanLiteralAsync(LiteralType.EntityReplText).ConfigureAwait(continueOnCapturedContext: false);
5066 _scanningFunction = ScanningFunction.ClosingTag;
5067 return Token.Literal;
5068 default:
5069 Throw(_curPos, System.SR.Xml_ExpectExternalIdOrEntityValue);
5070 return Token.None;
5071 }
5072 }
5073
5074 private async Task<Token> ScanEntity3Async()
5075 {
5076 if (_chars[_curPos] == 'N')
5077 {
5078 do
5079 {
5080 if (_charsUsed - _curPos >= 5)
5081 {
5082 if (_chars[_curPos + 1] != 'D' || _chars[_curPos + 2] != 'A' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'A')
5083 {
5084 break;
5085 }
5086 _curPos += 5;
5087 _scanningFunction = ScanningFunction.Name;
5088 _nextScaningFunction = ScanningFunction.ClosingTag;
5089 return Token.NData;
5090 }
5091 }
5092 while (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) != 0);
5093 }
5094 _scanningFunction = ScanningFunction.ClosingTag;
5095 return Token.None;
5096 }
5097
5098 private async Task<Token> ScanPublicId1Async()
5099 {
5100 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
5101 {
5102 ThrowUnexpectedToken(_curPos, "\"", "'");
5103 }
5104 await ScanLiteralAsync(LiteralType.SystemOrPublicID).ConfigureAwait(continueOnCapturedContext: false);
5105 _scanningFunction = ScanningFunction.PublicId2;
5106 return Token.Literal;
5107 }
5108
5109 private async Task<Token> ScanPublicId2Async()
5110 {
5111 if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
5112 {
5113 _scanningFunction = _nextScaningFunction;
5114 return Token.None;
5115 }
5116 await ScanLiteralAsync(LiteralType.SystemOrPublicID).ConfigureAwait(continueOnCapturedContext: false);
5117 _scanningFunction = _nextScaningFunction;
5118 return Token.Literal;
5119 }
5120
5121 private async Task<Token> ScanCondSection1Async()
5122 {
5123 if (_chars[_curPos] != 'I')
5124 {
5125 Throw(_curPos, System.SR.Xml_ExpectIgnoreOrInclude);
5126 }
5127 _curPos++;
5128 while (true)
5129 {
5130 if (_charsUsed - _curPos >= 5)
5131 {
5132 char c = _chars[_curPos];
5133 if (c == 'G')
5134 {
5135 if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'O' || _chars[_curPos + 3] != 'R' || _chars[_curPos + 4] != 'E' || XmlCharType.IsNameSingleChar(_chars[_curPos + 5]))
5136 {
5137 break;
5138 }
5139 _nextScaningFunction = ScanningFunction.CondSection3;
5140 _scanningFunction = ScanningFunction.CondSection2;
5141 _curPos += 5;
5142 return Token.IGNORE;
5143 }
5144 if (c != 'N')
5145 {
5146 break;
5147 }
5148 if (_charsUsed - _curPos >= 6)
5149 {
5150 if (_chars[_curPos + 1] != 'C' || _chars[_curPos + 2] != 'L' || _chars[_curPos + 3] != 'U' || _chars[_curPos + 4] != 'D' || _chars[_curPos + 5] != 'E' || XmlCharType.IsNameSingleChar(_chars[_curPos + 6]))
5151 {
5152 break;
5153 }
5154 _nextScaningFunction = ScanningFunction.SubsetContent;
5155 _scanningFunction = ScanningFunction.CondSection2;
5156 _curPos += 6;
5157 return Token.INCLUDE;
5158 }
5159 }
5160 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
5161 {
5162 Throw(_curPos, System.SR.Xml_IncompleteDtdContent);
5163 }
5164 }
5165 Throw(_curPos - 1, System.SR.Xml_ExpectIgnoreOrInclude);
5166 return Token.None;
5167 }
5168
5169 private async Task<Token> ScanCondSection3Async()
5170 {
5171 int ignoreSectionDepth = 0;
5172 while (true)
5173 {
5174 if (XmlCharType.IsTextChar(_chars[_curPos]) && _chars[_curPos] != ']')
5175 {
5176 _curPos++;
5177 continue;
5178 }
5179 switch (_chars[_curPos])
5180 {
5181 case '\t':
5182 case '"':
5183 case '&':
5184 case '\'':
5185 _curPos++;
5186 continue;
5187 case '\n':
5188 _curPos++;
5189 _readerAdapter.OnNewLine(_curPos);
5190 continue;
5191 case '\r':
5192 if (_chars[_curPos + 1] == '\n')
5193 {
5194 _curPos += 2;
5195 }
5196 else
5197 {
5198 if (_curPos + 1 >= _charsUsed && !_readerAdapter.IsEof)
5199 {
5200 break;
5201 }
5202 _curPos++;
5203 }
5204 _readerAdapter.OnNewLine(_curPos);
5205 continue;
5206 case '<':
5207 if (_charsUsed - _curPos >= 3)
5208 {
5209 if (_chars[_curPos + 1] != '!' || _chars[_curPos + 2] != '[')
5210 {
5211 _curPos++;
5212 continue;
5213 }
5214 ignoreSectionDepth++;
5215 _curPos += 3;
5216 continue;
5217 }
5218 break;
5219 case ']':
5220 if (_charsUsed - _curPos < 3)
5221 {
5222 break;
5223 }
5224 if (_chars[_curPos + 1] != ']' || _chars[_curPos + 2] != '>')
5225 {
5226 _curPos++;
5227 continue;
5228 }
5229 if (ignoreSectionDepth > 0)
5230 {
5231 ignoreSectionDepth--;
5232 _curPos += 3;
5233 continue;
5234 }
5235 _curPos += 3;
5236 _scanningFunction = ScanningFunction.SubsetContent;
5237 return Token.CondSectionEnd;
5238 default:
5239 {
5240 if (_curPos == _charsUsed)
5241 {
5242 break;
5243 }
5244 char ch = _chars[_curPos];
5245 if (XmlCharType.IsHighSurrogate(ch))
5246 {
5247 if (_curPos + 1 == _charsUsed)
5248 {
5249 break;
5250 }
5251 _curPos++;
5252 if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
5253 {
5254 _curPos++;
5255 continue;
5256 }
5257 }
5258 ThrowInvalidChar(_chars, _charsUsed, _curPos);
5259 return Token.None;
5260 }
5261 }
5262 bool isEof = _readerAdapter.IsEof;
5263 bool flag = isEof;
5264 if (!flag)
5265 {
5266 flag = await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0;
5267 }
5268 if (flag)
5269 {
5270 if (HandleEntityEnd(inLiteral: false))
5271 {
5272 continue;
5273 }
5274 Throw(_curPos, System.SR.Xml_UnclosedConditionalSection);
5275 }
5276 _tokenStartPos = _curPos;
5277 }
5278 }
5279
5280 private Task ScanNameAsync()
5281 {
5282 return ScanQNameAsync(isQName: false);
5283 }
5284
5285 private Task ScanQNameAsync()
5286 {
5287 return ScanQNameAsync(SupportNamespaces);
5288 }
5289
5290 private async Task ScanQNameAsync(bool isQName)
5291 {
5292 _tokenStartPos = _curPos;
5293 int colonOffset = -1;
5294 while (true)
5295 {
5296 if (XmlCharType.IsStartNCNameSingleChar(_chars[_curPos]) || _chars[_curPos] == ':')
5297 {
5298 _curPos++;
5299 }
5300 else if (_curPos + 1 >= _charsUsed)
5301 {
5302 if (await ReadDataInNameAsync().ConfigureAwait(continueOnCapturedContext: false))
5303 {
5304 continue;
5305 }
5306 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "Name");
5307 }
5308 else
5309 {
5310 Throw(_curPos, System.SR.Xml_BadStartNameChar, XmlException.BuildCharExceptionArgs(_chars, _charsUsed, _curPos));
5311 }
5312 while (true)
5313 {
5314 if (XmlCharType.IsNCNameSingleChar(_chars[_curPos]))
5315 {
5316 _curPos++;
5317 continue;
5318 }
5319 if (_chars[_curPos] == ':')
5320 {
5321 if (isQName)
5322 {
5323 break;
5324 }
5325 _curPos++;
5326 continue;
5327 }
5328 if (_curPos == _charsUsed)
5329 {
5330 if (await ReadDataInNameAsync().ConfigureAwait(continueOnCapturedContext: false))
5331 {
5332 continue;
5333 }
5334 if (_tokenStartPos == _curPos)
5335 {
5336 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "Name");
5337 }
5338 }
5339 _colonPos = ((colonOffset == -1) ? (-1) : (_tokenStartPos + colonOffset));
5340 return;
5341 }
5342 if (colonOffset != -1)
5343 {
5344 Throw(_curPos, System.SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(':', '\0'));
5345 }
5346 colonOffset = _curPos - _tokenStartPos;
5347 _curPos++;
5348 }
5349 }
5350
5351 private async Task<bool> ReadDataInNameAsync()
5352 {
5353 int offset = _curPos - _tokenStartPos;
5354 _curPos = _tokenStartPos;
5355 bool result = await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) != 0;
5356 _tokenStartPos = _curPos;
5357 _curPos += offset;
5358 return result;
5359 }
5360
5361 private async Task ScanNmtokenAsync()
5362 {
5363 _tokenStartPos = _curPos;
5364 int len;
5365 while (true)
5366 {
5367 if (XmlCharType.IsNCNameSingleChar(_chars[_curPos]) || _chars[_curPos] == ':')
5368 {
5369 _curPos++;
5370 continue;
5371 }
5372 if (_curPos < _charsUsed)
5373 {
5374 if (_curPos - _tokenStartPos == 0)
5375 {
5376 Throw(_curPos, System.SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(_chars, _charsUsed, _curPos));
5377 }
5378 return;
5379 }
5380 len = _curPos - _tokenStartPos;
5381 _curPos = _tokenStartPos;
5382 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
5383 {
5384 if (len > 0)
5385 {
5386 break;
5387 }
5388 Throw(_curPos, System.SR.Xml_UnexpectedEOF, "NmToken");
5389 }
5390 _tokenStartPos = _curPos;
5391 _curPos += len;
5392 }
5393 _tokenStartPos = _curPos;
5394 _curPos += len;
5395 }
5396
5397 private async Task<bool> EatPublicKeywordAsync()
5398 {
5399 while (_charsUsed - _curPos < 6)
5400 {
5401 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
5402 {
5403 return false;
5404 }
5405 }
5406 if (_chars[_curPos + 1] != 'U' || _chars[_curPos + 2] != 'B' || _chars[_curPos + 3] != 'L' || _chars[_curPos + 4] != 'I' || _chars[_curPos + 5] != 'C')
5407 {
5408 return false;
5409 }
5410 _curPos += 6;
5411 return true;
5412 }
5413
5414 private async Task<bool> EatSystemKeywordAsync()
5415 {
5416 while (_charsUsed - _curPos < 6)
5417 {
5418 if (await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false) == 0)
5419 {
5420 return false;
5421 }
5422 }
5423 if (_chars[_curPos + 1] != 'Y' || _chars[_curPos + 2] != 'S' || _chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'M')
5424 {
5425 return false;
5426 }
5427 _curPos += 6;
5428 return true;
5429 }
5430
5431 private async Task<int> ReadDataAsync()
5432 {
5433 SaveParsingBuffer();
5434 int result = await _readerAdapter.ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false);
5435 LoadParsingBuffer();
5436 return result;
5437 }
5438
5444
5445 private async Task<bool> HandleEntityReferenceAsync(XmlQualifiedName entityName, bool paramEntity, bool inLiteral, bool inAttribute)
5446 {
5447 SaveParsingBuffer();
5448 if (paramEntity && ParsingInternalSubset && !ParsingTopLevelMarkup)
5449 {
5450 Throw(_curPos - entityName.Name.Length - 1, System.SR.Xml_InvalidParEntityRef);
5451 }
5452 SchemaEntity schemaEntity = VerifyEntityReference(entityName, paramEntity, mustBeDeclared: true, inAttribute);
5453 if (schemaEntity == null)
5454 {
5455 return false;
5456 }
5457 if (schemaEntity.ParsingInProgress)
5458 {
5459 Throw(_curPos - entityName.Name.Length - 1, paramEntity ? System.SR.Xml_RecursiveParEntity : System.SR.Xml_RecursiveGenEntity, entityName.Name);
5460 }
5461 int currentEntityId;
5462 if (schemaEntity.IsExternal)
5463 {
5464 (int, bool) tuple = await _readerAdapter.PushEntityAsync(schemaEntity).ConfigureAwait(continueOnCapturedContext: false);
5465 (currentEntityId, _) = tuple;
5466 if (!tuple.Item2)
5467 {
5468 return false;
5469 }
5470 _externalEntitiesDepth++;
5471 }
5472 else
5473 {
5474 if (schemaEntity.Text.Length == 0)
5475 {
5476 return false;
5477 }
5478 (int, bool) tuple3 = await _readerAdapter.PushEntityAsync(schemaEntity).ConfigureAwait(continueOnCapturedContext: false);
5479 (currentEntityId, _) = tuple3;
5480 if (!tuple3.Item2)
5481 {
5482 return false;
5483 }
5484 }
5485 _currentEntityId = currentEntityId;
5486 if (paramEntity && !inLiteral && _scanningFunction != ScanningFunction.ParamEntitySpace)
5487 {
5488 _savedScanningFunction = _scanningFunction;
5489 _scanningFunction = ScanningFunction.ParamEntitySpace;
5490 }
5491 LoadParsingBuffer();
5492 return true;
5493 }
5494}
System.Array.Copy
static unsafe void Copy(Array sourceArray, Array destinationArray, int length)
Definition Array.cs:624
System.Collections.Generic.Dictionary.ValueCollection.Contains
bool ICollection< TValue >. Contains(TValue item)
Definition Dictionary.cs:584
System.Collections.Generic.Dictionary.TryGetValue
bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
Definition Dictionary.cs:1419
System.Collections.Generic.Dictionary.Remove
bool ICollection< KeyValuePair< TKey, TValue > >. Remove(KeyValuePair< TKey, TValue > keyValuePair)
Definition Dictionary.cs:893
System.Collections.Generic.Dictionary.Contains
bool ICollection< KeyValuePair< TKey, TValue > >. Contains(KeyValuePair< TKey, TValue > keyValuePair)
Definition Dictionary.cs:883
System.Collections.Generic.Dictionary.Add
void Add(TKey key, TValue value)
Definition Dictionary.cs:873
System.SR.Xml_BadAttributeChar
static string Xml_BadAttributeChar
Definition SR.cs:74
System.SR.Xml_ExpectIgnoreOrInclude
static string Xml_ExpectIgnoreOrInclude
Definition SR.cs:276
System.SR.Xml_UndeclaredParEntity
static string Xml_UndeclaredParEntity
Definition SR.cs:214
System.SR.Xml_ExpectDtdMarkup
static string Xml_ExpectDtdMarkup
Definition SR.cs:244
System.SR.Xml_AttlistDuplNotationValue
static string Xml_AttlistDuplNotationValue
Definition SR.cs:232
System.SR.Xml_InvalidParEntityRef
static string Xml_InvalidParEntityRef
Definition SR.cs:268
System.SR.Xml_ExpectSubOrClose
static string Xml_ExpectSubOrClose
Definition SR.cs:270
System.SR.Sch_NotationAttributeOnEmptyElement
static string Sch_NotationAttributeOnEmptyElement
Definition SR.cs:716
System.SR.Xml_UnclosedQuote
static string Xml_UnclosedQuote
Definition SR.cs:34
System.SR.Xml_ExternalEntityInAttValue
static string Xml_ExternalEntityInAttValue
Definition SR.cs:126
System.SR.Xml_ExpectNoWhitespace
static string Xml_ExpectNoWhitespace
Definition SR.cs:256
System.SR.Xml_BadStartNameChar
static string Xml_BadStartNameChar
Definition SR.cs:42
System.SR.Xml_ExpectOp
static string Xml_ExpectOp
Definition SR.cs:258
System.SR.Xml_EnumerationRequired
static string Xml_EnumerationRequired
Definition SR.cs:248
System.SR.Sch_DupElementDecl
static string Sch_DupElementDecl
Definition SR.cs:404
System.SR.Xml_UndeclaredEntity
static string Xml_UndeclaredEntity
Definition SR.cs:120
System.SR.Xml_InvalidConditionalSection
static string Xml_InvalidConditionalSection
Definition SR.cs:238
System.SR.Xml_FragmentId
static string Xml_FragmentId
Definition SR.cs:252
System.SR.Xml_IncompleteDtdContent
static string Xml_IncompleteDtdContent
Definition SR.cs:246
System.SR.Xml_UnexpectedCDataEnd
static string Xml_UnexpectedCDataEnd
Definition SR.cs:240
System.SR.Sch_DupNotationAttribute
static string Sch_DupNotationAttribute
Definition SR.cs:712
System.SR.Sch_ParEntityRefNesting
static string Sch_ParEntityRefNesting
Definition SR.cs:392
System.SR.Xml_AttlistDuplEnumValue
static string Xml_AttlistDuplEnumValue
Definition SR.cs:230
System.SR.Xml_UnparsedEntityRef
static string Xml_UnparsedEntityRef
Definition SR.cs:128
System.SR.Xml_RecursiveParEntity
static string Xml_RecursiveParEntity
Definition SR.cs:122
System.SR.Xml_ExpectExternalIdOrEntityValue
static string Xml_ExpectExternalIdOrEntityValue
Definition SR.cs:274
System.SR.Xml_InternalError
static string Xml_InternalError
Definition SR.cs:54
System.SR.Xml_ColonInLocalName
static string Xml_ColonInLocalName
Definition SR.cs:266
System.SR.Sch_DupElement
static string Sch_DupElement
Definition SR.cs:480
System.SR.Xml_InvalidAttributeType1
static string Xml_InvalidAttributeType1
Definition SR.cs:262
System.SR.Xml_UnexpectedTokens2
static string Xml_UnexpectedTokens2
Definition SR.cs:64
System.SR.Xml_ExpectAttType
static string Xml_ExpectAttType
Definition SR.cs:264
System.SR.Xml_InvalidCharacter
static string Xml_InvalidCharacter
Definition SR.cs:110
System.SR.Xml_ExpectExternalOrPublicId
static string Xml_ExpectExternalOrPublicId
Definition SR.cs:272
System.SR.Xml_UnexpectedTokenEx
static string Xml_UnexpectedTokenEx
Definition SR.cs:62
System.SR.Xml_InvalidContentModel
static string Xml_InvalidContentModel
Definition SR.cs:250
System.SR.Sch_AttListPresence
static string Sch_AttListPresence
Definition SR.cs:564
System.SR.Xml_InvalidAttributeType
static string Xml_InvalidAttributeType
Definition SR.cs:260
System.SR.Xml_ExpectingWhiteSpace
static string Xml_ExpectingWhiteSpace
Definition SR.cs:66
System.SR.Xml_ErrorParsingEntityName
static string Xml_ErrorParsingEntityName
Definition SR.cs:136
System.SR.Xml_BadNameChar
static string Xml_BadNameChar
Definition SR.cs:44
System.SR.Sch_IdAttrDeclared
static string Sch_IdAttrDeclared
Definition SR.cs:406
System.SR.Xml_UnexpectedEOF
static string Xml_UnexpectedEOF
Definition SR.cs:36
System.SR.Xml_ExpectPcData
static string Xml_ExpectPcData
Definition SR.cs:254
System.SR.Xml_RecursiveGenEntity
static string Xml_RecursiveGenEntity
Definition SR.cs:124
System.SR.Xml_UnclosedConditionalSection
static string Xml_UnclosedConditionalSection
Definition SR.cs:242
System.SR.Sch_UndeclaredNotation
static string Sch_UndeclaredNotation
Definition SR.cs:416
System.SR.Xml_ExpectExternalOrClose
static string Xml_ExpectExternalOrClose
Definition SR.cs:76
System.SR.Sch_DupNotation
static string Sch_DupNotation
Definition SR.cs:534
System.SR
Definition SR.cs:7
System.Text.StringBuilder.ToString
override string ToString()
Definition StringBuilder.cs:679
System.Text.StringBuilder.Append
StringBuilder Append(char value, int repeatCount)
Definition StringBuilder.cs:744
System.Threading.Tasks.Task.ConfigureAwait
new ConfiguredTaskAwaitable< TResult > ConfigureAwait(bool continueOnCapturedContext)
Definition Task.cs:226
System.Uri.ToString
override string ToString()
Definition Uri.cs:1119
System.Xml.DtdParser.ParseElementOnlyContent_LocalFrame.ParseElementOnlyContent_LocalFrame
ParseElementOnlyContent_LocalFrame(int startParentEntityIdParam)
Definition DtdParser.cs:133
System.Xml.DtdParser.ParseElementOnlyContent_LocalFrame.startParenEntityId
int startParenEntityId
Definition DtdParser.cs:129
System.Xml.DtdParser.ParseElementOnlyContent_LocalFrame.parsingSchema
Token parsingSchema
Definition DtdParser.cs:131
System.Xml.DtdParser.ParseElementOnlyContent_LocalFrame
Definition DtdParser.cs:128
System.Xml.DtdParser.UndeclaredNotation.UndeclaredNotation
UndeclaredNotation(string name, int lineNo, int linePos)
Definition DtdParser.cs:118
System.Xml.DtdParser.ParseNotationDeclAsync
async Task ParseNotationDeclAsync()
Definition DtdParser.cs:3929
System.Xml.DtdParser.ScanLiteral
Token ScanLiteral(LiteralType literalType)
Definition DtdParser.cs:2145
System.Xml.DtdParser.ScanCondSection3Async
async Task< Token > ScanCondSection3Async()
Definition DtdParser.cs:5169
System.Xml.DtdParser.ThrowUnexpectedToken
void ThrowUnexpectedToken(int pos, string expectedToken1, string expectedToken2)
Definition DtdParser.cs:3074
System.Xml.DtdParser.ScanAttlist1Async
async Task< Token > ScanAttlist1Async()
Definition DtdParser.cs:4591
System.Xml.DtdParser.ParseHowMany
void ParseHowMany(ParticleContentValidator pcv)
Definition DtdParser.cs:931
System.Xml.DtdParser.ScanEntity2Async
async Task< Token > ScanEntity2Async()
Definition DtdParser.cs:5043
System.Xml.DtdParser.ParseInDocumentDtd
void ParseInDocumentDtd(bool saveInternalSubset)
Definition DtdParser.cs:378
System.Xml.DtdParser._nextScaningFunction
ScanningFunction _nextScaningFunction
Definition DtdParser.cs:168
System.Xml.DtdParser.ScanEntity3Async
async Task< Token > ScanEntity3Async()
Definition DtdParser.cs:5074
System.Xml.DtdParser.ReadDataAsync
async Task< int > ReadDataAsync()
Definition DtdParser.cs:5431
System.Xml.DtdParser.ParseAttlistDefault
void ParseAttlistDefault(SchemaAttDef attrDef, bool ignoreErrors)
Definition DtdParser.cs:734
System.Xml.DtdParser.Create
static IDtdParser Create()
Definition DtdParser.cs:261
System.Xml.DtdParser.ParseAttlistTypeAsync
async Task ParseAttlistTypeAsync(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
Definition DtdParser.cs:3457
System.Xml.DtdParser.Parse
void Parse(bool saveInternalSubset)
Definition DtdParser.cs:354
System.Xml.DtdParser.ScanElement2Async
async Task< Token > ScanElement2Async()
Definition DtdParser.cs:4550
System.Xml.DtdParser.SendValidationEvent
void SendValidationEvent(int pos, XmlSeverityType severity, string code, string arg)
Definition DtdParser.cs:3002
System.Xml.DtdParser.ParseElementDeclAsync
async Task ParseElementDeclAsync()
Definition DtdParser.cs:3600
System.Xml.DtdParser.EatSystemKeywordAsync
async Task< bool > EatSystemKeywordAsync()
Definition DtdParser.cs:5414
System.Xml.DtdParser.ParseElementOnlyContentAsync
async Task ParseElementOnlyContentAsync(ParticleContentValidator pcv, int startParenEntityId)
Definition DtdParser.cs:3678
System.Xml.DtdParser.ScanQNameAsync
async Task ScanQNameAsync(bool isQName)
Definition DtdParser.cs:5290
System.Xml.DtdParser.AddUndeclaredNotation
void AddUndeclaredNotation(string notationName)
Definition DtdParser.cs:1140
System.Xml.DtdParser._undeclaredNotations
Dictionary< string, UndeclaredNotation > _undeclaredNotations
Definition DtdParser.cs:200
System.Xml.DtdParser.StripSpaces
static string StripSpaces(string value)
Definition DtdParser.cs:3101
System.Xml.DtdParser.ParsePIAsync
async Task ParsePIAsync()
Definition DtdParser.cs:3996
System.Xml.DtdParser.ParseHowManyAsync
async Task ParseHowManyAsync(ParticleContentValidator pcv)
Definition DtdParser.cs:3758
System.Xml.DtdParser.ScanSystemIdAsync
async Task< Token > ScanSystemIdAsync()
Definition DtdParser.cs:5018
System.Xml.DtdParser.ScanNmtokenExpected
Token ScanNmtokenExpected()
Definition DtdParser.cs:1637
System.Xml.DtdParser.ParseElementMixedContent
void ParseElementMixedContent(ParticleContentValidator pcv, int startParenEntityId)
Definition DtdParser.cs:947
System.Xml.DtdParser.EatPublicKeywordAsync
async Task< bool > EatPublicKeywordAsync()
Definition DtdParser.cs:5397
System.Xml.DtdParser.ParseSubsetAsync
async Task ParseSubsetAsync()
Definition DtdParser.cs:3277
System.Xml.DtdParser.ScanQName
void ScanQName(bool isQName)
Definition DtdParser.cs:2662
System.Xml.DtdParser.ScanElement1Async
async Task< Token > ScanElement1Async()
Definition DtdParser.cs:4499
System.Xml.DtdParser.ScanElement3Async
async Task< Token > ScanElement3Async()
Definition DtdParser.cs:4573
System.Xml.DtdParser.ParseAttlistDeclAsync
async Task ParseAttlistDeclAsync()
Definition DtdParser.cs:3373
System.Xml.DtdParser.ScanQNameExpectedAsync
async Task< Token > ScanQNameExpectedAsync()
Definition DtdParser.cs:4451
System.Xml.DtdParser.Throw
void Throw(int curPos, string res)
Definition DtdParser.cs:3031
System.Xml.DtdParser.IsAttributeValueType
bool IsAttributeValueType(Token token)
Definition DtdParser.cs:3017
System.Xml.DtdParser.ScanNotation1Async
async Task< Token > ScanNotation1Async()
Definition DtdParser.cs:4992
System.Xml.DtdParser.HandleEntityReferenceAsync
async Task< bool > HandleEntityReferenceAsync(XmlQualifiedName entityName, bool paramEntity, bool inLiteral, bool inAttribute)
Definition DtdParser.cs:5445
System.Xml.DtdParser.ScanCondSection1Async
async Task< Token > ScanCondSection1Async()
Definition DtdParser.cs:5121
System.Xml.DtdParser.GetNameQualified
XmlQualifiedName GetNameQualified(bool canHavePrefix)
Definition DtdParser.cs:2803
System.Xml.DtdParser.ParseCommentAsync
async Task ParseCommentAsync()
Definition DtdParser.cs:3970
System.Xml.DtdParser.HandleEntityReference
bool HandleEntityReference(XmlQualifiedName entityName, bool paramEntity, bool inLiteral, bool inAttribute)
Definition DtdParser.cs:2881
System.Xml.DtdParser.ScanPublicId1Async
async Task< Token > ScanPublicId1Async()
Definition DtdParser.cs:5098
System.Xml.DtdParser.Throw
void Throw(string res, string arg, int lineNo, int linePos)
Definition DtdParser.cs:3053
System.Xml.DtdParser.ScanEntityName
XmlQualifiedName ScanEntityName()
Definition DtdParser.cs:2340
System.Xml.DtdParser.ParseElementMixedContentAsync
async Task ParseElementMixedContentAsync(ParticleContentValidator pcv, int startParenEntityId)
Definition DtdParser.cs:3774
System.Xml.DtdParser.HandleEntityEnd
bool HandleEntityEnd(bool inLiteral)
Definition DtdParser.cs:2927
System.Xml.DtdParser.ParseInternalSubsetAsync
Task ParseInternalSubsetAsync()
Definition DtdParser.cs:3257
System.Xml.DtdParser.ReadDataInNameAsync
async Task< bool > ReadDataInNameAsync()
Definition DtdParser.cs:5351
System.Xml.DtdParser._literalLineInfo
LineInfo _literalLineInfo
Definition DtdParser.cs:192
System.Xml.DtdParser.Throw
void Throw(int curPos, string res, string arg)
Definition DtdParser.cs:3037
System.Xml.DtdParser.GetToken
Token GetToken(bool needWhiteSpace)
Definition DtdParser.cs:1318
System.Xml.DtdParser.ParseFreeFloatingDtd
void ParseFreeFloatingDtd()
Definition DtdParser.cs:417
System.Xml.DtdParser.ScanDoctype1Async
async Task< Token > ScanDoctype1Async()
Definition DtdParser.cs:4465
System.Xml.DtdParser.InitializeFreeFloatingDtd
void InitializeFreeFloatingDtd(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
Definition DtdParser.cs:292
System.Xml.DtdParser.ParseCondSectionAsync
async Task ParseCondSectionAsync()
Definition DtdParser.cs:4011
System.Xml.DtdParser.SaveParsingBuffer
void SaveParsingBuffer(int internalSubsetValueEndPos)
Definition DtdParser.cs:2862
System.Xml.DtdParser.ThrowUnexpectedToken
void ThrowUnexpectedToken(int pos, string expectedToken)
Definition DtdParser.cs:3069
System.Xml.DtdParser.Initialize
void Initialize(IDtdParserAdapter readerAdapter)
Definition DtdParser.cs:266
System.Xml.DtdParser._savedScanningFunction
ScanningFunction _savedScanningFunction
Definition DtdParser.cs:170
System.Xml.DtdParser.ScanAttlist2Async
async Task< Token > ScanAttlist2Async()
Definition DtdParser.cs:4609
System.Xml.DtdParser.ScanAttlist6Async
async Task< Token > ScanAttlist6Async()
Definition DtdParser.cs:4725
System.Xml.DtdParser._readerAdapterWithValidation
IDtdParserAdapterWithValidation _readerAdapterWithValidation
Definition DtdParser.cs:142
System.Xml.DtdParser.VerifyEntityReference
SchemaEntity VerifyEntityReference(XmlQualifiedName entityName, bool paramEntity, bool mustBeDeclared, bool inAttribute)
Definition DtdParser.cs:2955
System.Xml.DtdParser.ScanLiteralAsync
async Task< Token > ScanLiteralAsync(LiteralType literalType)
Definition DtdParser.cs:4791
System.Xml.DtdParser.ParseAttlistDefaultAsync
async Task ParseAttlistDefaultAsync(SchemaAttDef attrDef, bool ignoreErrors)
Definition DtdParser.cs:3562
System.Xml.DtdParser.ParseElementOnlyContent
void ParseElementOnlyContent(ParticleContentValidator pcv, int startParenEntityId)
Definition DtdParser.cs:851
System.Xml.DtdParser._readerAdapter
IDtdParserAdapter _readerAdapter
Definition DtdParser.cs:140
System.Xml.DtdParser.ParseAsync
async Task ParseAsync(bool saveInternalSubset)
Definition DtdParser.cs:3178
System.Xml.DtdParser._internalSubsetValueSb
StringBuilder _internalSubsetValueSb
Definition DtdParser.cs:178
System.Xml.DtdParser.ParseUnexpectedToken
string ParseUnexpectedToken(int startPos)
Definition DtdParser.cs:3087
System.Xml.DtdParser.ScanEntity1Async
async Task< Token > ScanEntity1Async()
Definition DtdParser.cs:5029
System.Xml.DtdParser.GetValueWithStrippedSpaces
string GetValueWithStrippedSpaces()
Definition DtdParser.cs:2836
System.Xml.DtdParser.HandleEntityReferenceAsync
Task< bool > HandleEntityReferenceAsync(bool paramEntity, bool inLiteral, bool inAttribute)
Definition DtdParser.cs:5439
System.Xml.DtdParser.ThrowInvalidChar
void ThrowInvalidChar(char[] data, int length, int invCharPos)
Definition DtdParser.cs:3064
System.Xml.DtdParser.ScanNameExpectedAsync
async Task< Token > ScanNameExpectedAsync()
Definition DtdParser.cs:4444
System.Xml.DtdParser._nameTable
XmlNameTable _nameTable
Definition DtdParser.cs:144
System.Xml.DtdParser.ParseExternalIdAsync
async Task<(string, string)> ParseExternalIdAsync(Token idTokenType, Token declType)
Definition DtdParser.cs:4064
System.Xml.DtdParser.ParseExternalId
void ParseExternalId(Token idTokenType, Token declType, out string publicId, out string systemId)
Definition DtdParser.cs:1252
System.Xml.DtdParser.ScanPublicId2Async
async Task< Token > ScanPublicId2Async()
Definition DtdParser.cs:5109
System.Xml.DtdParser.SendValidationEvent
void SendValidationEvent(XmlSeverityType severity, XmlSchemaException e)
Definition DtdParser.cs:3012
System.Xml.DtdParser.HandleEntityReference
bool HandleEntityReference(bool paramEntity, bool inLiteral, bool inAttribute)
Definition DtdParser.cs:2875
System.Xml.DtdParser.ScanNmtokenAsync
async Task ScanNmtokenAsync()
Definition DtdParser.cs:5361
System.Xml.DtdParser._schemaInfo
SchemaInfo _schemaInfo
Definition DtdParser.cs:146
System.Xml.DtdParser._scanningFunction
ScanningFunction _scanningFunction
Definition DtdParser.cs:166
System.Xml.DtdParser.ParseFreeFloatingDtdAsync
async Task ParseFreeFloatingDtdAsync()
Definition DtdParser.cs:3243
System.Xml.DtdParser._hasFreeFloatingInternalSubset
bool _hasFreeFloatingInternalSubset
Definition DtdParser.cs:186
System.Xml.DtdParser.GetNmtokenString
string GetNmtokenString()
Definition DtdParser.cs:2822
System.Xml.DtdParser.ParseInDocumentDtdAsync
async Task ParseInDocumentDtdAsync(bool saveInternalSubset)
Definition DtdParser.cs:3202
System.Xml.DtdParser.GetTokenAsync
async Task< Token > GetTokenAsync(bool needWhiteSpace)
Definition DtdParser.cs:4133
System.Xml.DtdParser.ScanNmtokenExpectedAsync
async Task< Token > ScanNmtokenExpectedAsync()
Definition DtdParser.cs:4458
System.Xml.DtdParser.ParseEntityDeclAsync
async Task ParseEntityDeclAsync()
Definition DtdParser.cs:3841
System.Xml.DtdParser.ThrowInvalidChar
void ThrowInvalidChar(int pos, string data, int invCharPos)
Definition DtdParser.cs:3059
System.Xml.DtdParser.SendValidationEvent
void SendValidationEvent(XmlSeverityType severity, string code, string arg)
Definition DtdParser.cs:3007
System.Xml.DtdParser._stringBuilder
StringBuilder _stringBuilder
Definition DtdParser.cs:188
System.Xml.DtdParser.ParseExternalSubsetAsync
async Task ParseExternalSubsetAsync()
Definition DtdParser.cs:3262
System.Xml.DtdParser.ParseAttlistType
void ParseAttlistType(SchemaAttDef attrDef, SchemaElementDecl elementDecl, bool ignoreErrors)
Definition DtdParser.cs:629
System.Xml.DtdParser.ScanSubsetContentAsync
async Task< Token > ScanSubsetContentAsync()
Definition DtdParser.cs:4295
System.Xml.DtdParser.Throw
void Throw(int curPos, string res, string[] args)
Definition DtdParser.cs:3045
System.Xml.Schema.ContentValidator.Empty
static readonly ContentValidator Empty
Definition ContentValidator.cs:13
System.Xml.Schema.ContentValidator.Any
static readonly ContentValidator Any
Definition ContentValidator.cs:19
System.Xml.Schema.DtdValidator.SetDefaultTypedValue
static void SetDefaultTypedValue(SchemaAttDef attdef, IDtdParserAdapter readerAdapter)
Definition DtdValidator.cs:497
System.Xml.Schema.SchemaInfo.GeneralEntities
Dictionary< XmlQualifiedName, SchemaEntity > GeneralEntities
Definition SchemaInfo.cs:60
System.Xml.Schema.SchemaInfo.Notations
Dictionary< string, SchemaNotation > Notations
Definition SchemaInfo.cs:102
System.Xml.Schema.SchemaInfo.ParameterEntities
Dictionary< XmlQualifiedName, SchemaEntity > ParameterEntities
Definition SchemaInfo.cs:72
System.Xml.Schema.SchemaInfo.ElementDecls
Dictionary< XmlQualifiedName, SchemaElementDecl > ElementDecls
Definition SchemaInfo.cs:55
System.Xml.Schema.SchemaInfo.UndeclaredElementDecls
Dictionary< XmlQualifiedName, SchemaElementDecl > UndeclaredElementDecls
Definition SchemaInfo.cs:57
System.Xml.Schema.XmlSchemaType.GetBuiltInSimpleType
static ? XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName)
Definition XmlSchemaType.cs:173
System.Xml.XmlCharType.IsStartNCNameSingleChar
static bool IsStartNCNameSingleChar(char ch)
Definition XmlCharType.cs:6579
System.Xml.XmlCharType.IsAttributeValueChar
static bool IsAttributeValueChar(char ch)
Definition XmlCharType.cs:6617
System.Xml.XmlCharType.IsOnlyCharData
static int IsOnlyCharData(string str)
Definition XmlCharType.cs:6706
System.Xml.XmlCharType.IsNCNameSingleChar
static bool IsNCNameSingleChar(char ch)
Definition XmlCharType.cs:6573
System.Xml.XmlCharType.IsWhiteSpace
static bool IsWhiteSpace(char ch)
Definition XmlCharType.cs:6567
System.Xml.XmlCharType.IsTextChar
static bool IsTextChar(char ch)
Definition XmlCharType.cs:6611
System.Xml.XmlCharType.IsLowSurrogate
static bool IsLowSurrogate(int ch)
Definition XmlCharType.cs:6664
System.Xml.XmlCharType.IsNameSingleChar
static bool IsNameSingleChar(char ch)
Definition XmlCharType.cs:6585
System.Xml.XmlCharType.IsHighSurrogate
static bool IsHighSurrogate(int ch)
Definition XmlCharType.cs:6659
System.Xml.XmlCharType.IsPublicId
static int IsPublicId(string str)
Definition XmlCharType.cs:6737
System.Xml.XmlConvert.CreateInvalidNameArgumentException
static ArgumentException CreateInvalidNameArgumentException(string name, string argumentName)
Definition XmlConvert.cs:1487
System.Xml.XmlConvert.VerifyName
static string VerifyName(string name)
Definition XmlConvert.cs:282
System.Xml.XmlException.BuildCharExceptionArgs
static string[] BuildCharExceptionArgs(string data, int invCharIndex)
Definition XmlException.cs:237
System.Xml.XmlNameTable.Add
string Add(char[] array, int offset, int length)
System.Xml.IDtdParserAdapter.PushExternalSubset
bool PushExternalSubset(string systemId, string publicId)
System.Xml.IDtdParserAdapter.ParsePI
void ParsePI(StringBuilder sb)
System.Xml.IDtdParserAdapter.ParsePIAsync
Task ParsePIAsync(StringBuilder sb)
System.Xml.IDtdParserAdapter.ParseNumericCharRefAsync
Task< int > ParseNumericCharRefAsync(StringBuilder internalSubsetBuilder)
System.Xml.IDtdParserAdapter.ParseNamedCharRefAsync
Task< int > ParseNamedCharRefAsync(bool expand, StringBuilder internalSubsetBuilder)
System.Xml.IDtdParserAdapter.OnSystemId
void OnSystemId(string systemId, LineInfo keywordLineInfo, LineInfo systemLiteralLineInfo)
System.Xml.IDtdParserAdapter.PopEntity
bool PopEntity(out IDtdEntityInfo oldEntity, out int newEntityId)
System.Xml.IDtdParserAdapter.ParseCommentAsync
Task ParseCommentAsync(StringBuilder sb)
System.Xml.IDtdParserAdapter.OnPublicId
void OnPublicId(string publicId, LineInfo keywordLineInfo, LineInfo publicLiteralLineInfo)
System.Xml.IDtdParserAdapter.PushInternalDtd
void PushInternalDtd(string baseUri, string internalDtd)
System.Xml.IDtdParserAdapter.PushEntityAsync
Task<(int, bool)> PushEntityAsync(IDtdEntityInfo entity)
System.Xml.IDtdParserAdapter.Throw
void Throw(Exception e)
System.Xml.IDtdParserAdapter.PushExternalSubsetAsync
Task< bool > PushExternalSubsetAsync(string systemId, string publicId)
System.Xml.IDtdParserAdapter.ParseNamedCharRef
int ParseNamedCharRef(bool expand, StringBuilder internalSubsetBuilder)
System.Xml.IDtdParserAdapter.ParseComment
void ParseComment(StringBuilder sb)
System.Xml.IDtdParserAdapter.PushEntity
bool PushEntity(IDtdEntityInfo entity, out int entityId)
System.Xml.IDtdParserAdapter.ParseNumericCharRef
int ParseNumericCharRef(StringBuilder internalSubsetBuilder)
System.Xml.IDtdParser.ParseInternalDtd
IDtdInfo ParseInternalDtd(IDtdParserAdapter adapter, bool saveInternalSubset)
System.Xml.IDtdParser.ParseInternalDtdAsync
Task< IDtdInfo > ParseInternalDtdAsync(IDtdParserAdapter adapter, bool saveInternalSubset)
System.Xml.IDtdParser.ParseFreeFloatingDtd
IDtdInfo ParseFreeFloatingDtd(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
System.Xml.IDtdParser.ParseFreeFloatingDtdAsync
Task< IDtdInfo > ParseFreeFloatingDtdAsync(string baseUri, string docTypeName, string publicId, string systemId, string internalSubset, IDtdParserAdapter adapter)
System.Xml.IValidationEventHandling.SendEvent
void SendEvent(Exception exception, XmlSeverityType severity)
System.Xml.LineInfo.Set
void Set(int lineNo, int linePos)
Definition LineInfo.cs:15