X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.XML%2FSystem.Xml%2FXmlDocument.cs;h=c976b9726160e31ab4d7d4b3d341fef30d932683;hb=37b37cedbc968b0276f852c9f1d3086b23706691;hp=43263b72731299e43131aba1614363475c2514fe;hpb=5584fe9d905d4536021f0a09f768c62218d8ecfd;p=mono.git

diff --git a/mcs/class/System.XML/System.Xml/XmlDocument.cs b/mcs/class/System.XML/System.Xml/XmlDocument.cs
index 43263b72731..c976b972616 100644
--- a/mcs/class/System.XML/System.Xml/XmlDocument.cs
+++ b/mcs/class/System.XML/System.Xml/XmlDocument.cs
@@ -35,6 +35,7 @@ namespace System.Xml
 		XmlImplementation implementation;
 		bool preserveWhitespace = false;
 		XmlResolver resolver;
+		Hashtable idTable = new Hashtable ();
 
 		#endregion
 
@@ -57,6 +58,7 @@ namespace System.Xml
 			implementation = (impl != null) ? impl : new XmlImplementation ();
 			nameTable = (nt != null) ? nt : implementation.internalNameTable;
 			AddDefaultNameTableKeys ();
+			resolver = new XmlUrlResolver ();
 		}
 		#endregion
 
@@ -98,7 +100,6 @@ namespace System.Xml
 			}
 		}
 
-		[MonoTODO("It doesn't have internal subset object model.")]
 		public virtual XmlDocumentType DocumentType {
 			get {
 				foreach(XmlNode n in this.ChildNodes) {
@@ -126,6 +127,14 @@ namespace System.Xml
 			get { return false; }
 		}
 
+		internal bool IsStandalone {
+			get {
+				return FirstChild != null &&
+					FirstChild.NodeType == XmlNodeType.XmlDeclaration &&
+					((XmlDeclaration) this.FirstChild).Standalone == "yes";
+			}
+		}
+
 		internal override XmlLinkedNode LastLinkedChild {
 			get	{
 				return lastLinkedChild;
@@ -167,6 +176,10 @@ namespace System.Xml
 			set { preserveWhitespace = value; }
 		}
 
+		internal XmlResolver Resolver {
+			get { return resolver; }
+		}
+
 		internal override string XmlLang {
 			get { return String.Empty; }
 		}
@@ -180,17 +193,31 @@ namespace System.Xml
 				return XmlSpace.None;
 			}
 		}
+		
+		internal Encoding TextEncoding {
+			get {
+				XmlDeclaration dec = FirstChild as XmlDeclaration;
+			
+				if (dec == null || dec.Encoding == "")
+					return null;
+				
+				return Encoding.GetEncoding (dec.Encoding);
+			}
+		}
 
 		#endregion
 
 		#region Methods
+		internal void AddIdenticalAttribute (XmlAttribute attr)
+		{
+			idTable [attr.Value] = attr;
+		}
 
 		public override XmlNode CloneNode (bool deep)
 		{
 			XmlDocument doc = implementation.CreateDocument ();
 			doc.baseURI = baseURI;
 
-			doc.PreserveWhitespace = PreserveWhitespace;	// required?
 			if(deep)
 			{
 				foreach(XmlNode n in ChildNodes)
@@ -201,8 +228,18 @@ namespace System.Xml
 
 		public XmlAttribute CreateAttribute (string name)
 		{
-			return CreateAttribute (name,
-				name == "xmlns" ? "http://www.w3.org/2000/xmlns/" : String.Empty);
+			string prefix;
+			string localName;
+			string namespaceURI = String.Empty;
+
+			ParseName (name, out prefix, out localName);
+
+			if (prefix == "xmlns" || (prefix == "" && localName == "xmlns"))
+				namespaceURI = XmlNamespaceManager.XmlnsXmlns;
+			else if (prefix == "xml")
+				namespaceURI = XmlNamespaceManager.XmlnsXml;
+
+			return CreateAttribute (prefix, localName, namespaceURI );
 		}
 
 		public XmlAttribute CreateAttribute (string qualifiedName, string namespaceURI)
@@ -251,6 +288,11 @@ namespace System.Xml
 			return new XmlDocumentType (name, publicId, systemId, internalSubset, this);
 		}
 
+		private XmlDocumentType CreateDocumentType (DTDObjectModel dtd)
+		{
+			return new XmlDocumentType (dtd, this);
+		}
+
 		public XmlElement CreateElement (string name)
 		{
 			return CreateElement (name, String.Empty);
@@ -275,7 +317,11 @@ namespace System.Xml
 		{
 			if ((localName == null) || (localName == String.Empty))
 				throw new ArgumentException ("The local name for elements or attributes cannot be null or an empty string.");
-			CheckName (localName);
+			// FIXME: MS.NET has a weird behavior that they can Load() from XmlTextReader 
+			// whose Namespaces = false, but their CreateElement() never allows qualified name.
+			// I leave it as it is.
+			if (!XmlChar.IsName (localName))
+				throw new ArgumentException ("Invalid name.", "localName");
 			return new XmlElement (prefix != null ? prefix : String.Empty, localName, namespaceURI != null ? namespaceURI : String.Empty, this);
 		}
 
@@ -284,7 +330,7 @@ namespace System.Xml
 			return new XmlEntityReference (name, this);
 		}
 
-		internal virtual XPathNavigator CreateNavigator (XmlNode node)
+		protected internal virtual XPathNavigator CreateNavigator (XmlNode node)
 		{
 			return new XmlDocumentNavigator (node);
 		}
@@ -321,7 +367,7 @@ namespace System.Xml
 				case XmlNodeType.Attribute: return CreateAttribute (prefix, name, namespaceURI);
 				case XmlNodeType.CDATA: return CreateCDataSection (null);
 				case XmlNodeType.Comment: return CreateComment (null);
-				case XmlNodeType.Document: return new XmlDocument (); // TODO - test to see which constructor to use, i.e. use existing NameTable or not.
+				case XmlNodeType.Document: return new XmlDocument ();
 				case XmlNodeType.DocumentFragment: return CreateDocumentFragment ();
 				case XmlNodeType.DocumentType: return CreateDocumentType (null, null, null, null);
 				case XmlNodeType.Element: return CreateElement (prefix, name, namespaceURI);
@@ -379,9 +425,14 @@ namespace System.Xml
 		}
 
 		[MonoTODO]
+		// FIXME: Currently XmlAttributeCollection.SetNamedItem() does
+		// add to the identity table, but in fact I delayed identity
+		// check on GetIdenticalAttribute. To make such way complete,
+		// we have to use MultiMap, not Hashtable.
 		public virtual XmlElement GetElementById (string elementId)
 		{
-			throw new NotImplementedException ();
+			XmlAttribute attr = GetIdenticalAttribute (elementId);
+			return attr != null ? attr.OwnerElement : null;
 		}
 
 		public virtual XmlNodeList GetElementsByTagName (string name)
@@ -442,117 +493,109 @@ namespace System.Xml
 			}
 		}
 
-		[MonoTODO("default attributes (of imported doc); Entity; Notation")]
-		public virtual XmlNode ImportNode (XmlNode node, bool deep)
+		internal XmlAttribute GetIdenticalAttribute (string id)
 		{
-			switch(node.NodeType)
-			{
-				case XmlNodeType.Attribute:
-					{
-						XmlAttribute src_att = node as XmlAttribute;
-						XmlAttribute dst_att = this.CreateAttribute (src_att.Prefix, src_att.LocalName, src_att.NamespaceURI);
-						dst_att.Value = src_att.Value;	// always explicitly specified (whether source is specified or not)
-						return dst_att;
-					}
-
-				case XmlNodeType.CDATA:
-					return this.CreateCDataSection (node.Value);
-
-				case XmlNodeType.Comment:
-					return this.CreateComment (node.Value);
-
-				case XmlNodeType.Document:
-					throw new XmlException ("Document cannot be imported.");
-
-				case XmlNodeType.DocumentFragment:
-					{
-						XmlDocumentFragment df = this.CreateDocumentFragment ();
-						if(deep)
-						{
-							foreach(XmlNode n in node.ChildNodes)
-							{
-								df.AppendChild (this.ImportNode (n, deep));
-							}
-						}
-						return df;
-					}
-
-				case XmlNodeType.DocumentType:
-					throw new XmlException ("DocumentType cannot be imported.");
-
-				case XmlNodeType.Element:
-					{
-						XmlElement src = (XmlElement)node;
-						XmlElement dst = this.CreateElement (src.Prefix, src.LocalName, src.NamespaceURI);
-						foreach(XmlAttribute attr in src.Attributes)
-						{
-							if(attr.Specified)	// copies only specified attributes
-								dst.SetAttributeNode ((XmlAttribute)this.ImportNode (attr, deep));
-							if(DocumentType != null)
-							{
-								// TODO: create default attribute values
-							}
-						}
-						if(deep)
-						{
-							foreach(XmlNode n in src.ChildNodes)
-								dst.AppendChild (this.ImportNode (n, deep));
-						}
-						return dst;
-					}
-
-				case XmlNodeType.EndElement:
-					throw new XmlException ("Illegal ImportNode call for NodeType.EndElement");
-				case XmlNodeType.EndEntity:
-					throw new XmlException ("Illegal ImportNode call for NodeType.EndEntity");
-
-				case XmlNodeType.Entity:
-					throw new NotImplementedException ();	// TODO
-
-				case XmlNodeType.EntityReference:
-					return this.CreateEntityReference (node.Name);
-
-				case XmlNodeType.None:
-					throw new XmlException ("Illegal ImportNode call for NodeType.None");
-
-				case XmlNodeType.Notation:
-					throw new NotImplementedException ();	// TODO
-
-				case XmlNodeType.ProcessingInstruction:
-					XmlProcessingInstruction pi = node as XmlProcessingInstruction;
-					return this.CreateProcessingInstruction (pi.Target, pi.Data);
-
-				case XmlNodeType.SignificantWhitespace:
-					return this.CreateSignificantWhitespace (node.Value);
-
-				case XmlNodeType.Text:
-					return this.CreateTextNode (node.Value);
-
-				case XmlNodeType.Whitespace:
-					return this.CreateWhitespace (node.Value);
-
-				case XmlNodeType.XmlDeclaration:
-					XmlDeclaration srcDecl = node as XmlDeclaration;
-					return this.CreateXmlDeclaration (srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone);
+			XmlAttribute attr = this.idTable [id] as XmlAttribute;
+			if (attr == null)
+				return null;
+			if (attr.OwnerElement == null || !attr.OwnerElement.IsRooted) {
+//				idTable.Remove (id);
+				return null;
+			}
+			return attr;
+		}
 
-				default:
-					throw new NotImplementedException ();
+		public virtual XmlNode ImportNode (XmlNode node, bool deep)
+		{
+			switch (node.NodeType) {
+			case XmlNodeType.Attribute:
+				XmlAttribute srcAtt = node as XmlAttribute;
+				XmlAttribute dstAtt = this.CreateAttribute (srcAtt.Prefix, srcAtt.LocalName, srcAtt.NamespaceURI);
+				foreach (XmlNode child in srcAtt.ChildNodes)
+					dstAtt.AppendChild (this.ImportNode (child, deep));
+				return dstAtt;
+
+			case XmlNodeType.CDATA:
+				return this.CreateCDataSection (node.Value);
+
+			case XmlNodeType.Comment:
+				return this.CreateComment (node.Value);
+
+			case XmlNodeType.Document:
+				throw new XmlException ("Document cannot be imported.");
+
+			case XmlNodeType.DocumentFragment:
+				XmlDocumentFragment df = this.CreateDocumentFragment ();
+				if(deep)
+					foreach(XmlNode n in node.ChildNodes)
+						df.AppendChild (this.ImportNode (n, deep));
+				return df;
+
+			case XmlNodeType.DocumentType:
+				throw new XmlException ("DocumentType cannot be imported.");
+
+			case XmlNodeType.Element:
+				XmlElement src = (XmlElement)node;
+				XmlElement dst = this.CreateElement (src.Prefix, src.LocalName, src.NamespaceURI);
+				foreach(XmlAttribute attr in src.Attributes)
+					if(attr.Specified)	// copies only specified attributes
+						dst.SetAttributeNode ((XmlAttribute)this.ImportNode (attr, deep));
+				if(deep)
+					foreach(XmlNode n in src.ChildNodes)
+						dst.AppendChild (this.ImportNode (n, deep));
+				return dst;
+
+			case XmlNodeType.EndElement:
+				throw new XmlException ("Illegal ImportNode call for NodeType.EndElement");
+			case XmlNodeType.EndEntity:
+				throw new XmlException ("Illegal ImportNode call for NodeType.EndEntity");
+
+			case XmlNodeType.EntityReference:
+				return this.CreateEntityReference (node.Name);
+
+			case XmlNodeType.None:
+				throw new XmlException ("Illegal ImportNode call for NodeType.None");
+
+			case XmlNodeType.ProcessingInstruction:
+				XmlProcessingInstruction pi = node as XmlProcessingInstruction;
+				return this.CreateProcessingInstruction (pi.Target, pi.Data);
+
+			case XmlNodeType.SignificantWhitespace:
+				return this.CreateSignificantWhitespace (node.Value);
+
+			case XmlNodeType.Text:
+				return this.CreateTextNode (node.Value);
+
+			case XmlNodeType.Whitespace:
+				return this.CreateWhitespace (node.Value);
+
+			case XmlNodeType.XmlDeclaration:
+				XmlDeclaration srcDecl = node as XmlDeclaration;
+				return this.CreateXmlDeclaration (srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone);
+
+			default:
+				throw new InvalidOperationException ("Cannot import specified node type: " + node.NodeType);
 			}
 		}
 
 		public virtual void Load (Stream inStream)
 		{
-			Load (new XmlTextReader (new XmlStreamReader (inStream)));
+			Load (new XmlTextReader (inStream));
 		}
 
 		public virtual void Load (string filename)
 		{
-			Load (new XmlTextReader (filename));
+			XmlTextReader xr = new XmlTextReader (filename);
+			xr.XmlResolver = resolver;
+			Load (xr);
+			xr.Close ();
 		}
 
 		public virtual void Load (TextReader txtReader)
 		{
-			Load (new XmlTextReader (txtReader));
+			XmlTextReader xr = new XmlTextReader (txtReader);
+			xr.XmlResolver = resolver;
+			Load (xr);
 		}
 
 		public virtual void Load (XmlReader xmlReader)
@@ -570,12 +613,13 @@ namespace System.Xml
 				if(n == null) break;
 				AppendChild (n);
 			} while (true);
-			xmlReader.Close ();
 		}
 
 		public virtual void LoadXml (string xml)
 		{
-			XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
+			XmlTextReader xmlReader = new XmlTextReader (
+				xml, XmlNodeType.Document, null);
+			xmlReader.XmlResolver = resolver;
 			Load (xmlReader);
 		}
 
@@ -640,14 +684,6 @@ namespace System.Xml
 			}
 		}
 
-		// Checks that Element's name is valid
-		private void CheckName (String name)
-		{
-			// TODO: others validations?
-			if (name.IndexOf (" ") >= 0)
-				throw new XmlException ("The ' ' characted cannot be included in a name");
-		}
-
 		// Reads XmlReader and creates Attribute Node.
 		private XmlAttribute ReadAttributeNode(XmlReader reader)
 		{
@@ -664,6 +700,8 @@ namespace System.Xml
 				res = reader.MoveToAttribute (attribute.Name);
 			else 
 				res = reader.MoveToAttribute (attribute.LocalName, attribute.NamespaceURI);
+			if (reader.IsDefault)
+				attribute.SetDefault ();
 			return attribute;
 		}
 
@@ -681,15 +719,21 @@ namespace System.Xml
 			}
 		}
 
-		[MonoTODO ("Child of entity is not simple Value string;Get prefix of NotationDecl")]
-		public virtual XmlNode ReadNode(XmlReader reader)
+		public virtual XmlNode ReadNode (XmlReader reader)
 		{
 			XmlNode resultNode = null;
 			XmlNode newNode = null;
 			XmlNode currentNode = null;
 
-			if (reader.ReadState == ReadState.Initial)
+			switch (reader.ReadState) {
+			case ReadState.Interactive:
+				break;
+			case ReadState.Initial:
 				reader.Read ();
+				break;
+			default:
+				return null;
+			}
 
 			int startDepth = reader.Depth;
 			bool ignoredWhitespace;
@@ -697,7 +741,7 @@ namespace System.Xml
 
 			do {
 				ignoredWhitespace = false;
-				if (reader.NodeType == XmlNodeType.None)
+				if (reader.ReadState != ReadState.Interactive)
 					if (reachedEOF)
 						throw new Exception ("XML Reader reached to end while reading node.");
 					else
@@ -744,7 +788,7 @@ namespace System.Xml
 					if (currentNode == null)
 						throw new XmlException ("Unexpected end element.");
 					else if (currentNode.Name != reader.Name)
-						throw new XmlException (MakeReaderErrorMessage (String.Format ("mismatch end tag. Expected {0} but found {1}", currentNode.Name, reader.Name), reader));
+						throw new XmlException (reader as IXmlLineInfo, String.Format ("mismatch end tag. Expected {0} but found {1}", currentNode.Name, reader.Name));
 					currentNode = currentNode.ParentNode;
 					break;
 
@@ -768,26 +812,32 @@ namespace System.Xml
 					newNode = CreateXmlDeclaration ("1.0" , String.Empty, String.Empty);
 					((XmlDeclaration)newNode).Value = reader.Value;
 					if(currentNode != null)
-						throw new XmlException (MakeReaderErrorMessage ("XmlDeclaration at invalid position.", reader));
+						throw new XmlException (reader as IXmlLineInfo, "XmlDeclaration at invalid position.");
 					break;
 
 				case XmlNodeType.DocumentType:
-					// hack ;-)
+					if(currentNode != null)
+						throw new XmlException (reader as IXmlLineInfo, "XmlDocumentType at invalid position.");
+
+					DTDObjectModel dtd = null;
 					XmlTextReader xtReader = reader as XmlTextReader;
-					if(xtReader == null) {
-						// XmlTextReader doesn't allow such creation that starts reading from Doctype.
-					/*
-						xtReader = new XmlTextReader (reader.ReadOuterXml (),
-							XmlNodeType.DocumentType,
-							new XmlParserContext (NameTable, ConstructNamespaceManager(), XmlLang, XmlSpace));
-						xtReader.Read ();
-					*/
+					if (xtReader != null)
+						dtd = xtReader.DTD;
+					XmlNodeReader xnReader = reader as XmlNodeReader;
+					if (xnReader != null)
+						dtd = xnReader.GetInternalParserContext ().Dtd;
+					XmlValidatingReader xvReader = reader as XmlValidatingReader;
+					if (xvReader != null)
+						dtd = xvReader.GetInternalParserContext ().Dtd;
+					IHasXmlParserContext ctxReader = reader as IHasXmlParserContext;
+					if (ctxReader != null)
+						dtd = ctxReader.ParserContext.Dtd;
+
+					if (dtd != null)
+						newNode = CreateDocumentType (dtd);
+					else
 						newNode = CreateDocumentType (reader.Name, reader ["PUBLIC"], reader ["SYSTEM"], reader.Value);
-					} else {
-						newNode = ReadDoctypeNode (xtReader);
-					}
-					if(currentNode != null)
-						throw new XmlException (this.MakeReaderErrorMessage ("XmlDocumentType at invalid position.", reader));
+
 					break;
 
 				case XmlNodeType.EntityReference:
@@ -812,6 +862,7 @@ namespace System.Xml
 						ignoredWhitespace = true;
 					break;
 				}
+				// Read next, except for reading attribute node.
 				if (!(newNode is XmlAttribute) && !reader.Read ())
 					break;
 			} while (ignoredWhitespace || reader.Depth > startDepth ||
@@ -825,56 +876,32 @@ namespace System.Xml
 		{
 			IXmlLineInfo li = reader as IXmlLineInfo;
 			if (li != null)
-				return String.Format ("{0} Line number = {1}, Inline position = {2}.", li.LineNumber, li.LinePosition);
+				return String.Format ("{0} Line number = {1}, Inline position = {2}.", message, li.LineNumber, li.LinePosition);
 			else
 				return message;
 		}
 
-		private XmlDocumentType ReadDoctypeNode (XmlTextReader xtReader)
+		internal void RemoveIdenticalAttribute (string id)
 		{
-			XmlDocumentType doctype = CreateDocumentType (xtReader.Name,
-				xtReader.GetAttribute ("PUBLIC"),
-				xtReader.GetAttribute ("SYSTEM"),
-				xtReader.Value);
-			DTDObjectModel subset = xtReader.currentSubset;
-			foreach (DTDEntityDeclaration decl in subset.EntityDecls.Values) {
-				XmlNode n = new XmlEntity (decl.Name, decl.NotationName,
-					decl.PublicId, decl.SystemId, this);
-				// FIXME: Value is more complex, similar to Attribute.
-				n.insertBeforeIntern (this.CreateTextNode (decl.EntityValue), null);
-				doctype.entities.Nodes.Add (n);
-			}
-			foreach (DTDNotationDeclaration decl in subset.NotationDecls.Values) {
-				XmlNode n = new XmlNotation (decl.LocalName, decl.Prefix,
-					decl.PublicId, decl.SystemId, this);
-				doctype.notations.Nodes.Add (n);
-			}
-			foreach (DTDElementDeclaration decl in subset.ElementDecls.Values) {
-				doctype.elementDecls.Add (decl.Name, decl.Clone ());
-			}
-			foreach (DTDAttListDeclaration decl in subset.AttListDecls.Values) {
-				doctype.attListDecls.Add (decl.Name, decl.Clone ());
-			}
-			return doctype;
+			idTable.Remove (id);
 		}
 
 		public virtual void Save(Stream outStream)
 		{
-			XmlTextWriter xmlWriter = new XmlTextWriter (outStream, Encoding.UTF8);
+			XmlTextWriter xmlWriter = new XmlTextWriter (outStream, TextEncoding);
 			xmlWriter.Formatting = Formatting.Indented;
 			WriteContentTo (xmlWriter);
-			xmlWriter.Close ();
+			xmlWriter.Flush ();
 		}
 
 		public virtual void Save (string filename)
 		{
-			XmlTextWriter xmlWriter = new XmlTextWriter (filename, Encoding.UTF8);
+			XmlTextWriter xmlWriter = new XmlTextWriter (filename, TextEncoding);
 			xmlWriter.Formatting = Formatting.Indented;
 			WriteContentTo (xmlWriter);
 			xmlWriter.Close ();
 		}
 
-		[MonoTODO]
 		public virtual void Save (TextWriter writer)
 		{
 			XmlTextWriter xmlWriter = new XmlTextWriter (writer);
@@ -888,7 +915,12 @@ namespace System.Xml
 			//
 			// This should preserve white space if PreserveWhiteSpace is true
 			//
+			bool autoXmlDecl = FirstChild != null && FirstChild.NodeType != XmlNodeType.XmlDeclaration;
+			if (autoXmlDecl)
+				xmlWriter.WriteStartDocument ();
 			WriteContentTo (xmlWriter);
+			if (autoXmlDecl)
+				xmlWriter.WriteEndDocument ();
 			xmlWriter.Flush ();
 		}