Files
mono/mcs/class/System.XML/System.Xml/DTDObjectModel.cs
T
Atsushi Eno f6a6ca4b93 2004-11-08 Atsushi Enomoto <[email protected]>
* DTDObjectModel.cs,
	  DTDReader.cs,
	  XmlReader.cs,
	  XmlTextReader.cs,
	  XmlException.cs :

	  Added support for 2.0 XmlException.SourceUri property. Improved
	  exception handling to contain BaseURI everywhere in the parser.

svn path=/trunk/mcs/; revision=35820
2004-11-08 09:18:29 +00:00

1124 lines
27 KiB
C#

//
// Mono.Xml.DTDObjectModel
//
// Author:
// Atsushi Enomoto ([email protected])
//
// (C)2003 Atsushi Enomoto
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using Mono.Xml.Schema;
#if NET_2_0
using XmlTextReaderImpl = Mono.Xml2.XmlTextReader;
#else
using XmlTextReaderImpl = System.Xml.XmlTextReader;
#endif
namespace Mono.Xml
{
internal class DTDObjectModel
{
// This specifies the max number of dependent external entities
// per a DTD can consume. A malicious external document server
// might send users' document processing server a large number
// of external entities.
public const int AllowedExternalEntitiesMax = 256;
DTDAutomataFactory factory;
DTDElementAutomata rootAutomata;
DTDEmptyAutomata emptyAutomata;
DTDAnyAutomata anyAutomata;
DTDInvalidAutomata invalidAutomata;
DTDElementDeclarationCollection elementDecls;
DTDAttListDeclarationCollection attListDecls;
DTDParameterEntityDeclarationCollection peDecls;
DTDEntityDeclarationCollection entityDecls;
DTDNotationDeclarationCollection notationDecls;
ArrayList validationErrors;
XmlResolver resolver;
XmlNameTable nameTable;
Hashtable externalResources;
string baseURI;
string name;
string publicId;
string systemId;
string intSubset;
bool intSubsetHasPERef;
bool isStandalone;
int lineNumber;
int linePosition;
public DTDObjectModel (XmlNameTable nameTable)
{
this.nameTable = nameTable;
elementDecls = new DTDElementDeclarationCollection (this);
attListDecls = new DTDAttListDeclarationCollection (this);
entityDecls = new DTDEntityDeclarationCollection (this);
peDecls = new DTDParameterEntityDeclarationCollection (this);
notationDecls = new DTDNotationDeclarationCollection (this);
factory = new DTDAutomataFactory (this);
validationErrors = new ArrayList ();
externalResources = new Hashtable ();
}
public string BaseURI {
get { return baseURI; }
set { baseURI = value; }
}
public bool IsStandalone {
get { return isStandalone; }
set { isStandalone = value; }
}
public string Name {
get { return name; }
set { name = value; }
}
public XmlNameTable NameTable {
get { return nameTable; }
}
public string PublicId {
get { return publicId; }
set { publicId = value; }
}
public string SystemId {
get { return systemId; }
set { systemId = value; }
}
public string InternalSubset {
get { return intSubset; }
set { intSubset = value; }
}
public bool InternalSubsetHasPEReference {
get { return intSubsetHasPERef; }
set { intSubsetHasPERef = value; }
}
public int LineNumber {
get { return lineNumber; }
set { lineNumber = value; }
}
public int LinePosition {
get { return linePosition; }
set { linePosition = value; }
}
public string ResolveEntity (string name)
{
DTDEntityDeclaration decl = EntityDecls [name]
as DTDEntityDeclaration;
if (decl == null) {
AddError (new XmlSchemaException ("Required entity was not found.",
this.LineNumber, this.LinePosition, null, this.BaseURI, null));
return " ";
}
else
return decl.EntityValue;
}
internal XmlResolver Resolver {
get { return resolver; }
}
public XmlResolver XmlResolver {
set { resolver = value; }
}
internal Hashtable ExternalResources {
get { return externalResources; }
}
public DTDAutomataFactory Factory {
get { return factory; }
}
public DTDElementDeclaration RootElement {
get { return ElementDecls [Name]; }
}
public DTDElementDeclarationCollection ElementDecls {
get { return elementDecls; }
}
public DTDAttListDeclarationCollection AttListDecls {
get { return attListDecls; }
}
public DTDEntityDeclarationCollection EntityDecls {
get { return entityDecls; }
}
public DTDParameterEntityDeclarationCollection PEDecls {
get { return peDecls; }
}
public DTDNotationDeclarationCollection NotationDecls {
get { return notationDecls; }
}
public DTDAutomata RootAutomata {
get {
if (rootAutomata == null)
rootAutomata = new DTDElementAutomata (this, this.Name);
return rootAutomata;
}
}
public DTDEmptyAutomata Empty {
get {
if (emptyAutomata == null)
emptyAutomata = new DTDEmptyAutomata (this);
return emptyAutomata;
}
}
public DTDAnyAutomata Any {
get {
if (anyAutomata == null)
anyAutomata = new DTDAnyAutomata (this);
return anyAutomata;
}
}
public DTDInvalidAutomata Invalid {
get {
if (invalidAutomata == null)
invalidAutomata = new DTDInvalidAutomata (this);
return invalidAutomata;
}
}
public XmlSchemaException [] Errors {
get { return validationErrors.ToArray (typeof (XmlSchemaException)) as XmlSchemaException []; }
}
public void AddError (XmlSchemaException ex)
{
validationErrors.Add (ex);
}
#if NET_2_0
internal string GenerateEntityAttributeText (string entityName)
{
DTDEntityDeclaration entity = EntityDecls [entityName] as DTDEntityDeclaration;
if (entity == null)
return null;
return entity.EntityValue;
}
internal XmlTextReaderImpl GenerateEntityContentReader (string entityName, XmlParserContext context)
{
DTDEntityDeclaration entity = EntityDecls [entityName] as DTDEntityDeclaration;
if (entity == null)
return null;
if (entity.SystemId != null) {
Uri baseUri = entity.BaseURI == null ? null : new Uri (entity.BaseURI);
Stream stream = resolver.GetEntity (resolver.ResolveUri (baseUri, entity.SystemId), null, typeof (Stream)) as Stream;
return new XmlTextReaderImpl (stream, XmlNodeType.Element, context);
}
else
return new XmlTextReaderImpl (entity.EntityValue, XmlNodeType.Element, context);
}
#endif
}
internal class DTDCollectionBase : DictionaryBase
{
DTDObjectModel root;
protected DTDCollectionBase (DTDObjectModel root)
{
this.root = root;
}
protected DTDObjectModel Root {
get { return root; }
}
public ICollection Keys {
get { return InnerHashtable.Keys; }
}
public ICollection Values {
get { return InnerHashtable.Values; }
}
}
internal class DTDElementDeclarationCollection : DTDCollectionBase
{
public DTDElementDeclarationCollection (DTDObjectModel root) : base (root) {}
public DTDElementDeclaration this [string name] {
get { return Get (name); }
}
public DTDElementDeclaration Get (string name)
{
return InnerHashtable [name] as DTDElementDeclaration;
}
public void Add (string name, DTDElementDeclaration decl)
{
if (InnerHashtable.Contains (name)) {
Root.AddError (new XmlSchemaException (String.Format (
"Element declaration for {0} was already added.",
name), null));
return;
}
decl.SetRoot (Root);
InnerHashtable.Add (name, decl);
}
}
internal class DTDAttListDeclarationCollection : DTDCollectionBase
{
public DTDAttListDeclarationCollection (DTDObjectModel root) : base (root) {}
public DTDAttListDeclaration this [string name] {
get { return InnerHashtable [name] as DTDAttListDeclaration; }
}
public void Add (string name, DTDAttListDeclaration decl)
{
DTDAttListDeclaration existing = this [name];
if (existing != null) {
// It is valid, that is additive declaration.
foreach (DTDAttributeDefinition def in decl.Definitions)
if (decl.Get (def.Name) == null)
existing.Add (def);
} else {
decl.SetRoot (Root);
InnerHashtable.Add (name, decl);
}
}
}
internal class DTDEntityDeclarationCollection : DTDCollectionBase
{
public DTDEntityDeclarationCollection (DTDObjectModel root) : base (root) {}
public DTDEntityDeclaration this [string name] {
get { return InnerHashtable [name] as DTDEntityDeclaration; }
}
public void Add (string name, DTDEntityDeclaration decl)
{
if (InnerHashtable [name] != null)
throw new InvalidOperationException (String.Format (
"Entity declaration for {0} was already added.",
name));
decl.SetRoot (Root);
InnerHashtable.Add (name, decl);
}
}
internal class DTDNotationDeclarationCollection : DTDCollectionBase
{
public DTDNotationDeclarationCollection (DTDObjectModel root) : base (root) {}
public DTDNotationDeclaration this [string name] {
get { return InnerHashtable [name] as DTDNotationDeclaration; }
}
public void Add (string name, DTDNotationDeclaration decl)
{
if (InnerHashtable [name] != null)
throw new InvalidOperationException (String.Format (
"Notation declaration for {0} was already added.",
name));
decl.SetRoot (Root);
InnerHashtable.Add (name, decl);
}
}
// This class contains either ElementName or ChildModels.
internal class DTDContentModel : DTDNode
{
DTDObjectModel root;
DTDAutomata compiledAutomata;
string ownerElementName;
string elementName;
DTDContentOrderType orderType = DTDContentOrderType.None;
DTDContentModelCollection childModels = new DTDContentModelCollection ();
DTDOccurence occurence = DTDOccurence.One;
internal DTDContentModel (DTDObjectModel root, string ownerElementName)
{
this.root = root;
this.ownerElementName = ownerElementName;
}
public DTDContentModelCollection ChildModels {
get { return childModels; }
set { childModels = value; }
}
public DTDElementDeclaration ElementDecl {
get { return root.ElementDecls [ownerElementName]; }
}
public string ElementName {
get { return elementName; }
set { elementName = value; }
}
public DTDOccurence Occurence {
get { return occurence; }
set { occurence = value; }
}
public DTDContentOrderType OrderType {
get { return orderType; }
set { orderType = value; }
}
public DTDAutomata GetAutomata ()
{
if (compiledAutomata == null)
Compile ();
return compiledAutomata;
}
public DTDAutomata Compile ()
{
compiledAutomata = CompileInternal ();
return compiledAutomata;
}
private DTDAutomata CompileInternal ()
{
if (ElementDecl.IsAny)
return root.Any;
if (ElementDecl.IsEmpty)
return root.Empty;
DTDAutomata basis = GetBasicContentAutomata ();
switch (Occurence) {
case DTDOccurence.One:
return basis;
case DTDOccurence.Optional:
return Choice (root.Empty, basis);
case DTDOccurence.OneOrMore:
return new DTDOneOrMoreAutomata (root, basis);
case DTDOccurence.ZeroOrMore:
return Choice (root.Empty, new DTDOneOrMoreAutomata (root, basis));
}
throw new InvalidOperationException ();
}
private DTDAutomata GetBasicContentAutomata ()
{
if (ElementName != null)
return new DTDElementAutomata (root, ElementName);
switch (ChildModels.Count) {
case 0:
return root.Empty;
case 1:
return ChildModels [0].GetAutomata ();
}
DTDAutomata current = null;
int childCount = ChildModels.Count;
switch (OrderType) {
case DTDContentOrderType.Seq:
current = Sequence (
ChildModels [childCount - 2].GetAutomata (),
ChildModels [childCount - 1].GetAutomata ());
for (int i = childCount - 2; i > 0; i--)
current = Sequence (
ChildModels [i - 1].GetAutomata (), current);
return current;
case DTDContentOrderType.Or:
current = Choice (
ChildModels [childCount - 2].GetAutomata (),
ChildModels [childCount - 1].GetAutomata ());
for (int i = childCount - 2; i > 0; i--)
current = Choice (
ChildModels [i - 1].GetAutomata (), current);
return current;
default:
throw new InvalidOperationException ("Invalid pattern specification");
}
}
private DTDAutomata Sequence (DTDAutomata l, DTDAutomata r)
{
return root.Factory.Sequence (l, r);
}
private DTDAutomata Choice (DTDAutomata l, DTDAutomata r)
{
return l.MakeChoice (r);
}
}
internal class DTDContentModelCollection
{
ArrayList contentModel = new ArrayList ();
public DTDContentModelCollection ()
{
}
public DTDContentModel this [int i] {
get { return contentModel [i] as DTDContentModel; }
}
public int Count {
get { return contentModel.Count; }
}
public void Add (DTDContentModel model)
{
contentModel.Add (model);
}
}
internal abstract class DTDNode : IXmlLineInfo
{
DTDObjectModel root;
bool isInternalSubset;
string baseURI;
int lineNumber;
int linePosition;
public virtual string BaseURI {
get { return baseURI; }
set { baseURI = value; }
}
public bool IsInternalSubset {
get { return isInternalSubset; }
set { isInternalSubset = value; }
}
public int LineNumber {
get { return lineNumber; }
set { lineNumber = value; }
}
public int LinePosition {
get { return linePosition; }
set { linePosition = value; }
}
public bool HasLineInfo ()
{
return lineNumber != 0;
}
internal void SetRoot (DTDObjectModel root)
{
this.root = root;
if (baseURI == null)
this.BaseURI = root.BaseURI;
}
protected DTDObjectModel Root {
get { return root; }
}
internal XmlException NotWFError (string message)
{
return new XmlException (this as IXmlLineInfo, BaseURI, message);
}
}
internal class DTDElementDeclaration : DTDNode
{
DTDObjectModel root;
DTDContentModel contentModel;
string name;
bool isEmpty;
bool isAny;
bool isMixedContent;
internal DTDElementDeclaration (DTDObjectModel root)
{
this.root = root;
}
public string Name {
get { return name; }
set { name = value; }
}
public bool IsEmpty {
get { return isEmpty; }
set { isEmpty = value; }
}
public bool IsAny {
get { return isAny; }
set { isAny = value; }
}
public bool IsMixedContent {
get { return isMixedContent; }
set { isMixedContent = value; }
}
public DTDContentModel ContentModel {
get {
if (contentModel == null)
contentModel = new DTDContentModel (root, Name);
return contentModel;
}
}
public DTDAttListDeclaration Attributes {
get {
return Root.AttListDecls [Name];
}
}
}
internal class DTDAttributeDefinition : DTDNode
{
string name;
XmlSchemaDatatype datatype;
ArrayList enumeratedLiterals;
string unresolvedDefault;
ArrayList enumeratedNotations;
DTDAttributeOccurenceType occurenceType = DTDAttributeOccurenceType.None;
string resolvedDefaultValue;
string resolvedNormalizedDefaultValue;
internal DTDAttributeDefinition (DTDObjectModel root)
{
this.SetRoot (root);
}
public string Name {
get { return name; }
set { name =value; }
}
public XmlSchemaDatatype Datatype {
get { return datatype; }
set { datatype = value; }
}
public DTDAttributeOccurenceType OccurenceType {
get { return this.occurenceType; }
set { this.occurenceType = value; }
}
// entity reference inside enumerated values are not allowed,
// but on the other hand, they are allowed inside default value.
// Then I decided to use string ArrayList for enumerated values,
// and unresolved string value for DefaultValue.
public ArrayList EnumeratedAttributeDeclaration {
get {
if (enumeratedLiterals == null)
enumeratedLiterals = new ArrayList ();
return this.enumeratedLiterals;
}
}
public ArrayList EnumeratedNotations {
get {
if (enumeratedNotations == null)
enumeratedNotations = new ArrayList ();
return this.enumeratedNotations;
}
}
public string DefaultValue {
get {
if (resolvedDefaultValue == null)
resolvedDefaultValue = ComputeDefaultValue ();
return resolvedDefaultValue;
}
}
public string NormalizedDefaultValue {
get {
if (resolvedNormalizedDefaultValue == null) {
string s = ComputeDefaultValue ();
try {
object o = Datatype.ParseValue (s, null, null);
resolvedNormalizedDefaultValue =
(o is string []) ?
String.Join (" ", (string []) o) :
o is IFormattable ? ((IFormattable) o).ToString (null, CultureInfo.InvariantCulture) : o.ToString ();
} catch (Exception) {
// This is for non-error-reporting reader
resolvedNormalizedDefaultValue = Datatype.Normalize (s);
}
}
return resolvedNormalizedDefaultValue;
}
}
public string UnresolvedDefaultValue {
get { return this.unresolvedDefault; }
set { this.unresolvedDefault = value; }
}
public char QuoteChar {
get {
return UnresolvedDefaultValue.Length > 0 ?
this.UnresolvedDefaultValue [0] :
'"';
}
}
internal string ComputeDefaultValue ()
{
if (UnresolvedDefaultValue == null)
return null;
StringBuilder sb = new StringBuilder ();
int pos = 0;
int next = 0;
string value = this.UnresolvedDefaultValue;
while ((next = value.IndexOf ('&', pos)) >= 0) {
int semicolon = value.IndexOf (';', next);
if (value [next + 1] == '#') {
// character reference.
char c = value [next + 2];
NumberStyles style = NumberStyles.Integer;
string spec;
if (c == 'x' || c == 'X') {
spec = value.Substring (next + 3, semicolon - next - 3);
style |= NumberStyles.HexNumber;
}
else
spec = value.Substring (next + 2, semicolon - next - 2);
sb.Append ((char) int.Parse (spec, style, CultureInfo.InvariantCulture));
} else {
sb.Append (value.Substring (pos, next - 1));
string name = value.Substring (next + 1, semicolon - 2);
int predefined = XmlChar.GetPredefinedEntity (name);
if (predefined >= 0)
sb.Append (predefined);
else
sb.Append (Root.ResolveEntity (name));
}
pos = semicolon + 1;
}
sb.Append (value.Substring (pos));
// strip quote chars
string ret = sb.ToString (1, sb.Length - 2);
sb.Length = 0;
return ret;
}
}
internal class DTDAttListDeclaration : DTDNode
{
string name;
Hashtable attributeOrders = new Hashtable ();
ArrayList attributes = new ArrayList ();
internal DTDAttListDeclaration (DTDObjectModel root)
{
SetRoot (root);
}
public string Name {
get { return name; }
set { name = value; }
}
public DTDAttributeDefinition this [int i] {
get { return Get (i); }
}
public DTDAttributeDefinition this [string name] {
get { return Get (name); }
}
public DTDAttributeDefinition Get (int i)
{
return attributes [i] as DTDAttributeDefinition;
}
public DTDAttributeDefinition Get (string name)
{
object o = attributeOrders [name];
if (o != null)
return attributes [(int) o] as DTDAttributeDefinition;
else
return null;
}
public IList Definitions {
get { return attributes; }
}
public void Add (DTDAttributeDefinition def)
{
if (attributeOrders [def.Name] != null)
throw new InvalidOperationException (String.Format (
"Attribute definition for {0} was already added at element {1}.",
def.Name, this.Name));
def.SetRoot (Root);
attributeOrders.Add (def.Name, attributes.Count);
attributes.Add (def);
}
public int Count {
get { return attributeOrders.Count; }
}
}
internal class DTDEntityBase : DTDNode
{
string name;
string publicId;
string systemId;
string literalValue;
string replacementText;
bool isInvalid;
Exception loadException;
bool loadFailed;
protected DTDEntityBase (DTDObjectModel root)
{
SetRoot (root);
}
internal bool IsInvalid {
get { return isInvalid; }
set { isInvalid = value; }
}
public bool LoadFailed {
get { return loadFailed; }
set { loadFailed = value; }
}
public string Name {
get { return name; }
set { name = value; }
}
public string PublicId {
get { return publicId; }
set { publicId = value; }
}
public string SystemId {
get { return systemId; }
set { systemId = value; }
}
public string LiteralEntityValue {
get { return literalValue; }
set { literalValue = value; }
}
public string ReplacementText {
get { return replacementText; }
set { replacementText = value; }
}
public void Resolve (XmlResolver resolver)
{
if (resolver == null || SystemId == null || SystemId.Length == 0) {
LoadFailed = true;
LiteralEntityValue = String.Empty;
return;
}
Uri baseUri = null;
try {
if (BaseURI != null && BaseURI.Length > 0)
baseUri = new Uri (BaseURI);
} catch (UriFormatException) {
}
Uri absUri = resolver.ResolveUri (baseUri, SystemId);
string absPath = absUri.ToString ();
if (Root.ExternalResources.ContainsKey (absPath))
LiteralEntityValue = (string) Root.ExternalResources [absPath];
Stream s = null;
try {
s = resolver.GetEntity (absUri, null, typeof (Stream)) as Stream;
XmlTextReaderImpl xtr = new XmlTextReaderImpl (absPath, s, Root.NameTable);
// Don't skip Text declaration here. LiteralEntityValue contains it. See spec 4.5
this.BaseURI = absPath;
LiteralEntityValue = xtr.GetRemainder ().ReadToEnd ();
Root.ExternalResources.Add (absPath, LiteralEntityValue);
if (Root.ExternalResources.Count > DTDObjectModel.AllowedExternalEntitiesMax)
throw new InvalidOperationException ("The total amount of external entities exceeded the allowed number.");
} catch (Exception ex) {
loadException = ex;
LiteralEntityValue = String.Empty;
LoadFailed = true;
// throw NotWFError ("Cannot resolve external entity. URI is " + absPath + " .");
} finally {
if (s != null)
s.Close ();
}
}
}
internal class DTDEntityDeclaration : DTDEntityBase
{
string entityValue;
string notationName;
ArrayList ReferencingEntities = new ArrayList ();
bool scanned;
bool recursed;
bool hasExternalReference;
internal DTDEntityDeclaration (DTDObjectModel root) : base (root)
{
}
public string NotationName {
get { return notationName; }
set { notationName = value; }
}
public bool HasExternalReference {
get {
if (!scanned)
ScanEntityValue (new ArrayList ());
return hasExternalReference;
}
}
public string EntityValue {
get {
if (this.IsInvalid)
return String.Empty;
if (PublicId == null && SystemId == null && LiteralEntityValue == null)
return String.Empty;
if (entityValue == null) {
if (NotationName != null)
entityValue = "";
else if (SystemId == null || SystemId == String.Empty) {
entityValue = ReplacementText;
if (entityValue == null)
entityValue = String.Empty;
} else {
entityValue = ReplacementText;
}
// Check illegal recursion.
ScanEntityValue (new ArrayList ());
}
return entityValue;
}
}
// It returns whether the entity contains references to external entities.
public void ScanEntityValue (ArrayList refs)
{
// To modify this code, beware nesting between this and EntityValue.
string value = EntityValue;
if (this.SystemId != null)
hasExternalReference = true;
if (recursed)
throw NotWFError ("Entity recursion was found.");
recursed = true;
if (scanned) {
foreach (string referenced in refs)
if (this.ReferencingEntities.Contains (referenced))
throw NotWFError (String.Format (
"Nested entity was found between {0} and {1}",
referenced, Name));
recursed = false;
return;
}
int len = value.Length;
int start = 0;
for (int i=0; i<len; i++) {
switch (value [i]) {
case '&':
start = i+1;
break;
case ';':
if (start == 0)
break;
string name = value.Substring (start, i - start);
if (name.Length == 0)
throw NotWFError ("Entity reference name is missing.");
if (name [0] == '#')
break; // character reference
if (XmlChar.GetPredefinedEntity (name) >= 0)
break; // predefined reference
this.ReferencingEntities.Add (name);
DTDEntityDeclaration decl = Root.EntityDecls [name];
if (decl != null) {
if (decl.SystemId != null)
hasExternalReference = true;
refs.Add (Name);
decl.ScanEntityValue (refs);
foreach (string str in decl.ReferencingEntities)
ReferencingEntities.Add (str);
refs.Remove (Name);
value = value.Remove (start - 1, name.Length + 2);
value = value.Insert (start - 1, decl.EntityValue);
i -= name.Length + 1; // not +2, because of immediate i++ .
len = value.Length;
}
start = 0;
break;
}
}
if (start != 0)
Root.AddError (new XmlSchemaException ("Invalid reference character '&' is specified.",
this.LineNumber, this.LinePosition, null, this.BaseURI, null));
scanned = true;
recursed = false;
}
}
internal class DTDNotationDeclaration : DTDNode
{
string name;
string localName;
string prefix;
string publicId;
string systemId;
public string Name {
get { return name; }
set { name = value; }
}
public string PublicId {
get { return publicId; }
set { publicId = value; }
}
public string SystemId {
get { return systemId; }
set { systemId = value; }
}
public string LocalName {
get { return localName; }
set { localName = value; }
}
public string Prefix {
get { return prefix; }
set { prefix = value; }
}
internal DTDNotationDeclaration (DTDObjectModel root)
{
SetRoot (root);
}
}
internal class DTDParameterEntityDeclarationCollection
{
Hashtable peDecls = new Hashtable ();
DTDObjectModel root;
public DTDParameterEntityDeclarationCollection (DTDObjectModel root)
{
this.root = root;
}
public DTDParameterEntityDeclaration this [string name] {
get { return peDecls [name] as DTDParameterEntityDeclaration; }
}
public void Add (string name, DTDParameterEntityDeclaration decl)
{
// PEDecl can be overriden.
if (peDecls [name] != null)
return;
decl.SetRoot (root);
peDecls.Add (name, decl);
}
public ICollection Keys {
get { return peDecls.Keys; }
}
public ICollection Values {
get { return peDecls.Values; }
}
}
internal class DTDParameterEntityDeclaration : DTDEntityBase
{
internal DTDParameterEntityDeclaration (DTDObjectModel root) : base (root)
{
}
}
internal enum DTDContentOrderType
{
None,
Seq,
Or
}
internal enum DTDAttributeOccurenceType
{
None,
Required,
Optional,
Fixed
}
internal enum DTDOccurence
{
One,
Optional,
ZeroOrMore,
OneOrMore
}
}