Files
mono/mcs/class/System.XML/System.Xml/XmlTextReader.cs
T
Gonzalo Paniagua Javier b4ff470fda 2003-01-11 Gonzalo Paniagua Javier <[email protected]>
* XmlTextReader.cs:
	(ReadOuterXml): use Depth property which return elementDepth, not depth.

svn path=/trunk/mcs/; revision=10367
2003-01-11 00:02:34 +00:00

1742 lines
39 KiB
C#

//
// System.Xml.XmlTextReader
//
// Author:
// Jason Diamond ([email protected])
// Adam Treat ([email protected])
//
// (C) 2001, 2002 Jason Diamond http://injektilo.org/
//
// FIXME:
// This can only parse basic XML: elements, attributes, processing
// instructions, and comments are OK.
//
// It barfs on DOCTYPE declarations.
// => No barfing, but parsing is incomplete.
// DTD nodes are not still created.
//
// There's also no checking being done for either well-formedness
// or validity.
//
// NameTables aren't being used everywhere yet.
//
// Some thought needs to be given to performance. There's too many
// strings being allocated.
//
// Some of the MoveTo methods haven't been implemented yet.
//
// LineNumber and LinePosition aren't being tracked.
//
// xml:space, xml:lang, and xml:base aren't being tracked.
//
using System;
using System.Collections;
using System.IO;
using System.Text;
namespace System.Xml
{
public class XmlTextReader : XmlReader, IXmlLineInfo
{
WhitespaceHandling whitespaceHandling = WhitespaceHandling.All;
#region Constructors
protected XmlTextReader ()
{
}
public XmlTextReader (Stream input)
: this (new StreamReader (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 StreamReader (input), nt)
{
}
public XmlTextReader (string url, Stream input)
: this (url, new StreamReader (input))
{
}
public XmlTextReader (string url, TextReader input)
: this (url, input, new NameTable ())
{
}
[MonoTODO("Non-filename-url must be supported. Waiting for WebClient")]
public XmlTextReader (string url, XmlNameTable nt)
// : this(url, new StreamReader ((Stream)new XmlUrlResolver ().GetEntity (new Uri (url), null, typeof(Stream))), nt)
: this (url, new StreamReader (url), nt)
{
}
public XmlTextReader (TextReader input, XmlNameTable nt)
: this(String.Empty, input, nt)
{
}
public XmlTextReader (Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
: this (String.Empty, new StreamReader (xmlFragment), fragType, context)
{
}
public XmlTextReader (string url, Stream input, XmlNameTable nt)
: this (url, new StreamReader (input), nt)
{
}
public XmlTextReader (string url, TextReader input, XmlNameTable nt)
: this (url, input, XmlNodeType.Document, new XmlParserContext (nt, new XmlNamespaceManager (nt), null, XmlSpace.None))
{
}
[MonoTODO("TODO as same as private XmlTextReader(TextReader, XmlNodeType, XmlParserContext)")]
public XmlTextReader (string xmlFragment, XmlNodeType fragType, XmlParserContext context)
: this (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)
{
this.SetReaderContext(url, context);
this.SetReaderFragment(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 { 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 line; }
}
public int LinePosition
{
get { return column; }
}
public override string LocalName
{
get { return localName; }
}
public override string Name
{
get { return name; }
}
[MonoTODO]
public bool Namespaces
{
get { throw new NotImplementedException (); }
set { throw new NotImplementedException (); }
}
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 { throw new NotImplementedException (); }
set { throw new NotImplementedException (); }
}
public override string Prefix
{
get { return prefix; }
}
[MonoTODO]
public override char QuoteChar
{
get { throw new NotImplementedException (); }
}
public override ReadState ReadState
{
get { return readState; }
}
public override string Value
{
get {
if(NodeType == XmlNodeType.Attribute)
return ResolveAttributeValue(value);
else
return value;
}
}
public WhitespaceHandling WhitespaceHandling
{
get { return whitespaceHandling; }
set { whitespaceHandling = value; }
}
[MonoTODO]
public override string XmlLang
{
get { throw new NotImplementedException (); }
}
[MonoTODO]
public XmlResolver XmlResolver
{
set { throw new NotImplementedException (); }
}
[MonoTODO]
public override XmlSpace XmlSpace
{
get { throw new NotImplementedException (); }
}
#endregion
#region Methods
[MonoTODO]
public override void Close ()
{
readState = ReadState.Closed;
}
[MonoTODO]
public override string GetAttribute (int i)
{
if (i > attributes.Count)
throw new ArgumentOutOfRangeException ("i is smaller than AttributeCount");
else
return ResolveAttributeValue (attributes [orderedAttributes [i]] as string);
}
public override string GetAttribute (string name)
{
return attributes.ContainsKey (name) ?
ResolveAttributeValue (attributes [name] as string) : String.Empty;
}
public override string GetAttribute (string localName, string namespaceURI)
{
foreach (DictionaryEntry entry in attributes)
{
string thisName = entry.Key as string;
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 attributes.ContainsKey (thisName) ?
ResolveAttributeValue (attributes [thisName] as string) : String.Empty;
}
} else if (localName == "xmlns" && namespaceURI == "http://www.w3.org/2000/xmlns/" && thisName == "xmlns")
return attributes.ContainsKey (thisName) ?
ResolveAttributeValue (attributes [thisName] as string) : String.Empty;
}
return String.Empty;
}
[MonoTODO]
public TextReader GetRemainder ()
{
throw new NotImplementedException ();
}
[MonoTODO]
bool IXmlLineInfo.HasLineInfo ()
{
return false;
}
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.");
string name = orderedAttributes [i] as string;
string value = attributes [name] as string;
SetProperties (
XmlNodeType.Attribute, // nodeType
name, // name
false, // isEmptyElement
value, // value
false // clearAttributes
);
}
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
);
}
return match;
}
[MonoTODO]
public override bool MoveToAttribute (string localName, string namespaceName)
{
throw new NotImplementedException ();
}
public override bool MoveToElement ()
{
if (orderedAttributesEnumerator != null) {
orderedAttributesEnumerator = null;
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
);
return true;
}
return false;
}
public override bool Read ()
{
bool more = false;
readState = ReadState.Interactive;
more = ReadContent ();
return more;
}
[MonoTODO("This method should consider entity references")]
public override bool ReadAttributeValue ()
{
// reading attribute value phase now stopped
if(attributeStringCurrentPosition < 0 ||
attributeString.Length < attributeStringCurrentPosition) {
attributeStringCurrentPosition = 0;
attributeString = String.Empty;
return false;
}
// If not started, then initialize attributeString when parsing is at start.
if(attributeStringCurrentPosition == 0)
attributeString = value;
bool returnEntity = false;
value = String.Empty;
int nextPosition = attributeString.IndexOf ('&',
attributeStringCurrentPosition);
// if attribute string starts from '&' then it may be (unparsable) entity reference.
if(nextPosition == 0) {
string parsed = ReadAttributeValueEntityReference ();
if(parsed == null) {
// return entity (It is only this case to return entity reference.)
int endEntityPosition = attributeString.IndexOf (';',
attributeStringCurrentPosition);
SetProperties (XmlNodeType.EntityReference,
attributeString.Substring (attributeStringCurrentPosition + 1,
endEntityPosition - attributeStringCurrentPosition - 1),
false,
String.Empty,
false);
attributeStringCurrentPosition = endEntityPosition + 1;
return true;
}
else
value += parsed;
}
// Other case always set text node.
while(!returnEntity) {
nextPosition = attributeString.IndexOf ('&', attributeStringCurrentPosition);
if(nextPosition < 0) {
// Reached to the end of value string.
value += attributeString.Substring (attributeStringCurrentPosition);
attributeStringCurrentPosition = -1;
break;
} else if(nextPosition == attributeStringCurrentPosition) {
string parsed = ReadAttributeValueEntityReference ();
if(parsed != null)
value += parsed;
else {
// Found that an entity reference starts from this point.
// Then once stop to parse attribute value and then return text.
value += attributeString.Substring (attributeStringCurrentPosition,
nextPosition - attributeStringCurrentPosition);
break;
}
} else {
value += attributeString.Substring (attributeStringCurrentPosition,
nextPosition - attributeStringCurrentPosition);
attributeStringCurrentPosition = nextPosition;
continue;
}
}
SetProperties(XmlNodeType.Text,
"#text",
false,
value,
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 ();
}
[MonoTODO]
public override string ReadInnerXml ()
{
// Still need a Well Formedness check.
// Will wait for Validating reader ;-)
if (NodeType == XmlNodeType.Attribute) {
return Value;
} else {
saveToXmlBuffer = true;
string startname = this.Name;
string endname = string.Empty;
readState = ReadState.Interactive;
while (startname != endname) {
ReadContent ();
endname = this.Name;
}
xmlBuffer.Replace (currentTag.ToString (), "");
saveToXmlBuffer = false;
string InnerXml = xmlBuffer.ToString ();
xmlBuffer.Length = 0;
return InnerXml;
}
}
[MonoTODO]
public override string ReadOuterXml ()
{
if (NodeType == XmlNodeType.Attribute) {
return Name + "=\"" + Value.Replace ("\"", "&quot;") + "\"";
} else {
saveToXmlBuffer = true;
xmlBuffer.Append (currentTag.ToString ());
int startDepth = Depth;
readState = ReadState.Interactive;
do {
ReadContent ();
} while (Depth > startDepth);
saveToXmlBuffer = false;
string OuterXml = xmlBuffer.ToString ();
xmlBuffer.Length = 0;
return OuterXml;
}
}
[MonoTODO]
public override string ReadString ()
{
throw new NotImplementedException ();
}
[MonoTODO]
public void ResetState ()
{
throw new NotImplementedException ();
}
public override void ResolveEntity ()
{
// XmlTextReaders don't resolve entities.
throw new InvalidOperationException ("XmlTextReader cannot resolve external entities.");
}
#endregion
#region Internals
internal string publicId;
internal string systemId;
internal void SetReaderContext (string url, XmlParserContext context)
{
parserContext = context;
parserContext.BaseURI = url;
Init ();
}
internal void SetReaderFragment(TextReader fragment, XmlNodeType fragType)
{
this.reader = fragment;
can_seek = fragment != null && fragment.Peek () != -1;
/* for future use
switch(fragType)
{
case XmlNodeType.Attribute: // attribute content
parserContext.InputState = XmlParserInputState.AttributeValue;
break;
case XmlNodeType.DocumentFragment: // element content
parserContext.InputState = XmlParserInputState.Content;
break;
case XmlNodeType.Element: // one element
parserContext.InputState = XmlParserInputState.StartTag;
break;
case XmlNodeType.Document: // document content
parserContext.InputState = XmlParserInputState.Start;
break;
default:
throw new InvalidOperationException("setting this xml node type not allowed.");
}
*/
}
#endregion
#region Privates
private XmlParserContext parserContext;
private TextReader reader;
private ReadState readState;
private int depth;
private int elementDepth;
private bool depthDown;
private bool popScope;
private XmlNodeType nodeType;
private string name;
private string prefix;
private string localName;
private string namespaceURI;
private bool isEmptyElement;
private string value;
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 char [] valueBuffer;
private int valueLength;
private int valueCapacity;
private const int initialValueCapacity = 8192;
private StringBuilder xmlBuffer; // This is for Read(Inner|Outer)Xml
private StringBuilder currentTag; // A buffer for ReadContent for ReadOuterXml
private bool saveToXmlBuffer;
private int line = 1;
private int column = 1;
private bool has_peek;
private bool can_seek;
private int peek_char;
private string attributeString = String.Empty;
private int attributeStringCurrentPosition;
private void Init ()
{
readState = ReadState.Initial;
depth = 0;
depthDown = false;
popScope = false;
nodeType = XmlNodeType.None;
name = String.Empty;
prefix = String.Empty;
localName = string.Empty;
isEmptyElement = false;
value = String.Empty;
attributes = new Hashtable ();
orderedAttributes = new ArrayList ();
orderedAttributesEnumerator = null;
returnEntityReference = false;
entityReferenceName = String.Empty;
nameBuffer = new char [initialNameCapacity];
nameLength = 0;
nameCapacity = initialNameCapacity;
valueBuffer = new char [initialValueCapacity];
valueLength = 0;
valueCapacity = initialValueCapacity;
xmlBuffer = new StringBuilder ();
currentTag = new StringBuilder ();
}
// 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;
if (clearAttributes)
ClearAttributes ();
int indexOfColon = name.IndexOf (':');
if (indexOfColon == -1) {
prefix = String.Empty;
localName = name;
} else {
prefix = name.Substring (0, indexOfColon);
localName = name.Substring (indexOfColon + 1);
}
namespaceURI = LookupNamespace (prefix);
}
private void SaveProperties ()
{
saveNodeType = nodeType;
saveName = name;
savePrefix = prefix;
saveLocalName = localName;
saveNamespaceURI = namespaceURI;
saveIsEmptyElement = isEmptyElement;
// An element's value is always String.Empty.
}
private void RestoreProperties ()
{
nodeType = saveNodeType;
name = saveName;
prefix = savePrefix;
localName = saveLocalName;
namespaceURI = saveNamespaceURI;
isEmptyElement = saveIsEmptyElement;
value = String.Empty;
}
private void AddAttribute (string name, string value)
{
attributes.Add (name, value);
orderedAttributes.Add (name);
}
private void ClearAttributes ()
{
if (attributes.Count > 0) {
attributes.Clear ();
orderedAttributes.Clear ();
}
orderedAttributesEnumerator = null;
}
private int PeekChar ()
{
if (can_seek)
return reader.Peek ();
if (has_peek)
return peek_char;
peek_char = reader.Read ();
has_peek = true;
return peek_char;
}
private int ReadChar ()
{
int ch;
if (has_peek) {
ch = peek_char;
has_peek = false;
} else {
ch = reader.Read ();
}
if (ch == '\n') {
line++;
column = 1;
} else {
column++;
}
if (saveToXmlBuffer) {
xmlBuffer.Append ((char) ch);
}
currentTag.Append ((char) ch);
return ch;
}
// 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':
if (whitespaceHandling == WhitespaceHandling.All ||
whitespaceHandling == WhitespaceHandling.Significant)
return ReadWhitespace ();
ReadChar ();
return ReadContent ();
case '\n':
if (whitespaceHandling == WhitespaceHandling.All ||
whitespaceHandling == WhitespaceHandling.Significant)
return ReadWhitespace ();
ReadChar ();
return ReadContent ();
case ' ':
if (whitespaceHandling == WhitespaceHandling.All ||
whitespaceHandling == WhitespaceHandling.Significant)
return ReadWhitespace ();
SkipWhitespace ();
return ReadContent ();
case -1:
readState = ReadState.EndOfFile;
SetProperties (
XmlNodeType.None, // nodeType
String.Empty, // name
false, // isEmptyElement
String.Empty, // value
true // clearAttributes
);
break;
default:
ReadText (true);
break;
}
}
return this.ReadState != ReadState.EndOfFile;
}
private void SetEntityReferenceProperties ()
{
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 ()
{
parserContext.NamespaceManager.PushScope ();
string name = ReadName ();
SkipWhitespace ();
bool isEmptyElement = false;
ClearAttributes ();
if (XmlChar.IsFirstNameChar (PeekChar ()))
ReadAttributes ();
if (PeekChar () == '/') {
ReadChar ();
isEmptyElement = true;
depthDown = true;
popScope = true;
}
Expect ('>');
SetProperties (
XmlNodeType.Element, // nodeType
name, // name
isEmptyElement, // isEmptyElement
String.Empty, // value
false // clearAttributes
);
if (!depthDown)
++depth;
else
depthDown = false;
}
// The reader is positioned on the first character
// of the element's name.
private void ReadEndTag ()
{
string name = ReadName ();
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 new String (nameBuffer, 0, nameLength);
}
private void AppendValueChar (int ch)
{
CheckValueCapacity ();
valueBuffer [valueLength++] = (char)ch;
}
private void CheckValueCapacity ()
{
if (valueLength == valueCapacity) {
valueCapacity = valueCapacity * 2;
char [] oldValueBuffer = valueBuffer;
valueBuffer = new char [valueCapacity];
Array.Copy (oldValueBuffer, valueBuffer, valueLength);
}
}
private string CreateValueString ()
{
return new String (valueBuffer, 0, valueLength);
}
// The reader is positioned on the first character
// of the text.
private void ReadText (bool cleanValue)
{
if (cleanValue)
valueLength = 0;
int ch = PeekChar ();
while (ch != '<' && ch != -1) {
if (ch == '&') {
ReadChar ();
if (ReadReference (false))
break;
} else
AppendValueChar (ReadChar ());
ch = PeekChar ();
}
if (returnEntityReference && valueLength == 0) {
SetEntityReferenceProperties ();
} else {
SetProperties (
XmlNodeType.Text, // nodeType
String.Empty, // name
false, // isEmptyElement
CreateValueString (), // 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 (
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 (
String.Format (
"invalid decimal digit: {0} (#x{1:X})",
(char)ch,
ch));
}
}
ReadChar (); // ';'
AppendValueChar (value);
}
private void ReadEntityReference (bool ignoreEntityReferences)
{
nameLength = 0;
int ch = PeekChar ();
while (ch != ';' && ch != -1) {
AppendNameChar (ReadChar ());
ch = PeekChar ();
}
Expect (';');
string name = CreateNameString ();
switch (name)
{
case "lt":
AppendValueChar ('<');
break;
case "gt":
AppendValueChar ('>');
break;
case "amp":
AppendValueChar ('&');
break;
case "apos":
AppendValueChar ('\'');
break;
case "quot":
AppendValueChar ('"');
break;
default:
if (ignoreEntityReferences) {
AppendValueChar ('&');
foreach (char ch2 in name) {
AppendValueChar (ch2);
}
AppendValueChar (';');
} else {
returnEntityReference = true;
entityReferenceName = name;
}
break;
}
}
// The reader is positioned on the first character of
// the attribute name.
private void ReadAttributes ()
{
do {
string name = ReadName ();
SkipWhitespace ();
Expect ('=');
SkipWhitespace ();
string value = ReadAttribute ();
SkipWhitespace ();
if (name == "xmlns")
parserContext.NamespaceManager.AddNamespace (String.Empty, value);
else if (name.StartsWith ("xmlns:"))
parserContext.NamespaceManager.AddNamespace (name.Substring (6), value);
AddAttribute (name, value);
} while (PeekChar () != '/' && PeekChar () != '>' && PeekChar () != -1);
}
// The reader is positioned on the quote character.
private string ReadAttribute ()
{
int quoteChar = ReadChar ();
if (quoteChar != '\'' && quoteChar != '\"')
throw new XmlException ("an attribute value was not quoted");
valueLength = 0;
while (PeekChar () != quoteChar) {
int ch = ReadChar ();
switch (ch)
{
case '<':
throw new XmlException ("attribute values cannot contain '<'");
// expansion of entity now should be done at ResolveAttributeValue() method
// case '&':
// ReadReference (true);
// break;
case -1:
throw new XmlException ("unexpected end of file in an attribute value");
default:
AppendValueChar (ch);
break;
}
}
ReadChar (); // quoteChar
return CreateValueString ();
}
// The reader is positioned on the first character
// of the target.
//
// Now it also reads XmlDeclaration, this method name became improper...
private void ReadProcessingInstruction ()
{
string target = ReadName ();
SkipWhitespace ();
valueLength = 0;
while (PeekChar () != -1) {
int ch = ReadChar ();
if (ch == '?' && PeekChar () == '>') {
ReadChar ();
break;
}
AppendValueChar ((char)ch);
}
/* for future use
if(target == "xml") && parserContext.InputState != XmlParserInputState.Start)
throw new XmlException("Xml declaration is not allowed here.");
else {
parserContext.InputState = XmlParserInputState.DTD; //for future use
}
*/
SetProperties (
target == "xml" ?
XmlNodeType.XmlDeclaration :
XmlNodeType.ProcessingInstruction, // nodeType
target, // name
false, // isEmptyElement
CreateValueString (), // value
true // 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;
}
}
// The reader is positioned on the first character after
// the leading '<!--'.
private void ReadComment ()
{
valueLength = 0;
while (PeekChar () != -1) {
int ch = ReadChar ();
if (ch == '-' && PeekChar () == '-') {
ReadChar ();
if (PeekChar () != '>')
throw new XmlException ("comments cannot contain '--'");
ReadChar ();
break;
}
AppendValueChar ((char)ch);
}
SetProperties (
XmlNodeType.Comment, // nodeType
String.Empty, // name
false, // isEmptyElement
CreateValueString (), // value
true // clearAttributes
);
}
// The reader is positioned on the first character after
// the leading '<![CDATA['.
private void ReadCDATA ()
{
valueLength = 0;
while (PeekChar () != -1) {
int ch = ReadChar ();
if (ch == ']' && PeekChar () == ']') {
ch = ReadChar (); // ']'
if (PeekChar () == '>') {
ReadChar (); // '>'
break;
} else {
AppendValueChar (']');
AppendValueChar (']');
ch = ReadChar ();
}
}
AppendValueChar ((char)ch);
}
SetProperties (
XmlNodeType.CDATA, // nodeType
String.Empty, // name
false, // isEmptyElement
CreateValueString (), // value
true // clearAttributes
);
}
// The reader is positioned on the first character after
// the leading '<!DOCTYPE'.
private void ReadDoctypeDecl ()
{
string doctypeName = null;
string publicId = String.Empty;
string systemId = String.Empty;
SkipWhitespace ();
doctypeName = ReadName ();
SkipWhitespace ();
xmlBuffer.Length = 0;
switch(PeekChar ())
{
case 'S':
systemId = ReadSystemLiteral (true);
break;
case 'P':
publicId = ReadPubidLiteral ();
SkipWhitespace ();
systemId = ReadSystemLiteral (false);
break;
}
SkipWhitespace ();
if(PeekChar () == '[')
{
// read markupdecl etc. or end of decl
ReadChar ();
xmlBuffer.Length = 0;
saveToXmlBuffer = true;
do {
ReadDTDInternalSubset ();
} while(nodeType != XmlNodeType.None);
xmlBuffer.Remove (xmlBuffer.Length - 1, 1); // cut off ']'
saveToXmlBuffer = false;
}
// end of DOCTYPE decl.
SkipWhitespace ();
Expect ('>');
parserContext.InternalSubset = xmlBuffer.ToString ();
// set properties for <!DOCTYPE> node
SetProperties (
XmlNodeType.DocumentType, // nodeType
doctypeName, // name
false, // isEmptyElement
parserContext.InternalSubset, // value
true // clearAttributes
);
}
// 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 ReadDTDInternalSubset()
{
SkipWhitespace ();
switch(ReadChar ())
{
case ']':
nodeType = XmlNodeType.None;
break;
case '%':
string peName = ReadName ();
Expect (';');
nodeType = XmlNodeType.EntityReference; // It's chating a bit;-)
break;
case '<':
switch(ReadChar ())
{
case '?':
ReadProcessingInstruction ();
break;
case '!':
switch(ReadChar ())
{
case '-':
Expect ('-');
ReadComment ();
break;
case 'E':
switch(ReadChar ())
{
case 'N':
Expect ("TITY");
ReadEntityDecl ();
break;
case 'L':
Expect ("EMENT");
ReadElementDecl ();
break;
default:
throw new XmlException ("Syntax Error after '<!E' (ELEMENT or ENTITY must be found)");
}
break;
case 'A':
Expect ("TTLIST");
ReadAttListDecl ();
break;
case 'N':
Expect ("OTATION");
ReadNotationDecl ();
break;
default:
throw new XmlException ("Syntax Error after '<!' characters.");
}
break;
default:
throw new XmlException ("Syntax Error after '<' character.");
}
break;
default:
throw new XmlException ("Syntax Error inside doctypedecl markup.");
}
}
// The reader is positioned on the head of the name.
private void ReadElementDecl()
{
while(ReadChar () != '>');
}
private void ReadEntityDecl()
{
while(ReadChar () != '>');
}
private void ReadAttListDecl()
{
while(ReadChar () != '>');
}
private void ReadNotationDecl()
{
while(ReadChar () != '>');
}
// The reader is positioned on the first 'S' of "SYSTEM".
private string ReadSystemLiteral (bool expectSYSTEM)
{
if(expectSYSTEM)
Expect ("SYSTEM");
SkipWhitespace ();
int quoteChar = ReadChar (); // apos or quot
xmlBuffer.Length = 0;
saveToXmlBuffer = true;
int c = 0;
while(c != quoteChar) {
c = ReadChar ();
if(c < 0) throw new XmlException ("Unexpected end of stream in ExternalID.");
}
saveToXmlBuffer = false;
xmlBuffer.Remove (xmlBuffer.Length-1, 1); // cut quoteChar
return xmlBuffer.ToString ();
}
private string ReadPubidLiteral()
{
Expect ("PUBLIC");
SkipWhitespace ();
int quoteChar = ReadChar ();
xmlBuffer.Length = 0;
saveToXmlBuffer = true;
int c = 0;
while(c != quoteChar)
{
c = ReadChar ();
if(c < 0) throw new XmlException ("Unexpected end of stream in ExternalID.");
if(c != quoteChar && !XmlChar.IsPubidChar (c))
throw new XmlException("character '" + (char)c + "' not allowed for PUBLIC ID");
}
ReadChar(); // skips quoteChar
xmlBuffer.Remove (xmlBuffer.Length-1, 1); // cut quoteChar
saveToXmlBuffer = false;
return xmlBuffer.ToString ();
}
// The reader is positioned on the first character
// of the name.
private string ReadName ()
{
if (!XmlChar.IsFirstNameChar (PeekChar ()))
throw new XmlException ("a name did not start with a legal character");
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 (
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 void SkipWhitespace ()
{
//FIXME: Should not skip if whitespaceHandling == WhiteSpaceHandling.None
while (XmlChar.IsWhitespace (PeekChar ()))
ReadChar ();
}
private bool ReadWhitespace ()
{
valueLength = 0;
int ch = PeekChar ();
do {
AppendValueChar (ReadChar ());
} while ((ch = PeekChar ()) != -1 && XmlChar.IsWhitespace (ch));
if (ch != -1 && ch != '<')
ReadText (false);
else
SetProperties (XmlNodeType.Whitespace,
String.Empty,
false,
CreateValueString (),
true);
return (PeekChar () != -1);
}
// read entity reference from attribute string and if parsable then return the value.
private string ReadAttributeValueEntityReference ()
{
int endEntityPosition = attributeString.IndexOf(';',
attributeStringCurrentPosition);
string entityName = attributeString.Substring (attributeStringCurrentPosition + 1,
endEntityPosition - attributeStringCurrentPosition - 1);
attributeStringCurrentPosition = 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 ResolveAttributeValue (string unresolved)
{
if(unresolved == null) return null;
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 {
switch(entityName) {
case "lt": resolved.Append ("<"); break;
case "gt": resolved.Append (">"); break;
case "amp": resolved.Append ("&"); break;
case "quot": resolved.Append ("\""); break;
case "apos": resolved.Append ("'"); break;
// With respect to "Value", MS document is helpless
// and the implemention returns inconsistent value
// (e.g. XML: "&ent; &amp;ent;" ---> Value: "&ent; &ent;".)
default: resolved.Append ("&" + entityName + ";"); break;
}
}
pos = endPos + 1;
if(pos > unresolved.Length)
break;
next = unresolved.IndexOf('&', pos);
}
resolved.Append (unresolved.Substring(pos));
return resolved.ToString();
}
#endregion
}
}