mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
* DTDValidatingReader.cs :
- Added ID support in ValidateAttributes().
- More refined ReadAttributeValue() support for non-expanding entity
situation
- It should handle LocalName, Name, Prefix, NamespaceURI and Value
correctly when the reader is on each of the value nodes of an
attribute. Now XmlDocument.ReadNode() should work well.
* XmlDocument.cs :
- added idTable, AddIdenticalAttribute(), GetIdenticalAttribute() and
RemoveIdenticalAttribute()
- Implemented GetAttributeById().
* XmlAttributeCollection.cs :
- added private ownerDocument property and replaced
ownerElement.OwnerDocument with it.
- Added AdjustIdenticalAttribute() and it is used in SetNamedItem().
It calls XmlDocument.{Add|Remove}IdenticalAttribute().
- Added RemoveIdenticalAttribute() and it is used in Remove().
(I also added AddIdenticalAttribute() but is not used.)
svn path=/trunk/mcs/; revision=16717
734 lines
19 KiB
C#
734 lines
19 KiB
C#
using System;
|
|
using System.Collections.Specialized;
|
|
using System.Collections;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
|
|
namespace Mono.Xml
|
|
{
|
|
public class DTDValidatingReader : /*XmlValidatingReader*/XmlReader, IXmlLineInfo
|
|
{
|
|
public DTDValidatingReader (XmlReader reader)
|
|
: this (reader, null)
|
|
{
|
|
}
|
|
|
|
public DTDValidatingReader (XmlReader reader,
|
|
XmlValidatingReader validatingReader)
|
|
// : base (reader)
|
|
{
|
|
this.reader = reader;
|
|
this.sourceTextReader = reader as XmlTextReader;
|
|
elementStack = new Stack ();
|
|
automataStack = new Stack ();
|
|
attributes = new StringCollection ();
|
|
attributeValues = new NameValueCollection ();
|
|
this.validatingReader = validatingReader;
|
|
valueBuilder = new StringBuilder ();
|
|
idList = new ArrayList ();
|
|
missingIDReferences = new ArrayList ();
|
|
}
|
|
|
|
XmlReader reader;
|
|
XmlTextReader sourceTextReader;
|
|
DTDObjectModel dtd;
|
|
Stack elementStack;
|
|
Stack automataStack;
|
|
string currentElement;
|
|
string currentAttribute;
|
|
bool consumedAttribute;
|
|
bool insideContent;
|
|
// bool insideAttributeValue;
|
|
DTDAutomata currentAutomata;
|
|
DTDAutomata previousAutomata;
|
|
bool isStandalone;
|
|
StringCollection attributes;
|
|
NameValueCollection attributeValues;
|
|
StringBuilder valueBuilder;
|
|
ArrayList idList;
|
|
ArrayList missingIDReferences;
|
|
|
|
XmlValidatingReader validatingReader;
|
|
// ValidationEventHandler handler;
|
|
|
|
public DTDObjectModel DTD {
|
|
get { return dtd; }
|
|
}
|
|
|
|
public override void Close ()
|
|
{
|
|
reader.Close ();
|
|
}
|
|
|
|
// We had already done attribute validation, so can ignore name.
|
|
public override string GetAttribute (int i)
|
|
{
|
|
if (dtd == null)
|
|
return reader.GetAttribute (i);
|
|
|
|
if (attributes.Count <= i)
|
|
throw new IndexOutOfRangeException ("Specified index is out of range: " + i);
|
|
|
|
return FilterNormalization (attributeValues [i]);
|
|
}
|
|
|
|
public override string GetAttribute (string name)
|
|
{
|
|
if (dtd == null)
|
|
return reader.GetAttribute (name);
|
|
|
|
return FilterNormalization (attributeValues [name]);
|
|
}
|
|
|
|
public override string GetAttribute (string name, string ns)
|
|
{
|
|
if (dtd == null)
|
|
return reader.GetAttribute (name, ns);
|
|
|
|
// FIXME: check whether this way is correct.
|
|
if (ns == String.Empty)
|
|
return GetAttribute (name);
|
|
else
|
|
return FilterNormalization (reader.GetAttribute (name, ns));
|
|
}
|
|
|
|
bool IXmlLineInfo.HasLineInfo ()
|
|
{
|
|
IXmlLineInfo ixli = reader as IXmlLineInfo;
|
|
if (ixli != null)
|
|
return ixli.HasLineInfo ();
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public override string LookupNamespace (string prefix)
|
|
{
|
|
// Does it mean anything with DTD?
|
|
return reader.LookupNamespace (prefix);
|
|
}
|
|
|
|
public override void MoveToAttribute (int i)
|
|
{
|
|
if (dtd == null) {
|
|
reader.MoveToAttribute (i);
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
return;
|
|
}
|
|
|
|
if (currentElement == null)
|
|
return;
|
|
|
|
if (attributes.Count > i) {
|
|
currentAttribute = attributes [i];
|
|
consumedAttribute = false;
|
|
return;
|
|
} else
|
|
throw new IndexOutOfRangeException ("The index is out of range.");
|
|
}
|
|
|
|
public override bool MoveToAttribute (string name)
|
|
{
|
|
if (dtd == null) {
|
|
bool b = reader.MoveToAttribute (name);
|
|
if (b) {
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
if (currentElement == null)
|
|
return false;
|
|
|
|
int idx = attributes.IndexOf (name);
|
|
if (idx >= 0) {
|
|
currentAttribute = name;
|
|
consumedAttribute = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToAttribute (string name, string ns)
|
|
{
|
|
if (dtd == null) {
|
|
bool b = reader.MoveToAttribute (name, ns);
|
|
if (b) {
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
if (reader.MoveToAttribute (name, ns)) {
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
return true;
|
|
}
|
|
|
|
if (ns != String.Empty)
|
|
throw new InvalidOperationException ("DTD validating reader does not support namespace.");
|
|
return MoveToAttribute (name);
|
|
}
|
|
|
|
public override bool MoveToElement ()
|
|
{
|
|
bool b = reader.MoveToElement ();
|
|
if (!b)
|
|
return false;
|
|
currentAttribute = null;
|
|
consumedAttribute = false;
|
|
return true;
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute ()
|
|
{
|
|
if (dtd == null) {
|
|
bool b = reader.MoveToFirstAttribute ();
|
|
if (b) {
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
// It should access attributes by *defined* order.
|
|
if (NodeType != XmlNodeType.Element)
|
|
return false;
|
|
|
|
if (attributes.Count == 0)
|
|
return false;
|
|
reader.MoveToFirstAttribute ();
|
|
currentAttribute = attributes [0];
|
|
consumedAttribute = false;
|
|
return true;
|
|
}
|
|
|
|
public override bool MoveToNextAttribute ()
|
|
{
|
|
if (dtd == null) {
|
|
bool b = reader.MoveToNextAttribute ();
|
|
if (b) {
|
|
currentAttribute = reader.Name;
|
|
consumedAttribute = false;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
if (currentAttribute == null)
|
|
return MoveToFirstAttribute ();
|
|
|
|
int idx = attributes.IndexOf (currentAttribute);
|
|
if (idx + 1 < attributes.Count) {
|
|
reader.MoveToNextAttribute ();
|
|
currentAttribute = attributes [idx + 1];
|
|
consumedAttribute = false;
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
[MonoTODO]
|
|
public override bool Read ()
|
|
{
|
|
MoveToElement ();
|
|
|
|
bool b = reader.Read ();
|
|
currentElement = null;
|
|
currentAttribute = null;
|
|
consumedAttribute = false;
|
|
attributes.Clear ();
|
|
attributeValues.Clear ();
|
|
|
|
if (!insideContent && reader.NodeType == XmlNodeType.Element) {
|
|
insideContent = true;
|
|
if (dtd == null)
|
|
currentAutomata = null;
|
|
else
|
|
currentAutomata = dtd.RootAutomata;
|
|
}
|
|
|
|
if (!b) {
|
|
if (elementStack.Count != 0)
|
|
throw new InvalidOperationException ("Unexpected end of XmlReader.");
|
|
return false;
|
|
}
|
|
|
|
switch (reader.NodeType) {
|
|
case XmlNodeType.XmlDeclaration:
|
|
if (GetAttribute ("standalone") == "yes")
|
|
isStandalone = true;
|
|
break;
|
|
|
|
case XmlNodeType.DocumentType:
|
|
XmlTextReader xmlTextReader = reader as XmlTextReader;
|
|
if (xmlTextReader == null) {
|
|
xmlTextReader = new XmlTextReader ("", XmlNodeType.Document, null);
|
|
xmlTextReader.GenerateDTDObjectModel (reader.Name,
|
|
reader ["PUBLIC"], reader ["SYSTEM"], reader.Value);
|
|
}
|
|
this.dtd = xmlTextReader.DTD;
|
|
break;
|
|
|
|
case XmlNodeType.Element: // startElementDeriv
|
|
// If no schema specification, then skip validation.
|
|
if (currentAutomata == null) {
|
|
SetupValidityIgnorantAttributes ();
|
|
break;
|
|
}
|
|
|
|
previousAutomata = currentAutomata;
|
|
currentAutomata = currentAutomata.TryStartElement (reader.Name);
|
|
if (currentAutomata == DTD.Invalid) {
|
|
HandleError (String.Format ("Invalid start element found: {0}", reader.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
currentAutomata = previousAutomata;
|
|
}
|
|
DTDElementDeclaration decl = DTD.ElementDecls [reader.Name];
|
|
if (decl == null) {
|
|
HandleError (String.Format ("Element {0} is not declared.", reader.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
currentAutomata = previousAutomata;
|
|
}
|
|
|
|
currentElement = Name;
|
|
elementStack.Push (reader.Name);
|
|
automataStack.Push (currentAutomata);
|
|
if (decl != null) { // i.e. not invalid
|
|
currentAutomata = decl.ContentModel.GetAutomata ();
|
|
|
|
// check attributes
|
|
if (decl.Attributes == null) {
|
|
if (reader.HasAttributes) {
|
|
HandleError (String.Format ("Attributes are found on element {0} while it has no attribute definitions.",decl.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
}
|
|
}
|
|
else
|
|
ValidateAttributes (decl);
|
|
} else
|
|
SetupValidityIgnorantAttributes ();
|
|
|
|
// If it is empty element then directly check end element.
|
|
if (reader.IsEmptyElement)
|
|
goto case XmlNodeType.EndElement;
|
|
break;
|
|
|
|
case XmlNodeType.EndElement: // endElementDeriv
|
|
// If no schema specification, then skip validation.
|
|
if (currentAutomata == null)
|
|
break;
|
|
|
|
decl = DTD.ElementDecls [reader.Name];
|
|
if (decl == null) {
|
|
HandleError (String.Format ("Element {0} is not declared.", reader.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
}
|
|
|
|
previousAutomata = currentAutomata;
|
|
// Don't let currentAutomata
|
|
DTDAutomata tmpAutomata = currentAutomata.TryEndElement ();
|
|
if (tmpAutomata == DTD.Invalid) {
|
|
HandleError (String.Format ("Invalid end element found: {0}", reader.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
currentAutomata = previousAutomata;
|
|
}
|
|
|
|
elementStack.Pop ();
|
|
currentAutomata = automataStack.Pop () as DTDAutomata;
|
|
break;
|
|
|
|
case XmlNodeType.CDATA:
|
|
case XmlNodeType.SignificantWhitespace:
|
|
case XmlNodeType.Text:
|
|
// If no schema specification, then skip validation.
|
|
if (currentAutomata == null)
|
|
break;
|
|
|
|
DTDElementDeclaration elem = dtd.ElementDecls [elementStack.Peek () as string];
|
|
if (!elem.IsMixedContent) {
|
|
HandleError (String.Format ("Current element {0} does not allow character data content.", elementStack.Peek () as string),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
currentAutomata = previousAutomata;
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void SetupValidityIgnorantAttributes ()
|
|
{
|
|
if (reader.MoveToFirstAttribute ()) {
|
|
// If it was invalid, simply add specified attributes.
|
|
do {
|
|
attributes.Add (reader.Name);
|
|
attributeValues.Add (reader.Name, reader.Value);
|
|
} while (reader.MoveToNextAttribute ());
|
|
reader.MoveToElement ();
|
|
}
|
|
}
|
|
|
|
private void HandleError (string message, XmlSeverityType severity)
|
|
{
|
|
if (validatingReader != null &&
|
|
validatingReader.ValidationType == ValidationType.None)
|
|
return;
|
|
|
|
IXmlLineInfo info = this as IXmlLineInfo;
|
|
bool hasLine = info.HasLineInfo ();
|
|
XmlSchemaException ex = new XmlSchemaException (
|
|
message,
|
|
hasLine ? info.LineNumber : 0,
|
|
hasLine ? info.LinePosition : 0,
|
|
null,
|
|
BaseURI,
|
|
null);
|
|
|
|
if (validatingReader != null)
|
|
this.validatingReader.OnValidationEvent (this,
|
|
new ValidationEventArgs (ex, message, severity));
|
|
else
|
|
throw ex;
|
|
}
|
|
|
|
private void ValidateAttributes (DTDElementDeclaration decl)
|
|
{
|
|
while (reader.MoveToNextAttribute ()) {
|
|
string attrName = reader.Name;
|
|
attributes.Add (attrName);
|
|
bool hasError = false;
|
|
while (reader.ReadAttributeValue ()) {
|
|
if (reader.NodeType == XmlNodeType.EntityReference) {
|
|
DTDEntityDeclaration edecl = DTD.EntityDecls [reader.Name];
|
|
if (edecl == null) {
|
|
HandleError (String.Format ("Referenced entity {0} is not declared.", reader.Name),
|
|
XmlSeverityType.Error);
|
|
hasError = true;
|
|
}
|
|
else
|
|
valueBuilder.Append (edecl.EntityValue);
|
|
}
|
|
else
|
|
valueBuilder.Append (reader.Value);
|
|
}
|
|
reader.MoveToElement ();
|
|
reader.MoveToAttribute (attrName);
|
|
string attrValue = valueBuilder.ToString ();
|
|
valueBuilder.Length = 0;
|
|
attributeValues.Add (attrName, attrValue);
|
|
|
|
DTDAttributeDefinition def = decl.Attributes [reader.Name];
|
|
if (def == null) {
|
|
HandleError (String.Format ("Attribute {0} is not declared.", reader.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
} else {
|
|
// check identity constraint
|
|
switch (def.Datatype.TokenizedType) {
|
|
case XmlTokenizedType.ID:
|
|
if (this.idList.Contains (attrValue)) {
|
|
HandleError (String.Format ("Node with ID {0} was already appeared.", attrValue),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
} else {
|
|
if (missingIDReferences.Contains (attrValue))
|
|
missingIDReferences.Remove (attrValue);
|
|
idList.Add (attrValue);
|
|
}
|
|
break;
|
|
case XmlTokenizedType.IDREF:
|
|
if (!idList.Contains (attrValue))
|
|
missingIDReferences.Add (attrValue);
|
|
break;
|
|
case XmlTokenizedType.IDREFS:
|
|
string [] idrefs = def.Datatype.ParseValue (attrValue, NameTable, null) as string [];
|
|
foreach (string idref in idrefs)
|
|
if (!idList.Contains (attrValue))
|
|
missingIDReferences.Add (attrValue);
|
|
break;
|
|
}
|
|
|
|
switch (def.OccurenceType) {
|
|
case DTDAttributeOccurenceType.Required:
|
|
if (attrValue == String.Empty) {
|
|
HandleError (String.Format ("Required attribute {0} in element {1} not found .",
|
|
def.Name, decl.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
}
|
|
break;
|
|
case DTDAttributeOccurenceType.Fixed:
|
|
if (attrValue != def.DefaultValue) {
|
|
HandleError (String.Format ("Fixed attribute {0} in element {1} has invalid value {2}.",
|
|
def.Name, decl.Name, attrValue),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Check if all required attributes exist, and/or
|
|
// if there is default values, then add them.
|
|
foreach (DTDAttributeDefinition def in decl.Attributes.Definitions)
|
|
if (!attributes.Contains (def.Name)) {
|
|
if (def.OccurenceType == DTDAttributeOccurenceType.Required) {
|
|
HandleError (String.Format ("Required attribute {0} was not found.", decl.Name),
|
|
XmlSeverityType.Error);
|
|
// FIXME: validation recovery code here.
|
|
}
|
|
else if (def.DefaultValue != null) {
|
|
attributes.Add (def.Name);
|
|
attributeValues.Add (def.Name, def.DefaultValue);
|
|
}
|
|
}
|
|
|
|
reader.MoveToElement ();
|
|
}
|
|
|
|
public override bool ReadAttributeValue ()
|
|
{
|
|
if (consumedAttribute)
|
|
return false;
|
|
if (NodeType == XmlNodeType.Attribute &&
|
|
validatingReader.EntityHandling == EntityHandling.ExpandEntities) {
|
|
consumedAttribute = true;
|
|
return true;
|
|
}
|
|
else
|
|
return reader.ReadAttributeValue ();
|
|
}
|
|
|
|
public override string ReadInnerXml ()
|
|
{
|
|
// MS.NET 1.0 has a serious bug here. It skips validation.
|
|
return reader.ReadInnerXml ();
|
|
}
|
|
|
|
public override string ReadOuterXml ()
|
|
{
|
|
// MS.NET 1.0 has a serious bug here. It skips validation.
|
|
return reader.ReadOuterXml ();
|
|
}
|
|
|
|
public override string ReadString ()
|
|
{
|
|
// It seems to be the same as ReadInnerXml().
|
|
return reader.ReadString ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public override void ResolveEntity ()
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
public override int AttributeCount {
|
|
get {
|
|
if (dtd == null || !insideContent)
|
|
return reader.AttributeCount;
|
|
|
|
return attributes.Count;
|
|
}
|
|
}
|
|
|
|
[MonoTODO ("Should consider general entities.")]
|
|
public override string BaseURI {
|
|
get {
|
|
return reader.BaseURI;
|
|
}
|
|
}
|
|
|
|
public override bool CanResolveEntity {
|
|
get { return true; }
|
|
}
|
|
|
|
[MonoTODO ("Should consider general entities' depth")]
|
|
public override int Depth {
|
|
get { return IsDefault ? reader.Depth + 1 : reader.Depth; }
|
|
}
|
|
|
|
[MonoTODO]
|
|
public override bool EOF {
|
|
get { return reader.EOF; }
|
|
}
|
|
|
|
public override bool HasValue {
|
|
get { return IsDefault ? true : reader.HasValue; }
|
|
}
|
|
|
|
public override bool IsDefault {
|
|
get {
|
|
if (currentAttribute == null)
|
|
return false;
|
|
return reader.GetAttribute (currentAttribute) == null;
|
|
}
|
|
}
|
|
|
|
public override bool IsEmptyElement {
|
|
get { return reader.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 name, string ns] {
|
|
get { return GetAttribute (name, ns); }
|
|
}
|
|
|
|
public int LineNumber {
|
|
get {
|
|
IXmlLineInfo info = reader as IXmlLineInfo;
|
|
return (info != null) ? info.LineNumber : 0;
|
|
}
|
|
}
|
|
|
|
public int LinePosition {
|
|
get {
|
|
IXmlLineInfo info = reader as IXmlLineInfo;
|
|
return (info != null) ? info.LinePosition : 0;
|
|
}
|
|
}
|
|
|
|
public override string LocalName {
|
|
get {
|
|
return IsDefault ?
|
|
consumedAttribute ? String.Empty : currentAttribute :
|
|
reader.LocalName;
|
|
}
|
|
}
|
|
|
|
public override string Name {
|
|
get {
|
|
return IsDefault ?
|
|
consumedAttribute ? String.Empty : currentAttribute :
|
|
reader.Name;
|
|
}
|
|
}
|
|
|
|
public override string NamespaceURI {
|
|
get {
|
|
return IsDefault ?
|
|
consumedAttribute ? String.Empty : String.Empty :
|
|
reader.NamespaceURI;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable {
|
|
get { return reader.NameTable; }
|
|
}
|
|
|
|
public override XmlNodeType NodeType {
|
|
get {
|
|
// If consumedAttribute is true, then entities must be resolved.
|
|
return consumedAttribute ? XmlNodeType.Text :
|
|
IsDefault ? XmlNodeType.Attribute :
|
|
reader.NodeType;
|
|
}
|
|
}
|
|
|
|
public override string Prefix {
|
|
get {
|
|
if (currentAttribute != null && NodeType != XmlNodeType.Attribute)
|
|
return String.Empty;
|
|
return IsDefault ? String.Empty : reader.Prefix;
|
|
}
|
|
}
|
|
|
|
public override char QuoteChar {
|
|
get {
|
|
// If it is not actually on an attribute, then it returns
|
|
// undefined value or '"'.
|
|
return reader.QuoteChar;
|
|
}
|
|
}
|
|
|
|
public override ReadState ReadState {
|
|
get {
|
|
return reader.ReadState;
|
|
}
|
|
}
|
|
|
|
char [] whitespaceChars = new char [] {' '};
|
|
private string FilterNormalization (string rawValue)
|
|
{
|
|
if (DTD != null &&
|
|
NodeType == XmlNodeType.Attribute &&
|
|
sourceTextReader != null &&
|
|
sourceTextReader.Normalization) {
|
|
DTDAttributeDefinition def =
|
|
dtd.ElementDecls [currentElement]
|
|
.Attributes [currentAttribute]
|
|
as DTDAttributeDefinition;
|
|
valueBuilder.Append (rawValue);
|
|
valueBuilder.Replace ('\r', ' ');
|
|
valueBuilder.Replace ('\n', ' ');
|
|
valueBuilder.Replace ('\t', ' ');
|
|
try {
|
|
if (def.Datatype.TokenizedType != XmlTokenizedType.CDATA) {
|
|
for (int i=0; i < valueBuilder.Length; i++) {
|
|
if (valueBuilder [i] == ' ') {
|
|
while (++i < valueBuilder.Length && valueBuilder [i] == ' ')
|
|
valueBuilder.Remove (i, 1);
|
|
}
|
|
}
|
|
return valueBuilder.ToString ().Trim (whitespaceChars);
|
|
}
|
|
else
|
|
return valueBuilder.ToString ();
|
|
} finally {
|
|
valueBuilder.Length = 0;
|
|
}
|
|
}
|
|
else
|
|
return rawValue;
|
|
}
|
|
|
|
public override string Value {
|
|
get {
|
|
// This check also covers value node of default attributes.
|
|
if (IsDefault) {
|
|
DTDAttributeDefinition def =
|
|
dtd.ElementDecls [currentElement]
|
|
.Attributes [currentAttribute]
|
|
as DTDAttributeDefinition;
|
|
return sourceTextReader != null && sourceTextReader.Normalization ?
|
|
def.NormalizedDefaultValue : def.DefaultValue;
|
|
}
|
|
// As to this property, MS.NET seems ignorant of EntityHandling...
|
|
else if (NodeType == XmlNodeType.Attribute)// &&
|
|
// validatingReader.EntityHandling == EntityHandling.ExpandEntities)
|
|
return FilterNormalization (attributeValues [currentAttribute]);
|
|
else if (consumedAttribute)
|
|
return FilterNormalization (attributeValues [this.currentAttribute]);
|
|
else
|
|
return FilterNormalization (reader.Value);
|
|
}
|
|
}
|
|
|
|
[MonoTODO ("Should consider default xml:lang values.")]
|
|
public override string XmlLang {
|
|
get { return reader.XmlLang; }
|
|
}
|
|
|
|
[MonoTODO ("Should consider default xml:space values.")]
|
|
public override XmlSpace XmlSpace {
|
|
get { return reader.XmlSpace; }
|
|
}
|
|
|
|
}
|
|
}
|