mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 12:31:30 -10:00
* DTDObjectModel.cs : added XmlResolver related members. Added invalid entity recursion logic. Added encodingdecl check on textdecl. * DTDValidatingReader.cs : It now implements IHasXmlParserContext. * XmlChar.cs : IsPubidChar() should not allow TAB(	). * XmlDocumentType.cs : 1) internal CreateDocumentType() was now changed to receive DTDObjectModel to support other than XmlTextReader. 2) Most of its public member is now based on DTDObjectModel. * XmlDocument.cs : 1) Synchronous change with XmlDocumentType. 2) ReadNode() now considers XmlParserContext's DTDObjectModel for other than XmlTextReader (such as XmlValidatingReader). * XmlNode.cs : code cleanup only. * XmlParserInput.cs : added HasPEBuffer, used to check illegal nesting. * XmlTextReader.cs : 1) Illegal entity reference check logic was moved from ReadContent() to SetEntityReferenceProperties(). 2) Indentation change on ReadEntityReference(). 3) ReadAttribute() now checks reference to external entity reference. 4) Added textdecl encoding check. 5) DTDObjectModel fields are now set correctly. 6) added PERef markup nest check. 7) If PEDecl was not found, it might be WFC violation, not only be VC violation. 8) ReadEntityDecl() now receives its declared entity itself, and this method checks IsInternalSubset. * XmlValidatingReader.cs : 1) Added GetInternalPerserContext(). 2) ValidationType.None should be the same as Auto, not DTD (in the future it should keep xml schema's default values). Pending Stuff in XmlTextReader which breaks some NUnit tests; 1) SetEntityReferenceProperies() has check for illegal references. 2) ReadAttribute(bool) has similar check for illegal references. svn path=/trunk/mcs/; revision=17218
3020 lines
77 KiB
C#
3020 lines
77 KiB
C#
//
|
|
// System.Xml.XmlTextReader
|
|
//
|
|
// Author:
|
|
// Jason Diamond ([email protected])
|
|
// Adam Treat ([email protected])
|
|
// Atsushi Enomoto ([email protected])
|
|
//
|
|
// (C) 2001, 2002 Jason Diamond http://injektilo.org/
|
|
//
|
|
|
|
// FIXME:
|
|
//
|
|
// NameTables aren't being used completely yet.
|
|
//
|
|
// Some thought needs to be given to performance. There's too many
|
|
// strings being allocated.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml.Schema;
|
|
using Mono.Xml;
|
|
using Mono.Xml.Native;
|
|
|
|
namespace System.Xml
|
|
{
|
|
public class XmlTextReader : XmlReader, IXmlLineInfo
|
|
{
|
|
#region Constructors
|
|
|
|
protected XmlTextReader ()
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (Stream input)
|
|
: this (new XmlStreamReader (input))
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url)
|
|
: this(url, new NameTable ())
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (TextReader input)
|
|
: this (input, new NameTable ())
|
|
{
|
|
}
|
|
|
|
protected XmlTextReader (XmlNameTable nt)
|
|
: this (String.Empty, null, XmlNodeType.None, null)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (Stream input, XmlNameTable nt)
|
|
: this(new XmlStreamReader (input), nt)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url, Stream input)
|
|
: this (url, new XmlStreamReader (input))
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url, TextReader input)
|
|
: this (url, input, new NameTable ())
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url, XmlNameTable nt)
|
|
: this (url, new XmlStreamReader (url, null, null), nt)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (TextReader input, XmlNameTable nt)
|
|
: this (String.Empty, input, nt)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
|
|
: this (context != null ? context.BaseURI : String.Empty,
|
|
new XmlStreamReader (xmlFragment),
|
|
fragType,
|
|
context)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url, Stream input, XmlNameTable nt)
|
|
: this (url, new XmlStreamReader (input), nt)
|
|
{
|
|
}
|
|
|
|
public XmlTextReader (string url, TextReader input, XmlNameTable nt)
|
|
: this (url, input, XmlNodeType.Document, null)
|
|
{
|
|
}
|
|
|
|
[MonoTODO("TODO as same as private XmlTextReader(TextReader, XmlNodeType, XmlParserContext)")]
|
|
public XmlTextReader (string xmlFragment, XmlNodeType fragType, XmlParserContext context)
|
|
: this (context != null ? context.BaseURI : String.Empty,
|
|
new StringReader (xmlFragment),
|
|
fragType,
|
|
context)
|
|
{
|
|
}
|
|
|
|
// TODO still remains as described at head of this file,
|
|
// but it might not be TODO of the constructors...
|
|
XmlTextReader (string url, TextReader fragment, XmlNodeType fragType, XmlParserContext context)
|
|
{
|
|
InitializeContext (url, context, fragment, fragType);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public override int AttributeCount
|
|
{
|
|
get { return attributes.Count; }
|
|
}
|
|
|
|
public override string BaseURI
|
|
{
|
|
get { return parserContext.BaseURI; }
|
|
}
|
|
|
|
public override int Depth
|
|
{
|
|
get {
|
|
return elementDepth;
|
|
}
|
|
}
|
|
|
|
public Encoding Encoding
|
|
{
|
|
get { return parserContext.Encoding; }
|
|
}
|
|
|
|
public override bool EOF
|
|
{
|
|
get
|
|
{
|
|
return
|
|
readState == ReadState.EndOfFile ||
|
|
readState == ReadState.Closed;
|
|
}
|
|
}
|
|
|
|
public override bool HasValue
|
|
{
|
|
get {
|
|
if (this.valueBuilderAvailable)
|
|
return valueBuilder.Length != 0;
|
|
else
|
|
return value != String.Empty;
|
|
}
|
|
}
|
|
|
|
public override bool IsDefault
|
|
{
|
|
get
|
|
{
|
|
// XmlTextReader does not expand default attributes.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override bool IsEmptyElement
|
|
{
|
|
get { return isEmptyElement; }
|
|
}
|
|
|
|
public override string this [int i]
|
|
{
|
|
get { return GetAttribute (i); }
|
|
}
|
|
|
|
public override string this [string name]
|
|
{
|
|
get { return GetAttribute (name); }
|
|
}
|
|
|
|
public override string this [string localName, string namespaceName]
|
|
{
|
|
get { return GetAttribute (localName, namespaceName); }
|
|
}
|
|
|
|
public int LineNumber
|
|
{
|
|
get { return currentInput.LineNumber; }
|
|
}
|
|
|
|
public int LinePosition
|
|
{
|
|
get { return currentInput.LinePosition; }
|
|
}
|
|
|
|
public override string LocalName
|
|
{
|
|
get { return localName; }
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get { return name; }
|
|
}
|
|
|
|
public bool Namespaces
|
|
{
|
|
get { return namespaces; }
|
|
set {
|
|
if (readState != ReadState.Initial)
|
|
throw new InvalidOperationException ("Namespaces have to be set before reading.");
|
|
namespaces = value;
|
|
}
|
|
}
|
|
|
|
public override string NamespaceURI
|
|
{
|
|
get { return namespaceURI; }
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get { return parserContext.NameTable; }
|
|
}
|
|
|
|
public override XmlNodeType NodeType
|
|
{
|
|
get { return nodeType; }
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool Normalization
|
|
{
|
|
get { return normalization; }
|
|
set { normalization = value; }
|
|
}
|
|
|
|
public override string Prefix
|
|
{
|
|
get { return prefix; }
|
|
}
|
|
|
|
public override char QuoteChar
|
|
{
|
|
get {
|
|
// value string holds attribute quotation char.
|
|
if (NodeType == XmlNodeType.Attribute)
|
|
return value [0];
|
|
else
|
|
return '"';
|
|
}
|
|
}
|
|
|
|
public override ReadState ReadState
|
|
{
|
|
get { return readState; }
|
|
}
|
|
|
|
public override string Value
|
|
{
|
|
get {
|
|
|
|
string v = value;
|
|
if (valueBuilderAvailable)
|
|
v = valueBuilder.ToString ();
|
|
if(NodeType == XmlNodeType.Attribute)
|
|
return UnescapeAttributeValue(v);
|
|
else
|
|
return v;
|
|
}
|
|
}
|
|
|
|
public WhitespaceHandling WhitespaceHandling
|
|
{
|
|
get { return whitespaceHandling; }
|
|
set { whitespaceHandling = value; }
|
|
}
|
|
|
|
public override string XmlLang
|
|
{
|
|
get { return parserContext.XmlLang; }
|
|
}
|
|
|
|
public XmlResolver XmlResolver
|
|
{
|
|
set { resolver = value; }
|
|
}
|
|
|
|
public override XmlSpace XmlSpace
|
|
{
|
|
get { return parserContext.XmlSpace; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
public override void Close ()
|
|
{
|
|
readState = ReadState.Closed;
|
|
foreach (XmlParserInput input in parserInputStack.ToArray ())
|
|
input.Close ();
|
|
this.currentInput.Close ();
|
|
}
|
|
|
|
public override string GetAttribute (int i)
|
|
{
|
|
if (i > attributes.Count)
|
|
throw new ArgumentOutOfRangeException ("i is smaller than AttributeCount");
|
|
else
|
|
return UnescapeAttributeValue (attributes [orderedAttributes [i]] as string);
|
|
}
|
|
|
|
// MS.NET 1.0 documentation says that this method returns String.Empty for
|
|
// not-exist attribute, but in fact it returns null.
|
|
// That description is corrected in MS.NET 1.1 documentation.
|
|
public override string GetAttribute (string name)
|
|
{
|
|
return UnescapeAttributeValue (attributes [name] as string);
|
|
}
|
|
|
|
private int GetIndexOfQualifiedAttribute (string localName, string namespaceURI)
|
|
{
|
|
for(int i = 0; i < orderedAttributes.Count; i++)
|
|
{
|
|
string thisName = (string) orderedAttributes [i];
|
|
|
|
int indexOfColon = thisName.IndexOf (':');
|
|
|
|
if (indexOfColon != -1) {
|
|
string thisLocalName = thisName.Substring (indexOfColon + 1);
|
|
|
|
if (localName == thisLocalName) {
|
|
string thisPrefix = thisName.Substring (0, indexOfColon);
|
|
string thisNamespaceURI = LookupNamespace (thisPrefix);
|
|
|
|
if (namespaceURI == thisNamespaceURI)
|
|
return i;
|
|
}
|
|
} else if (localName == "xmlns" && namespaceURI == "http://www.w3.org/2000/xmlns/" && thisName == "xmlns")
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
internal XmlParserContext GetInternalParserContext ()
|
|
{
|
|
return parserContext;
|
|
}
|
|
|
|
public override string GetAttribute (string localName, string namespaceURI)
|
|
{
|
|
int idx = this.GetIndexOfQualifiedAttribute (localName, namespaceURI);
|
|
if (idx < 0)
|
|
return null;
|
|
return UnescapeAttributeValue (attributes [orderedAttributes [idx]] as string);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public TextReader GetRemainder ()
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
bool IXmlLineInfo.HasLineInfo ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override string LookupNamespace (string prefix)
|
|
{
|
|
return parserContext.NamespaceManager.LookupNamespace (prefix);
|
|
}
|
|
|
|
public override void MoveToAttribute (int i)
|
|
{
|
|
MoveToElement ();
|
|
|
|
if (attributes == null || orderedAttributes.Count < i || i < 0)
|
|
throw new ArgumentOutOfRangeException ("attribute index out of range.");
|
|
|
|
if (orderedAttributesEnumerator == null) {
|
|
SaveProperties ();
|
|
}
|
|
|
|
orderedAttributesEnumerator = orderedAttributes.GetEnumerator ();
|
|
for (int n=0; n<=i; n++)
|
|
orderedAttributesEnumerator.MoveNext();
|
|
|
|
string name = orderedAttributes [i] as string;
|
|
string value = attributes [name] as string;
|
|
SetProperties (
|
|
XmlNodeType.Attribute, // nodeType
|
|
name, // name
|
|
false, // isEmptyElement
|
|
value, // value
|
|
false // clearAttributes
|
|
);
|
|
attributeValuePos = 0;
|
|
}
|
|
|
|
public override bool MoveToAttribute (string name)
|
|
{
|
|
MoveToElement ();
|
|
bool match = false;
|
|
|
|
if (attributes == null)
|
|
return false;
|
|
|
|
if (orderedAttributesEnumerator == null) {
|
|
SaveProperties ();
|
|
}
|
|
|
|
orderedAttributesEnumerator = orderedAttributes.GetEnumerator ();
|
|
while (orderedAttributesEnumerator.MoveNext ()) {
|
|
if(name == orderedAttributesEnumerator.Current as string) {
|
|
match = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (match) {
|
|
string value = attributes [name] as string;
|
|
SetProperties (
|
|
XmlNodeType.Attribute, // nodeType
|
|
name, // name
|
|
false, // isEmptyElement
|
|
value, // value
|
|
false // clearAttributes
|
|
);
|
|
attributeValuePos = 0;
|
|
}
|
|
|
|
return match;
|
|
}
|
|
|
|
public override bool MoveToAttribute (string localName, string namespaceName)
|
|
{
|
|
MoveToElement ();
|
|
|
|
if (attributes == null)
|
|
return false;
|
|
|
|
int idx = GetIndexOfQualifiedAttribute (localName, namespaceName);
|
|
if (idx < 0)
|
|
return false;
|
|
MoveToAttribute (idx);
|
|
return true;
|
|
}
|
|
|
|
public override bool MoveToElement ()
|
|
{
|
|
if (orderedAttributesEnumerator != null) {
|
|
orderedAttributesEnumerator = null;
|
|
if (isPropertySaved)
|
|
RestoreProperties ();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute ()
|
|
{
|
|
MoveToElement ();
|
|
return MoveToNextAttribute ();
|
|
}
|
|
|
|
public override bool MoveToNextAttribute ()
|
|
{
|
|
if (attributes == null)
|
|
return false;
|
|
|
|
if (orderedAttributesEnumerator == null) {
|
|
SaveProperties ();
|
|
orderedAttributesEnumerator = orderedAttributes.GetEnumerator ();
|
|
}
|
|
|
|
if (orderedAttributesEnumerator.MoveNext ()) {
|
|
string name = orderedAttributesEnumerator.Current as string;
|
|
string value = attributes [name] as string;
|
|
SetProperties (
|
|
XmlNodeType.Attribute, // nodeType
|
|
name, // name
|
|
false, // isEmptyElement
|
|
value, // value
|
|
false // clearAttributes
|
|
);
|
|
attributeValuePos = 0;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool Read ()
|
|
{
|
|
bool more = false;
|
|
isPropertySaved = false;
|
|
readState = ReadState.Interactive;
|
|
|
|
// It was moved from end of ReadStartTag ().
|
|
if (depthUp)
|
|
++depth;
|
|
depthUp = false;
|
|
|
|
more = ReadContent ();
|
|
|
|
if (depth == 0 && !allowMultipleRoot && (IsEmptyElement || NodeType == XmlNodeType.EndElement))
|
|
currentState = XmlNodeType.EndElement;
|
|
if (maybeTextDecl != 0)
|
|
maybeTextDecl--;
|
|
|
|
if (!more && startNodeType == XmlNodeType.Document && currentState != XmlNodeType.EndElement)
|
|
throw new XmlException ("Document element was not appeared.");
|
|
|
|
return more;
|
|
}
|
|
|
|
public override bool ReadAttributeValue ()
|
|
{
|
|
// 'attributeString' holds real string value (without their
|
|
// quotation characters).
|
|
//
|
|
// 'attributeValuePos' holds current position
|
|
// of 'attributeString' while iterating ReadAttribute().
|
|
// It may be:
|
|
// -1 if ReadAttributeValue() has already finished.
|
|
// 0 if ReadAttributeValue() ready to start reading.
|
|
// >0 if ReadAttributeValue() already got 1 or more values
|
|
//
|
|
// local 'refPosition' holds the position on the
|
|
// attributeString which may be used next time.
|
|
|
|
if (attributeValuePos < 0)
|
|
return false;
|
|
|
|
// If not started, then initialize attributeString when parsing is at start.
|
|
if (attributeValuePos == 0)
|
|
attributeString =
|
|
value.Substring (1, value.Length - 2);
|
|
|
|
// It occurs when attribute dully consists of entity reference.
|
|
if (attributeValuePos == attributeString.Length)
|
|
return false;
|
|
|
|
returnEntityReference = false;
|
|
value = String.Empty;
|
|
int refPosition;
|
|
int loop = 0;
|
|
|
|
do {
|
|
refPosition = attributeString.IndexOf ('&', attributeValuePos);
|
|
if (refPosition < 0) {
|
|
// Reached to the end of value string.
|
|
value += attributeString.Substring (attributeValuePos);
|
|
attributeValuePos = -1;
|
|
break;
|
|
} else if (refPosition == attributeValuePos) {
|
|
string parsed = ReadAttributeValueReference ();
|
|
if (parsed != null)
|
|
value += parsed;
|
|
else {
|
|
// Found that an entity reference starts from this point.
|
|
// reset position to after '&'.
|
|
attributeValuePos = refPosition;
|
|
if (value.Length <= 0) {
|
|
int endNamePos = attributeString.IndexOf (";", attributeValuePos);
|
|
value = attributeString.Substring (attributeValuePos+1, endNamePos - attributeValuePos - 1);
|
|
attributeValuePos += value.Length + 2;
|
|
returnEntityReference = true;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
value += attributeString.Substring (attributeValuePos,
|
|
refPosition - attributeValuePos);
|
|
attributeValuePos = refPosition;
|
|
continue;
|
|
}
|
|
} while (++loop > 0);
|
|
|
|
if (returnEntityReference)
|
|
SetProperties (XmlNodeType.EntityReference,
|
|
value,
|
|
false,
|
|
String.Empty,
|
|
false);
|
|
else
|
|
SetProperties (XmlNodeType.Text,
|
|
"",
|
|
false,
|
|
value,
|
|
false);
|
|
|
|
returnEntityReference = false;
|
|
return true;
|
|
}
|
|
|
|
[MonoTODO]
|
|
public int ReadBase64 (byte [] buffer, int offset, int length)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public int ReadBinHex (byte [] buffer, int offset, int length)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public int ReadChars (char [] buffer, int offset, int length)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
#if NET_1_0
|
|
public override string ReadInnerXml ()
|
|
{
|
|
if (readState != ReadState.Interactive)
|
|
return String.Empty;
|
|
|
|
switch (NodeType) {
|
|
case XmlNodeType.Attribute:
|
|
return value.Substring (1, value.Length - 2);
|
|
case XmlNodeType.Element:
|
|
if (IsEmptyElement)
|
|
return String.Empty;
|
|
|
|
int startDepth = depth;
|
|
|
|
if (innerXmlBuilder == null)
|
|
innerXmlBuilder = new StringBuilder ();
|
|
innerXmlBuilder.Length = 0;
|
|
bool loop = true;
|
|
do {
|
|
Read ();
|
|
if (NodeType ==XmlNodeType.None)
|
|
throw new XmlException ("unexpected end of xml.");
|
|
else if (NodeType == XmlNodeType.EndElement && depth == startDepth) {
|
|
loop = false;
|
|
Read ();
|
|
}
|
|
else
|
|
innerXmlBuilder.Append (currentTag);
|
|
} while (loop);
|
|
string xml = innerXmlBuilder.ToString ();
|
|
innerXmlBuilder.Length = 0;
|
|
return xml;
|
|
case XmlNodeType.None:
|
|
// MS document is incorrect. Seems not to progress.
|
|
return String.Empty;
|
|
default:
|
|
Read ();
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
public override string ReadOuterXml ()
|
|
{
|
|
if (readState != ReadState.Interactive)
|
|
return String.Empty;
|
|
|
|
switch (NodeType) {
|
|
case XmlNodeType.Attribute:
|
|
// strictly incompatible with MS... (it holds spaces attribute between name, value and "=" char (very trivial).
|
|
return String.Format ("{0}={1}{2}{1}", Name, QuoteChar, ReadInnerXml ());
|
|
case XmlNodeType.Element:
|
|
bool isEmpty = IsEmptyElement;
|
|
string startTag = currentTag.ToString ();
|
|
string name = Name;
|
|
|
|
if (NodeType == XmlNodeType.Element && !isEmpty)
|
|
return String.Format ("{0}{1}</{2}>", startTag, ReadInnerXml (), name);
|
|
else
|
|
return currentTag.ToString ();
|
|
case XmlNodeType.None:
|
|
// MS document is incorrect. Seems not to progress.
|
|
return String.Empty;
|
|
default:
|
|
Read ();
|
|
return String.Empty;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public override string ReadString ()
|
|
{
|
|
return ReadStringInternal ();
|
|
}
|
|
|
|
public void ResetState ()
|
|
{
|
|
Init ();
|
|
}
|
|
|
|
public override void ResolveEntity ()
|
|
{
|
|
// XmlTextReader does not resolve entities.
|
|
throw new InvalidOperationException ("XmlTextReader cannot resolve external entities.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internals
|
|
// Parsed DTD Objects
|
|
internal DTDObjectModel DTD {
|
|
get { return parserContext.Dtd; }
|
|
}
|
|
|
|
internal bool MaybeTextDecl {
|
|
set { if (value) this.maybeTextDecl = 2; }
|
|
}
|
|
#endregion
|
|
|
|
#region Privates
|
|
|
|
private XmlParserContext parserContext;
|
|
|
|
private XmlParserInput currentInput;
|
|
private Stack parserInputStack;
|
|
private ReadState readState;
|
|
|
|
private int depth;
|
|
private int elementDepth;
|
|
private bool depthUp;
|
|
|
|
private bool popScope;
|
|
private Stack elementStack;
|
|
private bool allowMultipleRoot;
|
|
|
|
private bool isStandalone;
|
|
|
|
private XmlNodeType nodeType;
|
|
private string name;
|
|
private string prefix;
|
|
private string localName;
|
|
private string namespaceURI;
|
|
private bool isEmptyElement;
|
|
private string value;
|
|
private StringBuilder valueBuilder;
|
|
private bool valueBuilderAvailable = false;
|
|
|
|
private bool isPropertySaved;
|
|
private XmlNodeType saveNodeType;
|
|
private string saveName;
|
|
private string savePrefix;
|
|
private string saveLocalName;
|
|
private string saveNamespaceURI;
|
|
private bool saveIsEmptyElement;
|
|
|
|
private Hashtable attributes;
|
|
private ArrayList orderedAttributes;
|
|
private IEnumerator orderedAttributesEnumerator;
|
|
|
|
private bool returnEntityReference;
|
|
private string entityReferenceName;
|
|
|
|
private char [] nameBuffer;
|
|
private int nameLength;
|
|
private int nameCapacity;
|
|
private const int initialNameCapacity = 256;
|
|
|
|
private StringBuilder valueBuffer;
|
|
|
|
// A buffer for ReadContent for ReadOuterXml
|
|
private StringBuilder currentTag {
|
|
get {
|
|
return currentInput.CurrentMarkup;
|
|
}
|
|
}
|
|
|
|
private string attributeString;
|
|
private int attributeValuePos;
|
|
// This should be only referenced(used) by ReadInnerXml(). Kind of flyweight pattern.
|
|
private StringBuilder innerXmlBuilder;
|
|
|
|
// Parameter entity placeholder
|
|
private Hashtable parameterEntities;
|
|
private int dtdIncludeSect;
|
|
|
|
private XmlNodeType startNodeType;
|
|
// State machine attribute.
|
|
// XmlDeclaration: after the first node.
|
|
// DocumentType: after doctypedecl
|
|
// Element: inside document element
|
|
// EndElement: after document element
|
|
private XmlNodeType currentState;
|
|
private int maybeTextDecl;
|
|
|
|
// These values are never re-initialized.
|
|
private XmlResolver resolver = new XmlUrlResolver ();
|
|
private bool namespaces = true;
|
|
private WhitespaceHandling whitespaceHandling = WhitespaceHandling.All;
|
|
private bool normalization = false;
|
|
|
|
private void Init ()
|
|
{
|
|
readState = ReadState.Initial;
|
|
currentState = XmlNodeType.None;
|
|
maybeTextDecl = 0;
|
|
allowMultipleRoot = false;
|
|
|
|
depth = 0;
|
|
depthUp = false;
|
|
|
|
popScope = false;
|
|
parserInputStack = new Stack ();
|
|
elementStack = new Stack();
|
|
|
|
nodeType = XmlNodeType.None;
|
|
name = String.Empty;
|
|
prefix = String.Empty;
|
|
localName = string.Empty;
|
|
isEmptyElement = false;
|
|
value = String.Empty;
|
|
|
|
attributes = new Hashtable ();
|
|
attributeString = String.Empty;
|
|
orderedAttributes = new ArrayList ();
|
|
orderedAttributesEnumerator = null;
|
|
|
|
returnEntityReference = false;
|
|
entityReferenceName = String.Empty;
|
|
|
|
nameBuffer = new char [initialNameCapacity];
|
|
nameLength = 0;
|
|
nameCapacity = initialNameCapacity;
|
|
|
|
valueBuffer = new StringBuilder (8192);
|
|
parameterEntities = new Hashtable ();
|
|
}
|
|
|
|
private void InitializeContext (string url, XmlParserContext context, TextReader fragment, XmlNodeType fragType)
|
|
{
|
|
startNodeType = fragType;
|
|
parserContext = context;
|
|
if (context == null) {
|
|
XmlNameTable nt = new NameTable ();
|
|
parserContext = new XmlParserContext (nt,
|
|
new XmlNamespaceManager (nt),
|
|
String.Empty,
|
|
XmlSpace.None);
|
|
}
|
|
|
|
if (url != null && url != String.Empty) {
|
|
string path = Path.GetFullPath ("./a");
|
|
Uri uri = new Uri (new Uri (path), url);
|
|
parserContext.BaseURI = uri.ToString ();
|
|
}
|
|
|
|
Init ();
|
|
|
|
switch (fragType) {
|
|
case XmlNodeType.Attribute:
|
|
value = String.Format ("{0}{1}{0}", "'", fragment.ReadToEnd ().Replace ("'", "'"));
|
|
break;
|
|
case XmlNodeType.Element:
|
|
currentState = XmlNodeType.Element;
|
|
allowMultipleRoot = true;
|
|
break;
|
|
case XmlNodeType.Document:
|
|
break;
|
|
default:
|
|
throw new XmlException (String.Format ("NodeType {0} is not allowed to create XmlTextReader.", fragType));
|
|
}
|
|
|
|
this.currentInput = new XmlParserInput (fragment, url);
|
|
StreamReader sr = fragment as StreamReader;
|
|
}
|
|
|
|
// Use this method rather than setting the properties
|
|
// directly so that all the necessary properties can
|
|
// be changed in harmony with each other. Maybe the
|
|
// fields should be in a seperate class to help enforce
|
|
// this.
|
|
private void SetProperties (
|
|
XmlNodeType nodeType,
|
|
string name,
|
|
bool isEmptyElement,
|
|
string value,
|
|
bool clearAttributes)
|
|
{
|
|
this.nodeType = nodeType;
|
|
this.name = name;
|
|
this.isEmptyElement = isEmptyElement;
|
|
this.value = value;
|
|
this.elementDepth = depth;
|
|
this.valueBuilderAvailable = false;
|
|
|
|
if (clearAttributes)
|
|
ClearAttributes ();
|
|
|
|
if (namespaces) {
|
|
int indexOfColon = name.IndexOf (':');
|
|
|
|
if (indexOfColon == -1) {
|
|
prefix = String.Empty;
|
|
localName = name;
|
|
} else {
|
|
prefix = name.Substring (0, indexOfColon);
|
|
localName = name.Substring (indexOfColon + 1);
|
|
}
|
|
} else {
|
|
prefix = String.Empty;
|
|
localName = name;
|
|
}
|
|
|
|
switch (nodeType) {
|
|
case XmlNodeType.Attribute:
|
|
if (prefix == string.Empty) namespaceURI = string.Empty;
|
|
else namespaceURI = LookupNamespace (prefix);
|
|
if (localName == "xmlns" && prefix == "")
|
|
namespaceURI = "http://www.w3.org/2000/xmlns/";
|
|
break;
|
|
|
|
case XmlNodeType.Element:
|
|
case XmlNodeType.EndElement:
|
|
namespaceURI = LookupNamespace (prefix);
|
|
break;
|
|
default:
|
|
namespaceURI = "";
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void SetProperties (
|
|
XmlNodeType nodeType,
|
|
string name,
|
|
bool isEmptyElement,
|
|
StringBuilder value,
|
|
bool clearAttributes) {
|
|
SetProperties (nodeType, name, isEmptyElement, (string)null, clearAttributes);
|
|
this.valueBuilderAvailable = true;
|
|
this.valueBuilder = value;
|
|
}
|
|
|
|
private void SaveProperties ()
|
|
{
|
|
// If already saved, then return.
|
|
if (isPropertySaved)
|
|
return;
|
|
|
|
saveNodeType = nodeType;
|
|
saveName = name;
|
|
savePrefix = prefix;
|
|
saveLocalName = localName;
|
|
saveNamespaceURI = namespaceURI;
|
|
saveIsEmptyElement = isEmptyElement;
|
|
// An element's value is always String.Empty.
|
|
isPropertySaved = true;
|
|
}
|
|
|
|
private void RestoreProperties ()
|
|
{
|
|
nodeType = saveNodeType;
|
|
name = saveName;
|
|
prefix = savePrefix;
|
|
localName = saveLocalName;
|
|
namespaceURI = saveNamespaceURI;
|
|
isEmptyElement = saveIsEmptyElement;
|
|
value = String.Empty;
|
|
isPropertySaved = false;
|
|
}
|
|
|
|
private void AddAttribute (string name, string value)
|
|
{
|
|
if (attributes.ContainsKey (name))
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
String.Format ("Attribute {0} already exists.", name));
|
|
attributes.Add (name, value);
|
|
orderedAttributes.Add (name);
|
|
}
|
|
|
|
private void ClearAttributes ()
|
|
{
|
|
if (attributes.Count > 0) {
|
|
attributes.Clear ();
|
|
orderedAttributes.Clear ();
|
|
}
|
|
|
|
orderedAttributesEnumerator = null;
|
|
}
|
|
|
|
private int PeekChar ()
|
|
{
|
|
return currentInput.PeekChar ();
|
|
}
|
|
|
|
private int ReadChar ()
|
|
{
|
|
return currentInput.ReadChar ();
|
|
}
|
|
|
|
// This should really keep track of some state so
|
|
// that it's not possible to have more than one document
|
|
// element or text outside of the document element.
|
|
private bool ReadContent ()
|
|
{
|
|
currentTag.Length = 0;
|
|
if (popScope) {
|
|
parserContext.NamespaceManager.PopScope ();
|
|
popScope = false;
|
|
}
|
|
|
|
if (returnEntityReference)
|
|
SetEntityReferenceProperties ();
|
|
else {
|
|
switch (PeekChar ()) {
|
|
case '<':
|
|
ReadChar ();
|
|
ReadTag ();
|
|
break;
|
|
case '\r': goto case ' ';
|
|
case '\n': goto case ' ';
|
|
case '\t': goto case ' ';
|
|
case ' ':
|
|
if (whitespaceHandling == WhitespaceHandling.All ||
|
|
whitespaceHandling == WhitespaceHandling.Significant)
|
|
ReadWhitespace ();
|
|
else {
|
|
SkipWhitespace ();
|
|
return ReadContent ();
|
|
}
|
|
break;
|
|
case -1:
|
|
if (depth > 0)
|
|
throw new XmlException ("unexpected end of file. Current depth is " + depth);
|
|
readState = ReadState.EndOfFile;
|
|
SetProperties (
|
|
XmlNodeType.None, // nodeType
|
|
String.Empty, // name
|
|
false, // isEmptyElement
|
|
String.Empty, // value
|
|
true // clearAttributes
|
|
);
|
|
break;
|
|
default:
|
|
ReadText (true);
|
|
break;
|
|
}
|
|
}
|
|
if (NodeType == XmlNodeType.XmlDeclaration && maybeTextDecl == 1)
|
|
return ReadContent ();
|
|
return this.ReadState != ReadState.EndOfFile;
|
|
}
|
|
|
|
private void SetEntityReferenceProperties ()
|
|
{
|
|
/*
|
|
if (resolver != null) {
|
|
if (DTD == null)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Entity reference is not allowed without document type declaration.");
|
|
else if((!DTD.InternalSubsetHasPEReference || isStandalone) &&
|
|
DTD.EntityDecls [entityReferenceName] == null)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Required entity declaration for '" + entityReferenceName + "' was not found.");
|
|
string dummy = DTD.EntityDecls [entityReferenceName].EntityValue;
|
|
}
|
|
*/
|
|
SetProperties (
|
|
XmlNodeType.EntityReference, // nodeType
|
|
entityReferenceName, // name
|
|
false, // isEmptyElement
|
|
String.Empty, // value
|
|
true // clearAttributes
|
|
);
|
|
|
|
returnEntityReference = false;
|
|
entityReferenceName = String.Empty;
|
|
}
|
|
|
|
// The leading '<' has already been consumed.
|
|
private void ReadTag ()
|
|
{
|
|
switch (PeekChar ())
|
|
{
|
|
case '/':
|
|
ReadChar ();
|
|
ReadEndTag ();
|
|
break;
|
|
case '?':
|
|
ReadChar ();
|
|
ReadProcessingInstruction ();
|
|
break;
|
|
case '!':
|
|
ReadChar ();
|
|
ReadDeclaration ();
|
|
break;
|
|
default:
|
|
ReadStartTag ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// The leading '<' has already been consumed.
|
|
private void ReadStartTag ()
|
|
{
|
|
if (currentState == XmlNodeType.EndElement)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Element cannot appear in this state.");
|
|
currentState = XmlNodeType.Element;
|
|
|
|
parserContext.NamespaceManager.PushScope ();
|
|
|
|
string name = ReadName ();
|
|
if (currentState == XmlNodeType.EndElement)
|
|
throw new XmlException (this as IXmlLineInfo,"document has terminated, cannot open new element");
|
|
|
|
bool isEmptyElement = false;
|
|
|
|
ClearAttributes ();
|
|
|
|
SkipWhitespace ();
|
|
if (XmlChar.IsFirstNameChar (PeekChar ()))
|
|
ReadAttributes (false);
|
|
|
|
string baseUri = GetAttribute ("xml:base");
|
|
if (baseUri != null)
|
|
parserContext.BaseURI = baseUri;
|
|
string xmlLang = GetAttribute ("xml:lang");
|
|
if (xmlLang != null)
|
|
parserContext.XmlLang = xmlLang;
|
|
string xmlSpaceAttr = GetAttribute ("xml:space");
|
|
if (xmlSpaceAttr != null) {
|
|
if (xmlSpaceAttr == "preserve")
|
|
parserContext.XmlSpace = XmlSpace.Preserve;
|
|
else if (xmlSpaceAttr == "default")
|
|
parserContext.XmlSpace = XmlSpace.Default;
|
|
else
|
|
throw new XmlException (this as IXmlLineInfo,String.Format ("Invalid xml:space value: {0}", xmlSpaceAttr));
|
|
}
|
|
if (PeekChar () == '/') {
|
|
ReadChar ();
|
|
isEmptyElement = true;
|
|
popScope = true;
|
|
}
|
|
else {
|
|
depthUp = true;
|
|
elementStack.Push (name);
|
|
parserContext.PushScope ();
|
|
}
|
|
|
|
Expect ('>');
|
|
|
|
SetProperties (
|
|
XmlNodeType.Element, // nodeType
|
|
name, // name
|
|
isEmptyElement, // isEmptyElement
|
|
String.Empty, // value
|
|
false // clearAttributes
|
|
);
|
|
}
|
|
|
|
// The reader is positioned on the first character
|
|
// of the element's name.
|
|
private void ReadEndTag ()
|
|
{
|
|
if (currentState != XmlNodeType.Element)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"End tag cannot appear in this state.");
|
|
|
|
string name = ReadName ();
|
|
if (elementStack.Count == 0)
|
|
throw new XmlException (this as IXmlLineInfo,"closing element without matching opening element");
|
|
string expected = (string)elementStack.Pop();
|
|
if (expected != name)
|
|
throw new XmlException (this as IXmlLineInfo,String.Format ("unmatched closing element: expected {0} but found {1}", expected, name));
|
|
parserContext.PopScope ();
|
|
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
|
|
--depth;
|
|
|
|
SetProperties (
|
|
XmlNodeType.EndElement, // nodeType
|
|
name, // name
|
|
false, // isEmptyElement
|
|
String.Empty, // value
|
|
true // clearAttributes
|
|
);
|
|
|
|
popScope = true;
|
|
}
|
|
|
|
private void AppendNameChar (int ch)
|
|
{
|
|
CheckNameCapacity ();
|
|
nameBuffer [nameLength++] = (char)ch;
|
|
}
|
|
|
|
private void CheckNameCapacity ()
|
|
{
|
|
if (nameLength == nameCapacity) {
|
|
nameCapacity = nameCapacity * 2;
|
|
char [] oldNameBuffer = nameBuffer;
|
|
nameBuffer = new char [nameCapacity];
|
|
Array.Copy (oldNameBuffer, nameBuffer, nameLength);
|
|
}
|
|
}
|
|
|
|
private string CreateNameString ()
|
|
{
|
|
return parserContext.NameTable.Add (nameBuffer, 0, nameLength);
|
|
}
|
|
|
|
private void AppendValueChar (int ch)
|
|
{
|
|
valueBuffer.Append ((char)ch);
|
|
}
|
|
|
|
private string CreateValueString ()
|
|
{
|
|
return valueBuffer.ToString ();
|
|
}
|
|
|
|
private void ClearValueBuffer ()
|
|
{
|
|
valueBuffer.Length = 0;
|
|
}
|
|
|
|
// The reader is positioned on the first character
|
|
// of the text.
|
|
private void ReadText (bool notWhitespace)
|
|
{
|
|
if (currentState != XmlNodeType.Element)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Text node cannot appear in this state.");
|
|
|
|
if (notWhitespace)
|
|
ClearValueBuffer ();
|
|
|
|
int ch = PeekChar ();
|
|
int previousCloseBracketLine = 0;
|
|
int previousCloseBracketColumn = 0;
|
|
|
|
while (ch != '<' && ch != -1) {
|
|
if (ch == '&') {
|
|
ReadChar ();
|
|
if (ReadReference (false))
|
|
break;
|
|
} else {
|
|
if (XmlConstructs.IsInvalid (ch))
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Not allowed character was found.");
|
|
AppendValueChar (ReadChar ());
|
|
if (ch == ']') {
|
|
if (previousCloseBracketColumn == LinePosition - 1 &&
|
|
previousCloseBracketLine == LineNumber)
|
|
if (PeekChar () == '>')
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Inside text content, character sequence ']]>' is not allowed.");
|
|
previousCloseBracketColumn = LinePosition;
|
|
previousCloseBracketLine = LineNumber;
|
|
}
|
|
}
|
|
ch = PeekChar ();
|
|
notWhitespace = true;
|
|
}
|
|
|
|
if (returnEntityReference && valueBuffer.Length == 0) {
|
|
SetEntityReferenceProperties ();
|
|
} else {
|
|
XmlNodeType nodeType = notWhitespace ?
|
|
XmlNodeType.Text : XmlNodeType.Whitespace;
|
|
SetProperties (
|
|
nodeType, // nodeType
|
|
String.Empty, // name
|
|
false, // isEmptyElement
|
|
valueBuffer, // value
|
|
true // clearAttributes
|
|
);
|
|
}
|
|
}
|
|
|
|
// The leading '&' has already been consumed.
|
|
// Returns true if the entity reference isn't a simple
|
|
// character reference or one of the predefined entities.
|
|
// This allows the ReadText method to break so that the
|
|
// next call to Read will return the EntityReference node.
|
|
private bool ReadReference (bool ignoreEntityReferences)
|
|
{
|
|
if (PeekChar () == '#') {
|
|
ReadChar ();
|
|
ReadCharacterReference ();
|
|
} else
|
|
ReadEntityReference (ignoreEntityReferences);
|
|
|
|
return returnEntityReference;
|
|
}
|
|
|
|
private void ReadCharacterReference ()
|
|
{
|
|
int value = 0;
|
|
|
|
if (PeekChar () == 'x') {
|
|
ReadChar ();
|
|
|
|
while (PeekChar () != ';' && PeekChar () != -1) {
|
|
int ch = ReadChar ();
|
|
|
|
if (ch >= '0' && ch <= '9')
|
|
value = (value << 4) + ch - '0';
|
|
else if (ch >= 'A' && ch <= 'F')
|
|
value = (value << 4) + ch - 'A' + 10;
|
|
else if (ch >= 'a' && ch <= 'f')
|
|
value = (value << 4) + ch - 'a' + 10;
|
|
else
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
String.Format (
|
|
"invalid hexadecimal digit: {0} (#x{1:X})",
|
|
(char)ch,
|
|
ch));
|
|
}
|
|
} else {
|
|
while (PeekChar () != ';' && PeekChar () != -1) {
|
|
int ch = ReadChar ();
|
|
|
|
if (ch >= '0' && ch <= '9')
|
|
value = value * 10 + ch - '0';
|
|
else
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
String.Format (
|
|
"invalid decimal digit: {0} (#x{1:X})",
|
|
(char)ch,
|
|
ch));
|
|
}
|
|
}
|
|
|
|
ReadChar (); // ';'
|
|
|
|
// FIXME: how to handle such chars larger than 0xffff?
|
|
if (value < 0xffff && !XmlConstructs.IsValid (value))
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Referenced character was not allowed in XML.");
|
|
AppendValueChar (value);
|
|
}
|
|
|
|
private void ReadEntityReference (bool ignoreEntityReferences)
|
|
{
|
|
nameLength = 0;
|
|
|
|
int ch = PeekChar ();
|
|
|
|
while (ch != ';' && ch != -1) {
|
|
AppendNameChar (ReadChar ());
|
|
ch = PeekChar ();
|
|
}
|
|
|
|
Expect (';');
|
|
|
|
string name = CreateNameString ();
|
|
if (!XmlChar.IsName (name))
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Invalid entity reference name was found.");
|
|
|
|
char predefined = XmlChar.GetPredefinedEntity (name);
|
|
if (predefined != 0)
|
|
AppendValueChar (predefined);
|
|
else {
|
|
if (ignoreEntityReferences) {
|
|
AppendValueChar ('&');
|
|
|
|
foreach (char ch2 in name) {
|
|
AppendValueChar (ch2);
|
|
}
|
|
|
|
AppendValueChar (';');
|
|
} else {
|
|
returnEntityReference = true;
|
|
entityReferenceName = name;
|
|
}
|
|
}
|
|
}
|
|
|
|
// The reader is positioned on the first character of
|
|
// the attribute name.
|
|
private void ReadAttributes (bool allowPIEnd)
|
|
{
|
|
int peekChar = -1;
|
|
bool requireWhitespace = false;
|
|
do {
|
|
if (!SkipWhitespace () && requireWhitespace)
|
|
throw new XmlException ("Unexpected token. Name is required here.");
|
|
string name = ReadName ();
|
|
SkipWhitespace ();
|
|
Expect ('=');
|
|
SkipWhitespace ();
|
|
string value = ReadAttribute (false);
|
|
|
|
if (name == "xmlns")
|
|
parserContext.NamespaceManager.AddNamespace (String.Empty, UnescapeAttributeValue (value));
|
|
else if (name.StartsWith ("xmlns:"))
|
|
parserContext.NamespaceManager.AddNamespace (name.Substring (6), UnescapeAttributeValue (value));
|
|
|
|
AddAttribute (name, value);
|
|
|
|
if (!SkipWhitespace ())
|
|
requireWhitespace = true;
|
|
peekChar = PeekChar ();
|
|
if (peekChar == '?' && allowPIEnd)
|
|
break;
|
|
} while (peekChar != '/' && peekChar != '>' && peekChar != -1);
|
|
}
|
|
|
|
// The reader is positioned on the quote character.
|
|
// *Keeps quote char* to value to get_QuoteChar() correctly.
|
|
private string ReadAttribute (bool isDefaultValue)
|
|
{
|
|
ClearValueBuffer ();
|
|
|
|
int quoteChar = ReadChar ();
|
|
|
|
if (quoteChar != '\'' && quoteChar != '\"')
|
|
throw new XmlException (this as IXmlLineInfo,"an attribute value was not quoted");
|
|
|
|
AppendValueChar (quoteChar);
|
|
|
|
while (PeekChar () != quoteChar) {
|
|
int ch = ReadChar ();
|
|
|
|
switch (ch)
|
|
{
|
|
case '<':
|
|
throw new XmlException (this as IXmlLineInfo,"attribute values cannot contain '<'");
|
|
case -1:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected end of file in an attribute value");
|
|
/*
|
|
case '&':
|
|
if (isDefaultValue) {
|
|
AppendValueChar (ch);
|
|
break;
|
|
}
|
|
AppendValueChar (ch);
|
|
if (PeekChar () == '#')
|
|
break;
|
|
// Check XML 1.0 section 3.1 WFC.
|
|
string entName = ReadName ();
|
|
Expect (';');
|
|
if (XmlChar.GetPredefinedEntity (entName) == 0) {
|
|
DTDEntityDeclaration entDecl =
|
|
DTD == null ? null : DTD.EntityDecls [entName];
|
|
if (entDecl == null || entDecl.SystemId != null)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Reference to external entities is not allowed in attribute value.");
|
|
}
|
|
valueBuffer.Append (entName);
|
|
AppendValueChar (';');
|
|
break;
|
|
*/
|
|
default:
|
|
AppendValueChar (ch);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ReadChar (); // quoteChar
|
|
AppendValueChar (quoteChar);
|
|
|
|
return CreateValueString ();
|
|
}
|
|
|
|
// The reader is positioned on the first character
|
|
// of the target.
|
|
//
|
|
// It may be xml declaration or processing instruction.
|
|
private void ReadProcessingInstruction ()
|
|
{
|
|
string target = ReadName ();
|
|
if (target == "xml") {
|
|
ReadXmlDeclaration ();
|
|
return;
|
|
} else if (target.ToLower () == "xml")
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Not allowed processing instruction name which starts with 'X', 'M', 'L' was found.");
|
|
|
|
if (currentState == XmlNodeType.None)
|
|
currentState = XmlNodeType.XmlDeclaration;
|
|
|
|
if (!SkipWhitespace ())
|
|
if (PeekChar () != '?')
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Invalid processing instruction name was found.");
|
|
|
|
ClearValueBuffer ();
|
|
|
|
while (PeekChar () != -1) {
|
|
int ch = ReadChar ();
|
|
|
|
if (ch == '?' && PeekChar () == '>') {
|
|
ReadChar ();
|
|
break;
|
|
}
|
|
|
|
AppendValueChar ((char)ch);
|
|
}
|
|
|
|
SetProperties (
|
|
XmlNodeType.ProcessingInstruction, // nodeType
|
|
target, // name
|
|
false, // isEmptyElement
|
|
valueBuffer, // value
|
|
true // clearAttributes
|
|
);
|
|
}
|
|
|
|
// The reader is positioned after "<?xml "
|
|
private void ReadXmlDeclaration ()
|
|
{
|
|
if (currentState != XmlNodeType.None) {
|
|
if (maybeTextDecl == 0)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"XML declaration cannot appear in this state.");
|
|
}
|
|
// Is this required?
|
|
// if (maybeTextDecl != 0)
|
|
// currentState = XmlNodeType.XmlDeclaration;
|
|
|
|
ClearAttributes ();
|
|
|
|
ReadAttributes (true); // They must have "version."
|
|
string version = (string) attributes ["version"];
|
|
if (version != null)
|
|
version = version.Substring (1, version.Length - 2);
|
|
|
|
string message = null;
|
|
if (parserInputStack.Count == 0) {
|
|
if (maybeTextDecl == 0 && (orderedAttributes [0] as string != "version" || version != "1.0"))
|
|
message = "Version 1.0 declaration is required in XML Declaration.";
|
|
else if (orderedAttributes.Count > 1 &&
|
|
(orderedAttributes [1] as string != "encoding" &&
|
|
orderedAttributes [1] as string != "standalone"))
|
|
message = "Invalid Xml Declaration markup was found.";
|
|
else if (orderedAttributes.Count > 2 && orderedAttributes [2] as string != "standalone")
|
|
message = "Invalid Xml Declaration markup was found.";
|
|
string sa = attributes ["standalone"] as string;
|
|
if (sa != null)
|
|
sa = sa.Substring (1, sa.Length - 2);
|
|
if (sa != null && sa != "yes" && sa != "no")
|
|
message = "Only 'yes' or 'no' is allowed for standalone.";
|
|
|
|
this.isStandalone = (sa == "yes");
|
|
} else {
|
|
int currentCheck = 0;
|
|
if (orderedAttributes [0] as string == "version") {
|
|
if (version != "1.0")
|
|
message = "Version 1.0 declaration is required in Text Declaration.";
|
|
currentCheck = 1;
|
|
}
|
|
if (orderedAttributes.Count <= currentCheck || orderedAttributes [currentCheck] as string != "encoding")
|
|
message = "Invalid Text Declaration markup was found. encoding specification is required.";
|
|
}
|
|
if (message != null)
|
|
throw new XmlException (this as IXmlLineInfo, message);
|
|
|
|
Expect ("?>");
|
|
|
|
if (maybeTextDecl != 0)
|
|
if (this ["standalone"] != null)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Invalid text declaration.");
|
|
if (maybeTextDecl == 2)
|
|
maybeTextDecl = 1;
|
|
|
|
SetProperties (
|
|
XmlNodeType.XmlDeclaration, // nodeType
|
|
"xml", // name
|
|
false, // isEmptyElement
|
|
currentInput.CurrentMarkup.ToString (6, currentInput.CurrentMarkup.Length - 6), // value
|
|
false // clearAttributes
|
|
);
|
|
}
|
|
|
|
// The reader is positioned on the first character after
|
|
// the leading '<!'.
|
|
private void ReadDeclaration ()
|
|
{
|
|
int ch = PeekChar ();
|
|
|
|
switch (ch)
|
|
{
|
|
case '-':
|
|
Expect ("--");
|
|
ReadComment ();
|
|
break;
|
|
case '[':
|
|
ReadChar ();
|
|
Expect ("CDATA[");
|
|
ReadCDATA ();
|
|
break;
|
|
case 'D':
|
|
Expect ("DOCTYPE");
|
|
ReadDoctypeDecl ();
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Unexpected declaration markup was found.");
|
|
}
|
|
}
|
|
|
|
// The reader is positioned on the first character after
|
|
// the leading '<!--'.
|
|
private void ReadComment ()
|
|
{
|
|
if (currentState == XmlNodeType.None)
|
|
currentState = XmlNodeType.XmlDeclaration;
|
|
|
|
ClearValueBuffer ();
|
|
|
|
while (PeekChar () != -1) {
|
|
int ch = ReadChar ();
|
|
|
|
if (ch == '-' && PeekChar () == '-') {
|
|
ReadChar ();
|
|
|
|
if (PeekChar () != '>')
|
|
throw new XmlException (this as IXmlLineInfo,"comments cannot contain '--'");
|
|
|
|
ReadChar ();
|
|
break;
|
|
}
|
|
|
|
if (XmlConstructs.IsInvalid (ch))
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Not allowed character was found.");
|
|
|
|
AppendValueChar ((char)ch);
|
|
}
|
|
|
|
SetProperties (
|
|
XmlNodeType.Comment, // nodeType
|
|
String.Empty, // name
|
|
false, // isEmptyElement
|
|
valueBuffer, // value
|
|
true // clearAttributes
|
|
);
|
|
}
|
|
|
|
// The reader is positioned on the first character after
|
|
// the leading '<![CDATA['.
|
|
private void ReadCDATA ()
|
|
{
|
|
if (currentState != XmlNodeType.Element)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"CDATA section cannot appear in this state.");
|
|
|
|
ClearValueBuffer ();
|
|
|
|
bool skip = false;
|
|
int ch = 0;
|
|
while (PeekChar () != -1) {
|
|
if (!skip)
|
|
ch = ReadChar ();
|
|
skip = false;
|
|
|
|
if (ch == ']' && PeekChar () == ']') {
|
|
ch = ReadChar (); // ']'
|
|
|
|
if (PeekChar () == '>') {
|
|
ReadChar (); // '>'
|
|
break;
|
|
} else {
|
|
skip = true;
|
|
// AppendValueChar (']');
|
|
// AppendValueChar (']');
|
|
// ch = ReadChar ();
|
|
}
|
|
}
|
|
|
|
AppendValueChar ((char)ch);
|
|
}
|
|
|
|
SetProperties (
|
|
XmlNodeType.CDATA, // nodeType
|
|
String.Empty, // name
|
|
false, // isEmptyElement
|
|
valueBuffer, // value
|
|
true // clearAttributes
|
|
);
|
|
}
|
|
|
|
// The reader is positioned on the first character after
|
|
// the leading '<!DOCTYPE'.
|
|
private void ReadDoctypeDecl ()
|
|
{
|
|
switch (currentState) {
|
|
case XmlNodeType.DocumentType:
|
|
case XmlNodeType.Element:
|
|
case XmlNodeType.EndElement:
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Document type cannot appear in this state.");
|
|
}
|
|
currentState = XmlNodeType.DocumentType;
|
|
|
|
string doctypeName = null;
|
|
string publicId = null;
|
|
string systemId = null;
|
|
int intSubsetStartLine = 0;
|
|
int intSubsetStartColumn = 0;
|
|
|
|
SkipWhitespace ();
|
|
doctypeName = ReadName ();
|
|
SkipWhitespace ();
|
|
switch(PeekChar ())
|
|
{
|
|
case 'S':
|
|
systemId = ReadSystemLiteral (true);
|
|
break;
|
|
case 'P':
|
|
publicId = ReadPubidLiteral ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between PUBLIC id and SYSTEM id.");
|
|
systemId = ReadSystemLiteral (false);
|
|
break;
|
|
}
|
|
SkipWhitespace ();
|
|
|
|
|
|
if(PeekChar () == '[')
|
|
{
|
|
// read markupdecl etc. or end of decl
|
|
ReadChar ();
|
|
intSubsetStartLine = this.LineNumber;
|
|
intSubsetStartColumn = this.LinePosition;
|
|
int startPos = currentTag.Length;
|
|
ReadInternalSubset ();
|
|
int endPos = currentTag.Length - 1;
|
|
parserContext.InternalSubset = currentTag.ToString (startPos, endPos - startPos);
|
|
}
|
|
// end of DOCTYPE decl.
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
|
|
GenerateDTDObjectModel (doctypeName, publicId,
|
|
systemId, parserContext.InternalSubset,
|
|
intSubsetStartLine, intSubsetStartColumn);
|
|
|
|
// set properties for <!DOCTYPE> node
|
|
SetProperties (
|
|
XmlNodeType.DocumentType, // nodeType
|
|
doctypeName, // name
|
|
false, // isEmptyElement
|
|
parserContext.InternalSubset, // value
|
|
true // clearAttributes
|
|
);
|
|
}
|
|
|
|
internal DTDObjectModel GenerateDTDObjectModel (string name, string publicId,
|
|
string systemId, string internalSubset)
|
|
{
|
|
return GenerateDTDObjectModel (name, publicId, systemId, internalSubset, 0, 0);
|
|
}
|
|
|
|
internal DTDObjectModel GenerateDTDObjectModel (string name, string publicId,
|
|
string systemId, string internalSubset, int intSubsetStartLine, int intSubsetStartColumn)
|
|
{
|
|
// now compile DTD
|
|
parserContext.Dtd = new DTDObjectModel (); // merges both internal and external subsets in the meantime,
|
|
DTD.BaseURI = BaseURI;
|
|
DTD.Name = name;
|
|
DTD.PublicId = publicId;
|
|
DTD.SystemId = systemId;
|
|
DTD.InternalSubset = internalSubset;
|
|
DTD.XmlResolver = resolver;
|
|
int originalParserDepth = parserInputStack.Count;
|
|
if (internalSubset != null && internalSubset.Length > 0) {
|
|
XmlParserInput original = currentInput;
|
|
currentInput = new XmlParserInput (new StringReader (internalSubset), BaseURI, intSubsetStartLine, intSubsetStartColumn);
|
|
do {
|
|
CompileDTDSubset ();
|
|
if (PeekChar () == -1 && parserInputStack.Count > 0)
|
|
PopParserInput ();
|
|
} while (nodeType != XmlNodeType.None || parserInputStack.Count > originalParserDepth);
|
|
if (dtdIncludeSect != 0)
|
|
throw new XmlException (this as IXmlLineInfo,"INCLUDE section is not ended correctly.");
|
|
currentInput = original;
|
|
}
|
|
if (systemId != null && systemId != String.Empty && resolver != null) {
|
|
PushParserInput (systemId);
|
|
do {
|
|
this.CompileDTDSubset ();
|
|
if (PeekChar () == -1 && parserInputStack.Count > 1)
|
|
PopParserInput ();
|
|
} while (nodeType != XmlNodeType.None || parserInputStack.Count > originalParserDepth + 1);
|
|
PopParserInput ();
|
|
}
|
|
|
|
return DTD;
|
|
}
|
|
|
|
private void PushParserInput (string url)
|
|
{
|
|
Uri baseUri = null;
|
|
try {
|
|
baseUri = new Uri (BaseURI);
|
|
} catch (UriFormatException) {
|
|
}
|
|
|
|
Uri absUri = resolver.ResolveUri (baseUri, url);
|
|
string absPath = absUri.ToString ();
|
|
|
|
foreach (XmlParserInput i in parserInputStack.ToArray ()) {
|
|
if (i.BaseURI == absPath)
|
|
throw new XmlException (this as IXmlLineInfo, "Nested inclusion is not allowed: " + url);
|
|
}
|
|
parserInputStack.Push (currentInput);
|
|
currentInput = new XmlParserInput (new XmlStreamReader (url, false, resolver, BaseURI), absPath);
|
|
parserContext.PushScope ();
|
|
parserContext.BaseURI = absPath;
|
|
|
|
maybeTextDecl = 2;
|
|
}
|
|
|
|
private void PopParserInput ()
|
|
{
|
|
currentInput = parserInputStack.Pop () as XmlParserInput;
|
|
parserContext.PopScope ();
|
|
}
|
|
|
|
private enum DtdInputState
|
|
{
|
|
Free = 1,
|
|
ElementDecl,
|
|
AttlistDecl,
|
|
EntityDecl,
|
|
NotationDecl,
|
|
PI,
|
|
Comment,
|
|
InsideSingleQuoted,
|
|
InsideDoubleQuoted,
|
|
}
|
|
|
|
private class DtdInputStateStack
|
|
{
|
|
Stack intern = new Stack ();
|
|
public DtdInputStateStack ()
|
|
{
|
|
Push (DtdInputState.Free);
|
|
}
|
|
|
|
public DtdInputState Peek ()
|
|
{
|
|
return (DtdInputState) intern.Peek ();
|
|
}
|
|
|
|
public DtdInputState Pop ()
|
|
{
|
|
return (DtdInputState) intern.Pop ();
|
|
}
|
|
|
|
public void Push (DtdInputState val)
|
|
{
|
|
intern.Push (val);
|
|
}
|
|
}
|
|
|
|
|
|
DtdInputStateStack stateStack = new DtdInputStateStack ();
|
|
DtdInputState State {
|
|
get { return stateStack.Peek (); }
|
|
}
|
|
|
|
// Simply read but not generate any result.
|
|
private void ReadInternalSubset ()
|
|
{
|
|
bool continueParse = true;
|
|
|
|
while (continueParse) {
|
|
switch (ReadChar ()) {
|
|
case ']':
|
|
switch (State) {
|
|
case DtdInputState.Free:
|
|
continueParse = false;
|
|
break;
|
|
case DtdInputState.InsideDoubleQuoted:
|
|
continue;
|
|
case DtdInputState.InsideSingleQuoted:
|
|
continue;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected end of file at DTD.");
|
|
}
|
|
break;
|
|
case -1:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected end of file at DTD.");
|
|
case '<':
|
|
if (State == DtdInputState.InsideDoubleQuoted ||
|
|
State == DtdInputState.InsideSingleQuoted)
|
|
continue; // well-formed
|
|
switch (ReadChar ()) {
|
|
case '?':
|
|
stateStack.Push (DtdInputState.PI);
|
|
break;
|
|
case '!':
|
|
switch (ReadChar ()) {
|
|
case 'E':
|
|
switch (ReadChar ()) {
|
|
case 'L':
|
|
Expect ("EMENT");
|
|
stateStack.Push (DtdInputState.ElementDecl);
|
|
break;
|
|
case 'N':
|
|
Expect ("TITY");
|
|
stateStack.Push (DtdInputState.EntityDecl);
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected token '<!E'.");
|
|
}
|
|
break;
|
|
case 'A':
|
|
Expect ("TTLIST");
|
|
stateStack.Push (DtdInputState.AttlistDecl);
|
|
break;
|
|
case 'N':
|
|
Expect ("OTATION");
|
|
stateStack.Push (DtdInputState.NotationDecl);
|
|
break;
|
|
case '-':
|
|
Expect ("-");
|
|
stateStack.Push (DtdInputState.Comment);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected '>'.");
|
|
}
|
|
break;
|
|
case '\'':
|
|
if (State == DtdInputState.InsideSingleQuoted)
|
|
stateStack.Pop ();
|
|
else if (State != DtdInputState.InsideDoubleQuoted && State != DtdInputState.Comment)
|
|
stateStack.Push (DtdInputState.InsideSingleQuoted);
|
|
break;
|
|
case '"':
|
|
if (State == DtdInputState.InsideDoubleQuoted)
|
|
stateStack.Pop ();
|
|
else if (State != DtdInputState.InsideSingleQuoted && State != DtdInputState.Comment)
|
|
stateStack.Push (DtdInputState.InsideDoubleQuoted);
|
|
break;
|
|
case '>':
|
|
switch (State) {
|
|
case DtdInputState.ElementDecl:
|
|
goto case DtdInputState.NotationDecl;
|
|
case DtdInputState.AttlistDecl:
|
|
goto case DtdInputState.NotationDecl;
|
|
case DtdInputState.EntityDecl:
|
|
goto case DtdInputState.NotationDecl;
|
|
case DtdInputState.NotationDecl:
|
|
stateStack.Pop ();
|
|
break;
|
|
case DtdInputState.InsideDoubleQuoted:
|
|
continue;
|
|
case DtdInputState.InsideSingleQuoted:
|
|
continue; // well-formed
|
|
case DtdInputState.Comment:
|
|
continue;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"unexpected token '>'");
|
|
}
|
|
break;
|
|
case '?':
|
|
if (State == DtdInputState.PI) {
|
|
if (ReadChar () == '>')
|
|
stateStack.Pop ();
|
|
}
|
|
break;
|
|
case '-':
|
|
if (State == DtdInputState.Comment) {
|
|
if (PeekChar () == '-') {
|
|
ReadChar ();
|
|
Expect ('>');
|
|
stateStack.Pop ();
|
|
}
|
|
}
|
|
break;
|
|
case '%':
|
|
if (State != DtdInputState.Free && State != DtdInputState.EntityDecl && State != DtdInputState.Comment && State != DtdInputState.InsideDoubleQuoted && State != DtdInputState.InsideSingleQuoted)
|
|
throw new XmlException (this as IXmlLineInfo,"Parameter Entity Reference cannot appear as a part of markupdecl (see XML spec 2.8).");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Read any one of following:
|
|
// elementdecl, AttlistDecl, EntityDecl, NotationDecl,
|
|
// PI, Comment, Parameter Entity, or doctype termination char(']')
|
|
//
|
|
// returns a node of some nodeType or null, setting nodeType.
|
|
// (if None then ']' was found.)
|
|
private void CompileDTDSubset()
|
|
{
|
|
SkipWhitespace ();
|
|
switch(PeekChar ())
|
|
{
|
|
case -1:
|
|
nodeType = XmlNodeType.None;
|
|
break;
|
|
case '%':
|
|
// It affects on entity references' well-formedness
|
|
if (this.parserInputStack.Count == 0)
|
|
DTD.InternalSubsetHasPEReference = true;
|
|
ReadChar ();
|
|
string peName = ReadName ();
|
|
Expect (';');
|
|
currentInput.InsertParameterEntityBuffer (GetPEValue (peName));
|
|
int currentLine = currentInput.LineNumber;
|
|
int currentColumn = currentInput.LinePosition;
|
|
while (currentInput.HasPEBuffer)
|
|
CompileDTDSubset ();
|
|
if (currentInput.LineNumber != currentLine ||
|
|
currentInput.LinePosition != currentColumn)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Incorrectly nested parameter entity.");
|
|
break;
|
|
case '<':
|
|
ReadChar ();
|
|
switch(ReadChar ())
|
|
{
|
|
case '?':
|
|
// Only read, no store.
|
|
ReadProcessingInstruction ();
|
|
break;
|
|
case '!':
|
|
CompileDeclaration ();
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"Syntax Error after '<' character.");
|
|
}
|
|
break;
|
|
case ']':
|
|
if (dtdIncludeSect == 0)
|
|
throw new XmlException (this as IXmlLineInfo, "Unbalanced end of INCLUDE/IGNORE section.");
|
|
// End of inclusion
|
|
Expect ("]]>");
|
|
dtdIncludeSect--;
|
|
SkipWhitespace ();
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,String.Format ("Syntax Error inside doctypedecl markup : {0}({1})", PeekChar (), (char) PeekChar ()));
|
|
}
|
|
}
|
|
|
|
private void CompileDeclaration ()
|
|
{
|
|
nodeType = XmlNodeType.DocumentType; // Hack!!
|
|
switch(ReadChar ())
|
|
{
|
|
case '-':
|
|
Expect ('-');
|
|
// Only read, no store.
|
|
ReadComment ();
|
|
break;
|
|
case 'E':
|
|
switch(ReadChar ())
|
|
{
|
|
case 'N':
|
|
Expect ("TITY");
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required after '<!ENTITY' in DTD entity declaration.");
|
|
LOOPBACK:
|
|
if (PeekChar () == '%') {
|
|
ReadChar ();
|
|
if (!SkipWhitespace ()) {
|
|
ImportAsPERef ();
|
|
goto LOOPBACK;
|
|
} else {
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
if (XmlChar.IsNameChar (PeekChar ()))
|
|
ReadParameterEntityDecl ();
|
|
else
|
|
throw new XmlException (this as IXmlLineInfo,"expected name character");
|
|
}
|
|
break;
|
|
}
|
|
DTDEntityDeclaration ent = ReadEntityDecl ();
|
|
if (DTD.EntityDecls [ent.Name] == null)
|
|
DTD.EntityDecls.Add (ent.Name, ent);
|
|
break;
|
|
case 'L':
|
|
Expect ("EMENT");
|
|
DTDElementDeclaration el = ReadElementDecl ();
|
|
DTD.ElementDecls.Add (el.Name, el);
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"Syntax Error after '<!E' (ELEMENT or ENTITY must be found)");
|
|
}
|
|
break;
|
|
case 'A':
|
|
Expect ("TTLIST");
|
|
DTDAttListDeclaration atl = ReadAttListDecl ();
|
|
// if (DTD.AttListDecls.ContainsKey (atl.Name))
|
|
DTD.AttListDecls.Add (atl.Name, atl);
|
|
break;
|
|
case 'N':
|
|
Expect ("OTATION");
|
|
DTDNotationDeclaration not = ReadNotationDecl ();
|
|
DTD.NotationDecls.Add (not.Name, not);
|
|
break;
|
|
case '[':
|
|
// conditional sections
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('I');
|
|
switch (ReadChar ()) {
|
|
case 'N':
|
|
Expect ("CLUDE");
|
|
SkipWhitespace ();
|
|
Expect ('[');
|
|
dtdIncludeSect++;
|
|
break;
|
|
case 'G':
|
|
Expect ("NORE");
|
|
ReadIgnoreSect ();
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
throw new XmlException (this as IXmlLineInfo,"Syntax Error after '<!' characters.");
|
|
}
|
|
}
|
|
|
|
private void ReadIgnoreSect ()
|
|
{
|
|
bool skip = false;
|
|
SkipWhitespace ();
|
|
Expect ('[');
|
|
int dtdIgnoreSect = 1;
|
|
while (dtdIgnoreSect > 0) {
|
|
switch (skip ? PeekChar () : ReadChar ()) {
|
|
case -1:
|
|
throw new XmlException (this as IXmlLineInfo,"Unexpected IGNORE section end.");
|
|
case '<':
|
|
if (ReadChar () == '!' && ReadChar () == '[')
|
|
dtdIgnoreSect++;
|
|
break;
|
|
case ']':
|
|
if (ReadChar () == ']') {
|
|
if (ReadChar () == '>')
|
|
dtdIgnoreSect--;
|
|
else
|
|
skip = true;
|
|
}
|
|
break;
|
|
}
|
|
skip = false;
|
|
}
|
|
}
|
|
|
|
// The reader is positioned on the head of the name.
|
|
private DTDElementDeclaration ReadElementDecl ()
|
|
{
|
|
DTDElementDeclaration decl = new DTDElementDeclaration (DTD);
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between '<!ELEMENT' and name in DTD element declaration.");
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
decl.Name = ReadName ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between name and content in DTD element declaration.");
|
|
TryExpandPERef ();
|
|
ReadContentSpec (decl);
|
|
SkipWhitespace ();
|
|
// This expanding is only allowed as a non-validating parser.
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
return decl;
|
|
}
|
|
|
|
// read 'children'(BNF) of contentspec
|
|
private void ReadContentSpec (DTDElementDeclaration decl)
|
|
{
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
switch(PeekChar ())
|
|
{
|
|
case 'E':
|
|
decl.IsEmpty = true;
|
|
Expect ("EMPTY");
|
|
break;
|
|
case 'A':
|
|
decl.IsAny = true;
|
|
Expect ("ANY");
|
|
break;
|
|
case '(':
|
|
DTDContentModel model = decl.ContentModel;
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
if(PeekChar () == '#') {
|
|
// Mixed Contents. "#PCDATA" must appear first.
|
|
decl.IsMixedContent = true;
|
|
model.Occurence = DTDOccurence.ZeroOrMore;
|
|
model.OrderType = DTDContentOrderType.Or;
|
|
Expect ("#PCDATA");
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
while(PeekChar () != ')') {
|
|
Expect('|');
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
DTDContentModel elem = new DTDContentModel (DTD, decl.Name);
|
|
elem.ElementName = ReadName ();
|
|
model.ChildModels.Add (elem);
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
}
|
|
Expect (')');
|
|
if (model.ChildModels.Count > 0)
|
|
Expect ('*');
|
|
else if (PeekChar () == '*')
|
|
Expect ('*');
|
|
} else {
|
|
// Non-Mixed Contents
|
|
model.ChildModels.Add (ReadCP (decl));
|
|
SkipWhitespace ();
|
|
|
|
do { // copied from ReadCP() ...;-)
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
if(PeekChar ()=='|') {
|
|
// CPType=Or
|
|
if (model.OrderType == DTDContentOrderType.Seq)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Inconsistent choice markup in sequence cp.");
|
|
model.OrderType = DTDContentOrderType.Or;
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
model.ChildModels.Add (ReadCP (decl));
|
|
SkipWhitespace ();
|
|
}
|
|
else if(PeekChar () == ',')
|
|
{
|
|
// CPType=Seq
|
|
if (model.OrderType == DTDContentOrderType.Or)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Inconsistent sequence markup in choice cp.");
|
|
model.OrderType = DTDContentOrderType.Seq;
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
model.ChildModels.Add (ReadCP (decl));
|
|
SkipWhitespace ();
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
while(true);
|
|
|
|
Expect (')');
|
|
switch(PeekChar ())
|
|
{
|
|
case '?':
|
|
model.Occurence = DTDOccurence.Optional;
|
|
ReadChar ();
|
|
break;
|
|
case '*':
|
|
model.Occurence = DTDOccurence.ZeroOrMore;
|
|
ReadChar ();
|
|
break;
|
|
case '+':
|
|
model.Occurence = DTDOccurence.OneOrMore;
|
|
ReadChar ();
|
|
break;
|
|
}
|
|
SkipWhitespace ();
|
|
}
|
|
SkipWhitespace ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Read 'cp' (BNF) of contentdecl (BNF)
|
|
private DTDContentModel ReadCP (DTDElementDeclaration elem)
|
|
{
|
|
DTDContentModel model = null;
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
if(PeekChar () == '(') {
|
|
model = new DTDContentModel (DTD, elem.Name);
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
model.ChildModels.Add (ReadCP (elem));
|
|
SkipWhitespace ();
|
|
do {
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
if(PeekChar ()=='|') {
|
|
// CPType=Or
|
|
if (model.OrderType == DTDContentOrderType.Seq)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Inconsistent choice markup in sequence cp.");
|
|
model.OrderType = DTDContentOrderType.Or;
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
model.ChildModels.Add (ReadCP (elem));
|
|
SkipWhitespace ();
|
|
}
|
|
else if(PeekChar () == ',') {
|
|
// CPType=Seq
|
|
if (model.OrderType == DTDContentOrderType.Or)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Inconsistent sequence markup in choice cp.");
|
|
model.OrderType = DTDContentOrderType.Seq;
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
model.ChildModels.Add (ReadCP (elem));
|
|
SkipWhitespace ();
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
while(true);
|
|
SkipWhitespace ();
|
|
Expect (')');
|
|
}
|
|
else {
|
|
TryExpandPERef ();
|
|
model = new DTDContentModel (DTD, elem.Name);
|
|
SkipWhitespace ();
|
|
model.ElementName = ReadName ();
|
|
}
|
|
|
|
switch(PeekChar ()) {
|
|
case '?':
|
|
model.Occurence = DTDOccurence.Optional;
|
|
ReadChar ();
|
|
break;
|
|
case '*':
|
|
model.Occurence = DTDOccurence.ZeroOrMore;
|
|
ReadChar ();
|
|
break;
|
|
case '+':
|
|
model.Occurence = DTDOccurence.OneOrMore;
|
|
ReadChar ();
|
|
break;
|
|
}
|
|
return model;
|
|
}
|
|
|
|
// The reader is positioned on the first name char.
|
|
private void ReadParameterEntityDecl ()
|
|
{
|
|
DTDParameterEntityDeclaration decl =
|
|
new DTDParameterEntityDeclaration();
|
|
decl.BaseURI = BaseURI;
|
|
|
|
decl.Name = ReadName ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required after name in DTD parameter entity declaration.");
|
|
|
|
if (PeekChar () == 'S' || PeekChar () == 'P') {
|
|
// throw new NotImplementedException ("External parameter entity reference is not implemented yet.");
|
|
// read publicId/systemId
|
|
ReadExternalID ();
|
|
decl.PublicId = attributes ["PUBLIC"] as string;
|
|
decl.SystemId = attributes ["SYSTEM"] as string;
|
|
SkipWhitespace ();
|
|
decl.Resolve (resolver);
|
|
}
|
|
else {
|
|
TryExpandPERef ();
|
|
int quoteChar = ReadChar ();
|
|
int start = currentTag.Length;
|
|
ClearValueBuffer ();
|
|
bool loop = true;
|
|
while (loop) {
|
|
int c = PeekChar ();
|
|
switch (c) {
|
|
case -1:
|
|
throw new XmlException ("unexpected end of stream in entity value definition.");
|
|
case '"':
|
|
ReadChar ();
|
|
if (quoteChar == '"')
|
|
loop = false;
|
|
else
|
|
AppendValueChar ('"');
|
|
break;
|
|
case '\'':
|
|
ReadChar ();
|
|
if (quoteChar == '\'')
|
|
loop = false;
|
|
else
|
|
AppendValueChar ('\'');
|
|
break;
|
|
case '&':
|
|
ReadChar ();
|
|
if (PeekChar () == '#') {
|
|
ReadChar ();
|
|
ReadCharacterReference ();
|
|
}
|
|
else
|
|
AppendValueChar ('&');
|
|
break;
|
|
case '%':
|
|
ReadChar ();
|
|
string peName = ReadName ();
|
|
Expect (';');
|
|
valueBuffer.Append (GetPEValue (peName));
|
|
break;
|
|
default:
|
|
AppendValueChar (ReadChar ());
|
|
break;
|
|
}
|
|
}
|
|
decl.LiteralValue = CreateValueString (); // currentTag.ToString (start, currentTag.Length - start - 1);
|
|
ClearValueBuffer ();
|
|
}
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
if (parameterEntities [decl.Name] == null) {
|
|
parameterEntities.Add (decl.Name, decl);
|
|
}
|
|
}
|
|
|
|
private string GetPEValue (string peName)
|
|
{
|
|
DTDParameterEntityDeclaration peDecl =
|
|
this.parameterEntities [peName] as DTDParameterEntityDeclaration;
|
|
if (peDecl != null)
|
|
return peDecl.Value;
|
|
// See XML 1.0 section 4.1 for both WFC and VC.
|
|
if ((DTD.SystemId == null && !DTD.InternalSubsetHasPEReference) || this.isStandalone)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Parameter entity " + peName + " not found.");
|
|
DTD.AddError (new XmlSchemaException (
|
|
"Parameter entity " + peName + " not found.", null));
|
|
return "";
|
|
}
|
|
|
|
private void TryExpandPERef ()
|
|
{
|
|
if (PeekChar () == '%') {
|
|
// ReadChar ();
|
|
// if (!XmlChar.IsNameChar (PeekChar ()))
|
|
// return;
|
|
// ExpandPERef ();
|
|
ImportAsPERef ();
|
|
}
|
|
}
|
|
|
|
// reader is positioned on '%'
|
|
private void ImportAsPERef ()
|
|
{
|
|
ReadChar ();
|
|
string peName = ReadName ();
|
|
Expect (';');
|
|
DTDParameterEntityDeclaration peDecl =
|
|
this.parameterEntities [peName] as DTDParameterEntityDeclaration;
|
|
if (peDecl == null) {
|
|
DTD.AddError (new XmlSchemaException ("Parameter entity " + peName + " not found.", null));
|
|
return; // do nothing
|
|
}
|
|
currentInput.InsertParameterEntityBuffer (" " + peDecl.Value + " ");
|
|
|
|
}
|
|
|
|
// The reader is positioned on the head of the name.
|
|
private DTDEntityDeclaration ReadEntityDecl ()
|
|
{
|
|
DTDEntityDeclaration decl = new DTDEntityDeclaration (DTD);
|
|
decl.IsInternalSubset = (parserInputStack.Count == 0);
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
decl.Name = ReadName ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between name and content in DTD entity declaration.");
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
|
|
if (PeekChar () == 'S' || PeekChar () == 'P') {
|
|
// external entity
|
|
ReadExternalID ();
|
|
decl.PublicId = attributes ["PUBLIC"] as string;
|
|
decl.SystemId = attributes ["SYSTEM"] as string;
|
|
if (SkipWhitespace ()) {
|
|
if (PeekChar () == 'N') {
|
|
// NDataDecl
|
|
Expect ("NDATA");
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required after NDATA.");
|
|
decl.NotationName = ReadName (); // ndata_name
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// literal entity
|
|
ReadEntityValueDecl (decl);
|
|
}
|
|
SkipWhitespace ();
|
|
// This expanding is only allowed as a non-validating parser.
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
return decl;
|
|
}
|
|
|
|
private void ReadEntityValueDecl (DTDEntityDeclaration decl)
|
|
{
|
|
SkipWhitespace ();
|
|
// quotation char will be finally removed on unescaping
|
|
int quoteChar = ReadChar ();
|
|
int start = currentTag.Length;
|
|
if (quoteChar != '\'' && quoteChar != '"')
|
|
throw new XmlException ("quotation char was expected.");
|
|
|
|
ClearValueBuffer ();
|
|
|
|
while (PeekChar () != quoteChar) {
|
|
switch (PeekChar ()) {
|
|
case '%':
|
|
ReadChar ();
|
|
string name = ReadName ();
|
|
Expect (';');
|
|
if (decl.IsInternalSubset)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Parameter entity is not allowed in internal subset entity '" + name + "'");
|
|
valueBuffer.Append (GetPEValue (name));
|
|
break;
|
|
case -1:
|
|
throw new XmlException ("unexpected end of stream.");
|
|
default:
|
|
AppendValueChar (ReadChar ());
|
|
break;
|
|
}
|
|
}
|
|
// string value = Dereference (currentTag.ToString (start, currentTag.Length - start), false);
|
|
string value = Dereference (CreateValueString (), false);
|
|
ClearValueBuffer ();
|
|
|
|
Expect (quoteChar);
|
|
decl.LiteralEntityValue = value;
|
|
}
|
|
|
|
private DTDAttListDeclaration ReadAttListDecl ()
|
|
{
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
string name = ReadName (); // target element name
|
|
DTDAttListDeclaration decl =
|
|
DTD.AttListDecls [name] as DTDAttListDeclaration;
|
|
if (decl == null)
|
|
decl = new DTDAttListDeclaration (DTD);
|
|
decl.Name = name;
|
|
|
|
if (!SkipWhitespace ())
|
|
if (PeekChar () != '>')
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between name and content in non-empty DTD attlist declaration.");
|
|
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
|
|
while (XmlChar.IsNameChar ((char) PeekChar ())) {
|
|
DTDAttributeDefinition def = ReadAttributeDefinition ();
|
|
if (decl [def.Name] == null)
|
|
decl.Add (def);
|
|
SkipWhitespace ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
}
|
|
SkipWhitespace ();
|
|
// This expanding is only allowed as a non-validating parser.
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
return decl;
|
|
}
|
|
|
|
private DTDAttributeDefinition ReadAttributeDefinition ()
|
|
{
|
|
DTDAttributeDefinition def = new DTDAttributeDefinition ();
|
|
|
|
// attr_name
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
def.Name = ReadName ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between name and content in DTD attribute definition.");
|
|
|
|
// attr_value
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
switch(PeekChar ()) {
|
|
case 'C': // CDATA
|
|
Expect ("CDATA");
|
|
def.Datatype = XmlSchemaDatatype.FromName ("normalizedString");
|
|
break;
|
|
case 'I': // ID, IDREF, IDREFS
|
|
Expect ("ID");
|
|
if(PeekChar () == 'R') {
|
|
Expect ("REF");
|
|
if(PeekChar () == 'S') {
|
|
// IDREFS
|
|
ReadChar ();
|
|
def.Datatype = XmlSchemaDatatype.FromName ("IDREFS");
|
|
}
|
|
else // IDREF
|
|
def.Datatype = XmlSchemaDatatype.FromName ("IDREF");
|
|
}
|
|
else // ID
|
|
def.Datatype = XmlSchemaDatatype.FromName ("ID");
|
|
break;
|
|
case 'E': // ENTITY, ENTITIES
|
|
Expect ("ENTIT");
|
|
switch(ReadChar ()) {
|
|
case 'Y': // ENTITY
|
|
def.Datatype = XmlSchemaDatatype.FromName ("ENTITY");
|
|
break;
|
|
case 'I': // ENTITIES
|
|
Expect ("ES");
|
|
def.Datatype = XmlSchemaDatatype.FromName ("ENTITIES");
|
|
break;
|
|
}
|
|
break;
|
|
case 'N': // NMTOKEN, NMTOKENS, NOTATION
|
|
ReadChar ();
|
|
switch(PeekChar ()) {
|
|
case 'M':
|
|
Expect ("MTOKEN");
|
|
if(PeekChar ()=='S') { // NMTOKENS
|
|
ReadChar ();
|
|
def.Datatype = XmlSchemaDatatype.FromName ("NMTOKENS");
|
|
}
|
|
else // NMTOKEN
|
|
def.Datatype = XmlSchemaDatatype.FromName ("NMTOKEN");
|
|
break;
|
|
case 'O':
|
|
Expect ("OTATION");
|
|
def.Datatype = XmlSchemaDatatype.FromName ("NOTATION");
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between name and content in DTD attribute definition.");
|
|
Expect ('(');
|
|
SkipWhitespace ();
|
|
def.EnumeratedNotations.Add (ReadName ()); // notation name
|
|
SkipWhitespace ();
|
|
while(PeekChar () == '|') {
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
def.EnumeratedNotations.Add (ReadName ()); // notation name
|
|
SkipWhitespace ();
|
|
}
|
|
Expect (')');
|
|
break;
|
|
default:
|
|
throw new XmlException ("attribute declaration syntax error.");
|
|
}
|
|
break;
|
|
default: // Enumerated Values
|
|
def.Datatype = XmlSchemaDatatype.FromName ("NMTOKEN");
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('(');
|
|
SkipWhitespace ();
|
|
def.EnumeratedAttributeDeclaration.Add (
|
|
def.Datatype.Normalize (ReadNmToken ())); // enum value
|
|
SkipWhitespace ();
|
|
while(PeekChar () == '|') {
|
|
ReadChar ();
|
|
SkipWhitespace ();
|
|
def.EnumeratedAttributeDeclaration.Add (
|
|
def.Datatype.Normalize (ReadNmToken ())); // enum value
|
|
SkipWhitespace ();
|
|
}
|
|
Expect (')');
|
|
break;
|
|
}
|
|
TryExpandPERef ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between type and occurence in DTD attribute definition.");
|
|
|
|
// def_value
|
|
if(PeekChar () == '#')
|
|
{
|
|
ReadChar ();
|
|
switch(PeekChar ())
|
|
{
|
|
case 'R':
|
|
Expect ("REQUIRED");
|
|
def.OccurenceType = DTDAttributeOccurenceType.Required;
|
|
break;
|
|
case 'I':
|
|
Expect ("IMPLIED");
|
|
def.OccurenceType = DTDAttributeOccurenceType.Optional;
|
|
break;
|
|
case 'F':
|
|
Expect ("FIXED");
|
|
def.OccurenceType = DTDAttributeOccurenceType.Fixed;
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between FIXED and actual value in DTD attribute definition.");
|
|
def.UnresolvedDefaultValue = ReadAttribute (true);
|
|
break;
|
|
}
|
|
} else {
|
|
// one of the enumerated value
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
def.UnresolvedDefaultValue = ReadAttribute (true);
|
|
}
|
|
|
|
return def;
|
|
}
|
|
|
|
private DTDNotationDeclaration ReadNotationDecl()
|
|
{
|
|
DTDNotationDeclaration decl = new DTDNotationDeclaration ();
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
decl.Name = ReadName (); // notation name
|
|
if (namespaces) { // copy from SetProperties ;-)
|
|
int indexOfColon = decl.Name.IndexOf (':');
|
|
|
|
if (indexOfColon == -1) {
|
|
decl.Prefix = String.Empty;
|
|
decl.LocalName = decl.Name;
|
|
} else {
|
|
decl.Prefix = decl.Name.Substring (0, indexOfColon);
|
|
decl.LocalName = decl.Name.Substring (indexOfColon + 1);
|
|
}
|
|
} else {
|
|
decl.Prefix = String.Empty;
|
|
decl.LocalName = decl.Name;
|
|
}
|
|
|
|
SkipWhitespace ();
|
|
if(PeekChar () == 'P') {
|
|
decl.PublicId = ReadPubidLiteral ();
|
|
bool wsSkipped = SkipWhitespace ();
|
|
if (PeekChar () == '\'' || PeekChar () == '"') {
|
|
if (!wsSkipped)
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between public id and system id.");
|
|
decl.SystemId = ReadSystemLiteral (false);
|
|
SkipWhitespace ();
|
|
}
|
|
} else if(PeekChar () == 'S') {
|
|
decl.SystemId = ReadSystemLiteral (true);
|
|
SkipWhitespace ();
|
|
}
|
|
if(decl.PublicId == null && decl.SystemId == null)
|
|
throw new XmlException ("public or system declaration required for \"NOTATION\" declaration.");
|
|
// This expanding is only allowed as a non-validating parser.
|
|
TryExpandPERef ();
|
|
SkipWhitespace ();
|
|
Expect ('>');
|
|
return decl;
|
|
}
|
|
|
|
private void ReadExternalID() {
|
|
switch(PeekChar ()) {
|
|
case 'S':
|
|
attributes ["PUBLIC"] = null;
|
|
attributes ["SYSTEM"] = ReadSystemLiteral (true);
|
|
break;
|
|
case 'P':
|
|
attributes ["PUBLIC"] = ReadPubidLiteral ();
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required between PUBLIC id and SYSTEM id.");
|
|
attributes ["SYSTEM"] = ReadSystemLiteral (false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// The reader is positioned on the first 'S' of "SYSTEM".
|
|
private string ReadSystemLiteral (bool expectSYSTEM)
|
|
{
|
|
if(expectSYSTEM) {
|
|
Expect ("SYSTEM");
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required after 'SYSTEM'.");
|
|
}
|
|
else
|
|
SkipWhitespace ();
|
|
int quoteChar = ReadChar (); // apos or quot
|
|
int startPos = currentTag.Length;
|
|
int c = 0;
|
|
while(c != quoteChar) {
|
|
c = ReadChar ();
|
|
if(c < 0) throw new XmlException (this as IXmlLineInfo,"Unexpected end of stream in ExternalID.");
|
|
}
|
|
return currentTag.ToString (startPos, currentTag.Length - 1 - startPos);
|
|
}
|
|
|
|
private string ReadPubidLiteral()
|
|
{
|
|
Expect ("PUBLIC");
|
|
if (!SkipWhitespace ())
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
"Whitespace is required after 'PUBLIC'.");
|
|
int quoteChar = ReadChar ();
|
|
int startPos = currentTag.Length;
|
|
int c = 0;
|
|
while(c != quoteChar)
|
|
{
|
|
c = ReadChar ();
|
|
if(c < 0) throw new XmlException (this as IXmlLineInfo,"Unexpected end of stream in ExternalID.");
|
|
if(c != quoteChar && !XmlChar.IsPubidChar (c))
|
|
throw new XmlException (this as IXmlLineInfo,"character '" + (char)c + "' not allowed for PUBLIC ID");
|
|
}
|
|
return currentTag.ToString (startPos, currentTag.Length - 1 - startPos);
|
|
}
|
|
|
|
// The reader is positioned on the first character
|
|
// of the name.
|
|
internal string ReadName ()
|
|
{
|
|
return ReadNameOrNmToken(false);
|
|
}
|
|
|
|
// The reader is positioned on the first character
|
|
// of the name.
|
|
private string ReadNmToken ()
|
|
{
|
|
return ReadNameOrNmToken(true);
|
|
}
|
|
|
|
private string ReadNameOrNmToken(bool isNameToken)
|
|
{
|
|
int ch = PeekChar ();
|
|
if(isNameToken) {
|
|
if (!XmlChar.IsNameChar ((char) ch))
|
|
throw new XmlException (this as IXmlLineInfo,String.Format ("a nmtoken did not start with a legal character {0} ({1})", ch, (char)ch));
|
|
}
|
|
else {
|
|
if (!XmlChar.IsFirstNameChar (ch))
|
|
throw new XmlException (this as IXmlLineInfo,String.Format ("a name did not start with a legal character {0} ({1})", ch, (char)ch));
|
|
}
|
|
|
|
nameLength = 0;
|
|
|
|
AppendNameChar (ReadChar ());
|
|
|
|
while (XmlChar.IsNameChar (PeekChar ())) {
|
|
AppendNameChar (ReadChar ());
|
|
}
|
|
|
|
return CreateNameString ();
|
|
}
|
|
|
|
// Read the next character and compare it against the
|
|
// specified character.
|
|
private void Expect (int expected)
|
|
{
|
|
int ch = ReadChar ();
|
|
|
|
if (ch != expected) {
|
|
throw new XmlException (this as IXmlLineInfo,
|
|
String.Format (
|
|
"expected '{0}' ({1:X}) but found '{2}' ({3:X})",
|
|
(char)expected,
|
|
expected,
|
|
(char)ch,
|
|
ch));
|
|
}
|
|
}
|
|
|
|
private void Expect (string expected)
|
|
{
|
|
int len = expected.Length;
|
|
for(int i=0; i< len; i++)
|
|
Expect (expected[i]);
|
|
}
|
|
|
|
// Does not consume the first non-whitespace character.
|
|
private bool SkipWhitespace ()
|
|
{
|
|
//FIXME: Should not skip if whitespaceHandling == WhiteSpaceHandling.None
|
|
bool skipped = XmlChar.IsWhitespace (PeekChar ());
|
|
while (XmlChar.IsWhitespace (PeekChar ()))
|
|
ReadChar ();
|
|
return skipped;
|
|
}
|
|
|
|
private void ReadWhitespace ()
|
|
{
|
|
if (currentState == XmlNodeType.None)
|
|
currentState = XmlNodeType.XmlDeclaration;
|
|
|
|
ClearValueBuffer ();
|
|
int ch = PeekChar ();
|
|
do {
|
|
AppendValueChar (ReadChar ());
|
|
} while ((ch = PeekChar ()) != -1 && XmlChar.IsWhitespace (ch));
|
|
|
|
if (currentState == XmlNodeType.Element && ch != -1 && ch != '<')
|
|
ReadText (false);
|
|
else
|
|
SetProperties (XmlNodeType.Whitespace,
|
|
String.Empty,
|
|
false,
|
|
valueBuffer,
|
|
true);
|
|
|
|
return; // (PeekChar () != -1);
|
|
}
|
|
|
|
// read entity reference from attribute string and if parsable then return the value.
|
|
private string ReadAttributeValueReference ()
|
|
{
|
|
int endEntityPosition = attributeString.IndexOf(';',
|
|
attributeValuePos);
|
|
if (endEntityPosition < 0)
|
|
throw new XmlException ("Insufficient markup of entity reference");
|
|
string entityName = attributeString.Substring (attributeValuePos + 1,
|
|
endEntityPosition - attributeValuePos - 1);
|
|
|
|
attributeValuePos = endEntityPosition + 1;
|
|
|
|
if(entityName [0] == '#') {
|
|
char c;
|
|
// character entity
|
|
if(entityName [1] == 'x') {
|
|
// hexadecimal
|
|
c = (char) int.Parse ("0" + entityName.Substring (2),
|
|
System.Globalization.NumberStyles.HexNumber);
|
|
} else {
|
|
// decimal
|
|
c = (char) int.Parse (entityName.Substring (1));
|
|
}
|
|
return c.ToString();
|
|
}
|
|
else {
|
|
switch(entityName)
|
|
{
|
|
case "lt": return "<";
|
|
case "gt": return ">";
|
|
case "amp": return "&";
|
|
case "quot": return "\"";
|
|
case "apos": return "'";
|
|
default: return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private string UnescapeAttributeValue (string unresolved)
|
|
{
|
|
if(unresolved == null) return null;
|
|
|
|
// trim start/end edge of quotation character.
|
|
return Dereference (unresolved.Substring (1, unresolved.Length - 2), true);
|
|
}
|
|
|
|
private string Dereference (string unresolved, bool expandPredefined)
|
|
{
|
|
StringBuilder resolved = new StringBuilder();
|
|
int pos = 0;
|
|
int next = unresolved.IndexOf ('&');
|
|
if(next < 0)
|
|
return unresolved;
|
|
|
|
while(next >= 0) {
|
|
if(pos < next)
|
|
resolved.Append (unresolved.Substring (pos, next - pos));// - 1);
|
|
int endPos = unresolved.IndexOf (';', next+1);
|
|
string entityName =
|
|
unresolved.Substring (next + 1, endPos - next - 1);
|
|
if(entityName [0] == '#') {
|
|
char c;
|
|
// character entity
|
|
if(entityName [1] == 'x') {
|
|
// hexadecimal
|
|
c = (char) int.Parse ("0" + entityName.Substring (2),
|
|
System.Globalization.NumberStyles.HexNumber);
|
|
} else {
|
|
// decimal
|
|
c = (char) int.Parse (entityName.Substring (1));
|
|
}
|
|
resolved.Append (c);
|
|
} else {
|
|
char predefined = XmlChar.GetPredefinedEntity (entityName);
|
|
if (expandPredefined && predefined != 0)
|
|
resolved.Append (predefined);
|
|
else
|
|
// With respect to "Value", MS document is helpless
|
|
// and the implemention returns inconsistent value
|
|
// (e.g. XML: "&ent; &ent;" ---> Value: "&ent; &ent;".)
|
|
resolved.Append ("&" + entityName + ";");
|
|
}
|
|
pos = endPos + 1;
|
|
if(pos > unresolved.Length)
|
|
break;
|
|
next = unresolved.IndexOf('&', pos);
|
|
}
|
|
resolved.Append (unresolved.Substring(pos));
|
|
|
|
return resolved.ToString();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|