Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.XML/System.Xml/ChangeLog.REMOVED.git-id

@@ -0,0 +1 @@
+3d3c41ae9e0f47d686b74fdb14ecf72565a3f025

mcs/class/System.XML/System.Xml/ConformanceLevel.cs

@@ -0,0 +1,37 @@
+//
+// ConformanceLevel.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+
+//
+// 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.
+//
+
+namespace System.Xml
+{
+	public enum ConformanceLevel
+	{
+		Auto,
+		Fragment,
+		Document
+	}
+}

mcs/class/System.XML/System.Xml/DTDAutomata.cs

@@ -0,0 +1,351 @@
+//
+// Mono.Xml.DTDAutomata
+//
+// Author:
+//	Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
+//
+//	(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.Text;
+using System.Xml;
+#if !NET_2_1
+using System.Xml.Schema;
+using Mono.Xml.Schema;
+#endif
+
+namespace Mono.Xml
+{
+	internal class DTDAutomataFactory
+	{
+		public DTDAutomataFactory (DTDObjectModel root)
+		{
+			this.root = root;
+		}
+
+		DTDObjectModel root;
+		Hashtable choiceTable = new Hashtable ();
+		Hashtable sequenceTable = new Hashtable ();
+
+		public DTDChoiceAutomata Choice (DTDAutomata left, DTDAutomata right)
+		{
+			Hashtable rightPool = choiceTable [left] as Hashtable;
+			if (rightPool == null) {
+				rightPool = new Hashtable ();
+				choiceTable [left] = rightPool;
+			}
+			DTDChoiceAutomata result = rightPool [right] as DTDChoiceAutomata;
+			if (result == null) {
+				result = new DTDChoiceAutomata (root, left, right);
+				rightPool [right] = result;
+			}
+			return result;
+		}
+
+		public DTDSequenceAutomata Sequence (DTDAutomata left, DTDAutomata right)
+		{
+			Hashtable rightPool = sequenceTable [left] as Hashtable;
+			if (rightPool == null) {
+				rightPool = new Hashtable ();
+				sequenceTable [left] = rightPool;
+			}
+			DTDSequenceAutomata result = rightPool [right] as DTDSequenceAutomata;
+			if (result == null) {
+				result = new DTDSequenceAutomata (root, left, right);
+				rightPool [right] = result;
+			}
+			return result;
+		}
+	}
+
+	internal abstract class DTDAutomata
+	{
+		public DTDAutomata (DTDObjectModel root)
+		{
+			this.root = root;
+		}
+
+		private DTDObjectModel root;
+
+		public DTDObjectModel Root {
+			get { return root; }
+		}
+
+		public DTDAutomata MakeChoice (DTDAutomata other)
+		{
+			if (this == Root.Invalid)
+				return other;
+			if (other == Root.Invalid)
+				return this;
+			if (this == Root.Empty && other == Root.Empty)
+				return this;
+			if (this == Root.Any && other == Root.Any)
+				return this;
+			else if (other == Root.Empty)
+				return Root.Factory.Choice (other, this);
+			else
+				return Root.Factory.Choice (this, other);
+		}
+
+		public DTDAutomata MakeSequence (DTDAutomata other)
+		{
+			if (this == Root.Invalid || other == Root.Invalid)
+				return Root.Invalid;
+			if (this == Root.Empty)
+				return other;
+			if (other == Root.Empty)
+				return this;
+			else
+				return Root.Factory.Sequence (this, other);
+		}
+
+		public abstract DTDAutomata TryStartElement (string name);
+		public virtual DTDAutomata TryEndElement ()
+		{
+			return Root.Invalid;
+		}
+
+		public virtual bool Emptiable {
+			get { return false; }
+		}
+	}
+
+	internal class DTDElementAutomata : DTDAutomata
+	{
+		public DTDElementAutomata (DTDObjectModel root, string name)
+			: base (root)
+		{
+			this.name = name;
+		}
+
+		private string name;
+
+		public string Name {
+			get { return name; }
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			if (name == Name)
+				return Root.Empty;
+			else
+				return Root.Invalid;
+		}
+	}
+
+	internal class DTDChoiceAutomata : DTDAutomata
+	{
+		public DTDChoiceAutomata (DTDObjectModel root,
+			DTDAutomata left, DTDAutomata right)
+			: base (root)
+		{
+			this.left = left;
+			this.right = right;
+		}
+
+		private DTDAutomata left;
+		private DTDAutomata right;
+
+		public DTDAutomata Left {
+			get { return left; }
+		}
+
+		public DTDAutomata Right {
+			get { return right; }
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			return left.TryStartElement (name).MakeChoice (
+				right.TryStartElement (name));
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return left.TryEndElement ().MakeChoice (right.TryEndElement ());
+		}
+
+		bool hasComputedEmptiable;
+		bool cachedEmptiable;
+		public override bool Emptiable {
+			get {
+				if (!hasComputedEmptiable) {
+					cachedEmptiable = left.Emptiable || 
+						right.Emptiable;
+					hasComputedEmptiable = true;
+				}
+				return cachedEmptiable;
+			}
+		}
+	}
+
+	internal class DTDSequenceAutomata : DTDAutomata
+	{
+		public DTDSequenceAutomata (DTDObjectModel root,
+			DTDAutomata left, DTDAutomata right)
+			: base (root)
+		{
+			this.left = left;
+			this.right = right;
+		}
+
+		private DTDAutomata left;
+		private DTDAutomata right;
+
+		public DTDAutomata Left {
+			get { return left; }
+		}
+
+		public DTDAutomata Right {
+			get { return right; }
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			DTDAutomata afterL = left.TryStartElement (name);
+			DTDAutomata afterR = right.TryStartElement (name);
+			if (afterL == Root.Invalid)
+				return (left.Emptiable) ? afterR : afterL;
+			// else
+			DTDAutomata whenLeftConsumed = afterL.MakeSequence (right);
+			if (left.Emptiable)
+				return afterR.MakeChoice (whenLeftConsumed);
+			else
+				return whenLeftConsumed;
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return left.Emptiable ? right : Root.Invalid;
+		}
+
+		bool hasComputedEmptiable;
+		bool cachedEmptiable;
+		public override bool Emptiable {
+			get {
+				if (!hasComputedEmptiable) {
+					cachedEmptiable = left.Emptiable &&
+						right.Emptiable;
+					hasComputedEmptiable = true;
+				}
+				return cachedEmptiable;
+			}
+		}
+	}
+
+	internal class DTDOneOrMoreAutomata : DTDAutomata
+	{
+		public DTDOneOrMoreAutomata (DTDObjectModel root,
+			DTDAutomata children)
+			: base (root)
+		{
+			this.children = children;
+		}
+
+		private DTDAutomata children;
+
+		public DTDAutomata Children {
+			get { return children; }
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			DTDAutomata afterC = children.TryStartElement (name);
+			if (afterC != Root.Invalid)
+				return afterC.MakeSequence (
+					Root.Empty.MakeChoice (this));
+			else
+				return Root.Invalid;
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return Emptiable ? children.TryEndElement () : Root.Invalid;
+		}
+	}
+
+	internal class DTDEmptyAutomata : DTDAutomata
+	{
+		public DTDEmptyAutomata (DTDObjectModel root)
+			: base (root)
+		{
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return this;
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			return Root.Invalid;
+		}
+
+		public override bool Emptiable {
+			get { return true; }
+		}
+	}
+
+	internal class DTDAnyAutomata : DTDAutomata
+	{
+		public DTDAnyAutomata (DTDObjectModel root)
+			: base (root)
+		{
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return this;
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			return this;
+		}
+
+		public override bool Emptiable {
+			get { return true; }
+		}
+	}
+
+	internal class DTDInvalidAutomata : DTDAutomata
+	{
+		public DTDInvalidAutomata (DTDObjectModel root)
+			: base (root)
+		{
+		}
+
+		public override DTDAutomata TryEndElement ()
+		{
+			return this;
+		}
+
+		public override DTDAutomata TryStartElement (string name)
+		{
+			return this;
+		}
+	}
+}

mcs/class/System.XML/System.Xml/DefaultXmlWriter.cs

@@ -0,0 +1,260 @@
+//
+// DefaultXmlWriter.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc. http://www.novell.com
+//
+using System;
+using System.Globalization;
+using System.Collections;
+
+namespace System.Xml
+{
+	internal class DefaultXmlWriter : XmlWriter
+	{
+		XmlWriter writer;
+		WriteState state = WriteState.Start;
+		bool delegate_write_state;
+		bool supports_lookup;
+
+		public DefaultXmlWriter (XmlWriter writer)
+			: this (writer, true)
+		{
+		}
+
+		public DefaultXmlWriter (XmlWriter writer, bool delegateWriteState)
+		{
+			this.writer = writer;
+			delegate_write_state = delegateWriteState;
+			supports_lookup = true;
+		}
+	
+		protected XmlWriter Writer {
+			get { return writer; }
+		}
+
+		private void CloseStartElement ()
+		{
+			state = WriteState.Content;
+		}
+
+		public override void Close ()
+		{
+			if (state != WriteState.Closed)
+				writer.Close ();
+			state = WriteState.Closed;
+		}
+	
+		public override void Flush ()
+		{
+			writer.Flush ();
+		}
+	
+		public override string LookupPrefix (string ns)
+		{
+			if (!supports_lookup)
+				return String.Empty;
+			try {
+				return writer.LookupPrefix (ns);
+			} catch (NotSupportedException) {
+				supports_lookup = false;
+				return String.Empty;
+			} catch (Exception) {
+				throw;
+			}
+		}
+	
+		public override void WriteBase64 (byte [] buffer, int index, int count)
+		{
+			writer.WriteBase64 (buffer, index, count);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteBinHex (byte [] buffer, int index, int count)
+		{
+			writer.WriteBinHex (buffer, index, count);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteCData (string text)
+		{
+			writer.WriteCData (text);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteCharEntity (char ch)
+		{
+			writer.WriteCharEntity (ch);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteChars (char [] buffer, int index, int count)
+		{
+			writer.WriteChars (buffer, index, count);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteComment (string text)
+		{
+			writer.WriteComment (text);
+			if (state == WriteState.Start)
+				state = WriteState.Prolog;
+			else
+				state = WriteState.Content;
+		}
+	
+		public override void WriteDocType (string name, string pubid, string sysid, string subset)
+		{
+			writer.WriteDocType (name, pubid, sysid, subset);
+			state = WriteState.Prolog;
+		}
+	
+		public override void WriteEndAttribute ()
+		{
+			writer.WriteEndAttribute ();
+			state = WriteState.Element;
+		}
+	
+		public override void WriteEndDocument ()
+		{
+			writer.WriteEndDocument ();
+			state = WriteState.Start;
+		}
+	
+		public override void WriteEndElement ()
+		{
+			writer.WriteEndElement ();
+			state = WriteState.Content;
+		}
+	
+		public override void WriteEntityRef (string name)
+		{
+			writer.WriteEntityRef (name);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteFullEndElement ()
+		{
+			writer.WriteFullEndElement ();
+			state = WriteState.Content;
+		}
+	
+		public override void WriteName (string name)
+		{
+			writer.WriteName (name);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteNmToken (string name)
+		{
+			writer.WriteNmToken (name);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteNode (XmlReader reader, bool defattr)
+		{
+			writer.WriteNode (reader, defattr);
+		}
+	
+		public override void WriteProcessingInstruction (string name, string text)
+		{
+			writer.WriteProcessingInstruction (name, text);
+			if (state == WriteState.Start)
+				state = WriteState.Prolog;
+			else
+				state = WriteState.Content;
+		}
+	
+		public override void WriteQualifiedName (string localName, string ns)
+		{
+			writer.WriteQualifiedName (localName, ns);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteRaw (string data)
+		{
+			writer.WriteRaw (data);
+			if (state == WriteState.Start)
+				state = WriteState.Prolog;
+			else
+				state = WriteState.Content;
+		}
+	
+		public override void WriteRaw (char [] buffer, int index, int count)
+		{
+			writer.WriteRaw (buffer, index, count);
+			if (state == WriteState.Start)
+				state = WriteState.Prolog;
+			else
+				state = WriteState.Content;
+		}
+	
+		public override void WriteStartAttribute (string prefix, string localName, string ns)
+		{
+			writer.WriteStartAttribute (prefix, localName, ns);
+			state = WriteState.Attribute;
+		}
+	
+		public override void WriteStartDocument (bool standalone)
+		{
+			writer.WriteStartDocument (standalone);
+			state = WriteState.Prolog;
+		}
+	
+		public override void WriteStartDocument ()
+		{
+			writer.WriteStartDocument ();
+			state = WriteState.Prolog;
+		}
+	
+		public override void WriteStartElement (string prefix, string localName, string ns)
+		{
+			writer.WriteStartElement (prefix, localName, ns);
+			state = WriteState.Element;
+		}
+	
+		public override void WriteString (string text)
+		{
+			writer.WriteString (text);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteSurrogateCharEntity (char lowChar, char highChar)
+		{
+			writer.WriteSurrogateCharEntity (lowChar, highChar);
+			state = WriteState.Content;
+		}
+	
+		public override void WriteWhitespace (string ws)
+		{
+			writer.WriteWhitespace (ws);
+			if (state == WriteState.Start)
+				state = WriteState.Prolog;
+			else
+				state = WriteState.Content;
+		}
+	
+		public override WriteState WriteState {
+			get {
+				if (delegate_write_state)
+					return writer.WriteState;
+				else
+					return state;
+			}
+		}
+	
+		public override string XmlLang {
+			get {
+				return writer.XmlLang;
+			}
+		}
+	
+		public override XmlSpace XmlSpace {
+			get {
+				return writer.XmlSpace;
+			}
+		}
+	}
+}

mcs/class/System.XML/System.Xml/DtdProcessing.cs

@@ -0,0 +1,39 @@
+// System.Xml.DtdProcessing.cs
+//
+// Author:
+//   Stephane Delcroix (stephane@delcroix.org)
+//
+// (C) 2008 Novell, Inc
+
+//
+// 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.
+//
+
+
+namespace System.Xml {
+#if NET_4_0
+	public enum DtdProcessing 
+	{
+		Prohibit = 0,
+		Ignore = 1,
+		Parse = 2
+	}
+#endif
+}

mcs/class/System.XML/System.Xml/EntityHandling.cs

@@ -0,0 +1,50 @@
+// EntityHandling.cs
+//
+// This code was automatically generated from
+// ECMA CLI XML Library Specification.
+// Generator: libgen.xsl [1.0; (C) Sergey Chaban (serge@wildwestsoftware.com)]
+// Created: Wed, 5 Sep 2001 06:46:17 UTC
+// Source file: all.xml
+// URL: http://devresource.hp.com/devresource/Docs/TechPapers/CSharp/all.xml
+//
+// (C) 2001 Ximian, Inc.  http://www.ximian.com
+
+//
+// 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.
+//
+
+
+namespace System.Xml {
+
+
+	/// <summary>
+	/// </summary>
+	public enum EntityHandling {
+
+		/// <summary>
+		/// </summary>
+		ExpandEntities = 1,
+
+		/// <summary>
+		/// </summary>
+		ExpandCharEntities = 2,
+	} // EntityHandling
+
+} // System.Xml

mcs/class/System.XML/System.Xml/EntityResolvingXmlReader.cs

@@ -0,0 +1,440 @@
+//
+// EntityResolvingXmlReader.cs - XmlReader that handles entity resolution
+//
+// Author:
+//   Atsushi Enomoto  (ginga@kit.hi-ho.ne.jp)
+//
+// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
+//
+// 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.Collections.Generic;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Security.Permissions;
+using System.Text;
+using System.Xml.Schema;
+using System.Xml;
+
+namespace Mono.Xml
+{
+	[PermissionSet (SecurityAction.InheritanceDemand, Unrestricted = true)]
+	internal class EntityResolvingXmlReader : XmlReader, IXmlNamespaceResolver,
+		IXmlLineInfo, IHasXmlParserContext
+	{
+		EntityResolvingXmlReader entity;
+		XmlReader source;
+		XmlParserContext context;
+		XmlResolver resolver;
+		EntityHandling entity_handling;
+		bool entity_inside_attr;
+		bool inside_attr;
+		bool do_resolve;
+
+		public EntityResolvingXmlReader (XmlReader source)
+		{
+			this.source = source;
+			IHasXmlParserContext container = source as IHasXmlParserContext;
+			if (container != null)
+				this.context = container.ParserContext;
+			else
+				this.context = new XmlParserContext (source.NameTable, new XmlNamespaceManager (source.NameTable), null, XmlSpace.None);
+		}
+
+		EntityResolvingXmlReader (XmlReader entityContainer,
+			bool inside_attr)
+		{
+			source = entityContainer;
+			this.entity_inside_attr = inside_attr;
+		}
+
+		#region Properties
+
+		private XmlReader Current {
+			get { return entity != null && entity.ReadState != ReadState.Initial ? (XmlReader) entity : source; }
+		}
+
+		public override int AttributeCount {
+			get { return Current.AttributeCount; }
+		}
+
+		public override string BaseURI {
+			get { return Current.BaseURI; }
+		}
+
+		public override bool CanResolveEntity {
+			get { return true; }
+		}
+
+		public override int Depth {
+			get {
+				// On EndEntity, depth is the same as that 
+				// of EntityReference.
+				if (entity != null && entity.ReadState == ReadState.Interactive)
+					return source.Depth + entity.Depth + 1;
+				else
+					return source.Depth;
+			}
+		}
+
+		public override bool EOF {
+			get { return source.EOF; }
+		}
+
+		public override bool HasValue {
+			get { return Current.HasValue; }
+		}
+
+		public override bool IsDefault {
+			get { return Current.IsDefault; }
+		}
+
+		public override bool IsEmptyElement {
+			get { return Current.IsEmptyElement; }
+		}
+
+		public override string LocalName {
+			get { return Current.LocalName; }
+		}
+
+		public override string Name {
+			get { return Current.Name; }
+		}
+
+		public override string NamespaceURI {
+			get { return Current.NamespaceURI; }
+		}
+
+		public override XmlNameTable NameTable {
+			get { return Current.NameTable; }
+		}
+
+		public override XmlNodeType NodeType {
+			get {
+				if (entity != null) {
+					if (entity.ReadState == ReadState.Initial)
+						return source.NodeType;
+					return entity.EOF ? XmlNodeType.EndEntity : entity.NodeType;
+				}
+				return source.NodeType;
+			}
+		}
+
+		internal XmlParserContext ParserContext {
+			get { return context; }
+		}
+
+		XmlParserContext IHasXmlParserContext.ParserContext {
+			get { return context; }
+		}
+
+		public override string Prefix {
+			get { return Current.Prefix; }
+		}
+
+		public override char QuoteChar {
+			get { return Current.QuoteChar; }
+		}
+
+		public override ReadState ReadState {
+			get { return entity != null ? ReadState.Interactive : source.ReadState; }
+		}
+
+		public override string Value {
+			get { return Current.Value; }
+		}
+
+		public override string XmlLang {
+			get { return Current.XmlLang; }
+		}
+
+		public override XmlSpace XmlSpace {
+			get { return Current.XmlSpace; }
+		}
+
+		// non-overrides
+
+		private void CopyProperties (EntityResolvingXmlReader other)
+		{
+			context = other.context;
+			resolver = other.resolver;
+			entity_handling = other.entity_handling;
+		}
+
+		// public members
+
+		public EntityHandling EntityHandling {
+			get { return entity_handling; }
+			set {
+				if (entity != null)
+					entity.EntityHandling = value;
+				entity_handling = value;
+			}
+		}
+
+		public int LineNumber {
+			get {
+				IXmlLineInfo li = Current as IXmlLineInfo;
+				return li == null ? 0 : li.LineNumber;
+			}
+		}
+
+		public int LinePosition {
+			get {
+				IXmlLineInfo li = Current as IXmlLineInfo;
+				return li == null ? 0 : li.LinePosition;
+			}
+		}
+
+		public XmlResolver XmlResolver {
+			set {
+				if (entity != null)
+					entity.XmlResolver = value;
+				resolver = value;
+			}
+		}
+
+		#endregion
+
+		#region Methods
+
+		// overrides
+
+		public override void Close ()
+		{
+			if (entity != null)
+				entity.Close ();
+			source.Close ();
+		}
+
+		public override string GetAttribute (int i)
+		{
+			return Current.GetAttribute (i);
+		}
+
+		// MS.NET 1.0 msdn says that this method returns String.Empty
+		// for absent attribute, but in fact it returns null.
+		// This description is corrected in MS.NET 1.1 msdn.
+		public override string GetAttribute (string name)
+		{
+			return Current.GetAttribute (name);
+		}
+
+		public override string GetAttribute (string localName, string namespaceURI)
+		{
+			return Current.GetAttribute (localName, namespaceURI);
+		}
+
+		public IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope)
+		{
+			return ((IXmlNamespaceResolver) Current).GetNamespacesInScope (scope);
+		}
+
+		IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope (XmlNamespaceScope scope)
+		{
+			return GetNamespacesInScope (scope);
+		}
+
+		string IXmlNamespaceResolver.LookupPrefix (string ns)
+		{
+			return ((IXmlNamespaceResolver) Current).LookupPrefix (ns);
+		}
+
+		public override string LookupNamespace (string prefix)
+		{
+			return Current.LookupNamespace (prefix);
+		}
+
+		public override void MoveToAttribute (int i)
+		{
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			Current.MoveToAttribute (i);
+			inside_attr = true;
+		}
+
+		public override bool MoveToAttribute (string name)
+		{
+			if (entity != null && !entity_inside_attr)
+				return entity.MoveToAttribute (name);
+			if (!source.MoveToAttribute (name))
+				return false;
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			inside_attr = true;
+			return true;
+		}
+
+		public override bool MoveToAttribute (string localName, string namespaceName)
+		{
+			if (entity != null && !entity_inside_attr)
+				return entity.MoveToAttribute (localName, namespaceName);
+			if (!source.MoveToAttribute (localName, namespaceName))
+				return false;
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			inside_attr = true;
+			return true;
+		}
+
+		public override bool MoveToElement ()
+		{
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			if (!Current.MoveToElement ())
+				return false;
+			inside_attr = false;
+			return true;
+		}
+
+		public override bool MoveToFirstAttribute ()
+		{
+			if (entity != null && !entity_inside_attr)
+				return entity.MoveToFirstAttribute ();
+			if (!source.MoveToFirstAttribute ())
+				return false;
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			inside_attr = true;
+			return true;
+		}
+
+		public override bool MoveToNextAttribute ()
+		{
+			if (entity != null && !entity_inside_attr)
+				return entity.MoveToNextAttribute ();
+			if (!source.MoveToNextAttribute ())
+				return false;
+			if (entity != null && entity_inside_attr) {
+				entity.Close ();
+				entity = null;
+			}
+			inside_attr = true;
+			return true;
+		}
+
+		public override bool Read ()
+		{
+			if (do_resolve) {
+				DoResolveEntity ();
+				do_resolve = false;
+			}
+
+			inside_attr = false;
+
+			if (entity != null && (entity_inside_attr || entity.EOF)) {
+				entity.Close ();
+				entity = null;
+			}
+			if (entity != null) {
+				if (entity.Read ())
+					return true;
+				if (EntityHandling == EntityHandling.ExpandEntities) {
+					// EndEntity must be skipped
+					entity.Close ();
+					entity = null;
+					return Read ();
+				}
+				else
+					return true; // either success or EndEntity
+			}
+			else {
+				if (!source.Read ())
+					return false;
+				if (EntityHandling == EntityHandling.ExpandEntities
+					&& source.NodeType == XmlNodeType.EntityReference) {
+					ResolveEntity ();
+					return Read ();
+				}
+				return true;
+			}
+		}
+
+		public override bool ReadAttributeValue ()
+		{
+			if (entity != null && entity_inside_attr) {
+				if (entity.EOF) {
+					entity.Close ();
+					entity = null;
+				}
+				else {
+					entity.Read ();
+					return true; // either success or EndEntity
+				}
+			}
+			return Current.ReadAttributeValue ();
+		}
+
+		public override string ReadString ()
+		{
+			return base.ReadString ();
+		}
+
+		public override void ResolveEntity ()
+		{
+			DoResolveEntity ();
+		}
+
+		void DoResolveEntity ()
+		{
+			if (entity != null)
+				entity.ResolveEntity ();
+			else {
+				if (source.NodeType != XmlNodeType.EntityReference)
+					throw new InvalidOperationException ("The current node is not an Entity Reference");
+				if (ParserContext.Dtd == null)
+					throw new XmlException (this as IXmlLineInfo, this.BaseURI, String.Format ("Cannot resolve entity without DTD: '{0}'", source.Name));
+				XmlReader entReader = ParserContext.Dtd.GenerateEntityContentReader (
+					source.Name, ParserContext);
+				if (entReader == null)
+					throw new XmlException (this as IXmlLineInfo, this.BaseURI, String.Format ("Reference to undeclared entity '{0}'.", source.Name));
+
+				entity = new EntityResolvingXmlReader (
+					entReader, inside_attr);
+				entity.CopyProperties (this);
+			}
+		}
+
+		public override void Skip ()
+		{
+			base.Skip ();
+		}
+
+		public bool HasLineInfo ()
+		{
+			IXmlLineInfo li = Current as IXmlLineInfo;
+			return li == null ? false : li.HasLineInfo ();
+		}
+
+		#endregion
+	}
+}

mcs/class/System.XML/System.Xml/Formatting.cs

@@ -0,0 +1,50 @@
+// Formatting.cs
+//
+// This code was automatically generated from
+// ECMA CLI XML Library Specification.
+// Generator: libgen.xsl [1.0; (C) Sergey Chaban (serge@wildwestsoftware.com)]
+// Created: Wed, 5 Sep 2001 06:31:21 UTC
+// Source file: AllTypes.xml
+// URL: http://msdn.microsoft.com/net/ecma/AllTypes.xml
+//
+// (C) 2001 Ximian, Inc.  http://www.ximian.com
+
+//
+// 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.
+//
+
+
+namespace System.Xml {
+
+
+	/// <summary>
+	/// </summary>
+	public enum Formatting {
+
+		/// <summary>
+		/// </summary>
+		None = 0,
+
+		/// <summary>
+		/// </summary>
+		Indented = 1,
+	} // Formatting
+
+} // System.Xml

mcs/class/System.XML/System.Xml/IHasXmlChildNode.cs

@@ -0,0 +1,37 @@
+//
+// System.Xml.IHasXmlChildNode.cs
+//
+// Authors:
+//   Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
+//
+// Copyright (c) 2006 Novell, Inc.
+//
+
+//
+// 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.
+//
+
+namespace System.Xml
+{
+	internal interface IHasXmlChildNode
+	{
+		XmlLinkedNode LastLinkedChild { get; set; }
+	}
+}

mcs/class/System.XML/System.Xml/IHasXmlNode.cs

@@ -0,0 +1,36 @@
+//
+// System.Xml.IHasXmlNode.cs
+//
+// Author: Duncan Mak  (duncan@ximian.com)
+//
+// (C) Ximian, Inc.
+//
+
+//
+// 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.
+//
+
+namespace System.Xml
+{
+	public interface IHasXmlNode
+	{
+		XmlNode GetNode ();
+	}
+}

mcs/class/System.XML/System.Xml/IXmlLineInfo.cs

@@ -0,0 +1,40 @@
+//
+// System.Xml.IXmlLineInfo.cs
+//
+// Author:
+//   Jason Diamond (jason@injektilo.org)
+//
+// (C) 2001 Jason Diamond  http://injektilo.org/
+//
+
+//
+// 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.
+//
+
+namespace System.Xml
+{
+	public interface IXmlLineInfo
+	{
+		int LineNumber { get; }
+		int LinePosition { get; }
+
+		bool HasLineInfo();
+	}
+}

mcs/class/System.XML/System.Xml/IXmlNamespaceResolver.cs

@@ -0,0 +1,42 @@
+//
+// IXmlNamespaceResolver.cs
+//
+// Author:
+//	Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
+//
+
+//
+// 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.Generic;
+
+namespace System.Xml
+{
+	public interface IXmlNamespaceResolver
+	{
+		IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope);
+
+		string LookupNamespace (string prefix);
+
+		string LookupPrefix (string namespaceName);
+	}
+}

mcs/class/System.XML/System.Xml/MonoFIXAttribute.cs

@@ -0,0 +1,54 @@
+//
+// MonoFIXAttribute.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// (C) Novell, Inc.  http://www.novell.com
+//
+
+//
+// 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.
+//
+
+namespace System.Xml
+{
+	/// <summary>
+	/// This class is used to mark significant MS bugs in the API
+	/// </summary>
+	[AttributeUsage (AttributeTargets.All)]
+	internal class MonoFIXAttribute : Attribute {
+
+		string comment;
+
+		public MonoFIXAttribute ()
+		{}
+
+		public MonoFIXAttribute (string comment)
+		{
+			this.comment = comment;
+		}
+
+		public string Comment {
+			get { return comment; }
+		}
+	}
+
+}

mcs/class/System.XML/System.Xml/NameTable.cs

@@ -0,0 +1,205 @@
+//
+// System.Xml.NameTable.cs
+//
+// Authors:
+//	Duncan Mak (duncan@ximian.com)
+//	Ben Maurer (bmaurer@users.sourceforge.net)
+//
+// (C) Ximian, Inc.
+// (C) 2003 Ben Maurer
+//
+
+//
+// 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;
+
+namespace System.Xml {
+
+	//
+	// This class implements the name table as a simple
+	// hashtable, using buckets and a linked list.
+	//
+	public class NameTable : XmlNameTable {
+		
+		const int INITIAL_BUCKETS = 2 << 6; // 64
+		
+		int count = INITIAL_BUCKETS;
+		Entry [] buckets = new Entry [INITIAL_BUCKETS];
+		int size;
+
+		public NameTable () {}
+		
+		class Entry {
+			public string str;
+			public int hash, len;
+			public Entry next;
+	
+			public Entry (string str, int hash, Entry next)
+			{
+				this.str = str;
+				this.len = str.Length;
+				this.hash = hash;
+				this.next = next;
+			}
+		}
+		
+		public override string Add (char [] key, int start, int len)
+		{
+			if (((0 > start) && (start >= key.Length))
+			   || ((0 > len) && (len >= key.Length - len)))
+				throw new IndexOutOfRangeException ("The Index is out of range.");
+			
+			if (len == 0) return String.Empty;
+			
+			int h = 0;
+			// This is from the String.Gethash () icall
+			int end = start + len;
+			for (int i = start; i < end; i++)
+				h = (h << 5) - h + key [i];
+			// h must be be >= 0
+			h &= 0x7FFFFFFF;
+			
+
+			for (Entry e = buckets [h % count]; e != null; e = e.next) {
+				if (e.hash == h && e.len == len && StrEqArray (e.str, key, start))
+					return e.str;
+			}
+			return AddEntry (new string (key, start, len), h);
+		}
+		
+		public override string Add (string key)
+		{
+			if (key == null) throw new ArgumentNullException ("key");
+
+			int keyLen = key.Length;
+			if (keyLen == 0) return String.Empty;
+
+			int h = 0;
+			// This is from the String.Gethash () icall
+			for (int i = 0; i < keyLen; i++)
+				h = (h << 5) - h + key [i];
+			
+			// h must be be >= 0
+			h &= 0x7FFFFFFF;
+
+			for (Entry e = buckets [h % count]; e != null; e = e.next) {
+				if (e.hash == h && e.len == key.Length && e.str == key)
+					return e.str;
+			}
+			
+			return AddEntry (key, h);
+		}
+
+		public override string Get (char [] key, int start, int len)
+		{
+			if (((0 > start) && (start >= key.Length))
+			   || ((0 > len) && (len >= key.Length - len)))
+				throw new IndexOutOfRangeException ("The Index is out of range.");
+			
+			if (len == 0) return String.Empty;
+			
+			int h = 0;
+			// This is from the String.Gethash () icall
+			int end = start + len;
+			for (int i = start; i < end; i++)
+				h = (h << 5) - h + key [i];
+			// h must be be >= 0
+			h &= 0x7FFFFFFF;
+			
+			for (Entry e = buckets [h % count]; e != null; e = e.next) {
+				if (e.hash == h && e.len == len && StrEqArray (e.str, key, start))
+					return e.str;
+			}
+			
+			return null;
+		}
+		
+		public override string Get (string value) {
+			if (value == null) throw new ArgumentNullException ("value");
+
+			int valLen = value.Length;
+			if (valLen == 0) return String.Empty;
+				
+			int h = 0;
+			// This is from the String.Gethash () icall
+			for (int i = 0; i < valLen; i++)
+				h = (h << 5) - h + value [i];
+			// h must be be >= 0
+			h &= 0x7FFFFFFF;
+			
+			for (Entry e = buckets [h % count]; e != null; e = e.next) {
+				if (e.hash == h && e.len == value.Length && e.str == value)
+					return e.str;
+			}
+			
+			return null;
+		}
+		
+		string AddEntry (string str, int hash)
+		{
+			int bucket = hash % count;
+			buckets [bucket] = new Entry (str, hash, buckets [bucket]);
+			
+			// Grow whenever we double in size
+			if (size++ == count) {
+				count <<= 1;
+				int csub1 = count - 1;
+				
+				Entry [] newBuckets = new Entry [count];
+				for (int i = 0; i < buckets.Length; i++) {
+					Entry root = buckets [i];
+					Entry e = root;
+					while (e != null) {
+						int newLoc = e.hash & csub1;
+						Entry n = e.next;
+						e.next = newBuckets [newLoc];
+						newBuckets [newLoc] = e;
+						e = n;
+					}
+				}
+
+				buckets = newBuckets;
+			}
+			
+			return str;
+		}
+	
+		static bool StrEqArray (string str, char [] str2, int start)
+		{
+			int i = str.Length;
+			i --;
+			start += i;
+			do
+			{
+				if (str[i] != str2[start])
+					return false;
+
+				i--;
+				start--;
+			}
+			while(i >= 0);
+
+			return true;
+		}
+	}
+}

mcs/class/System.XML/System.Xml/NamespaceHandling.cs

@@ -0,0 +1,36 @@
+//
+// Copyright (C) 2009 Novell, Inc (http://www.novell.com)
+//
+// 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.
+//
+
+namespace System.Xml {
+
+	[Flags]
+#if NET_4_0
+	public
+#else
+	internal
+#endif
+	enum NamespaceHandling {
+		Default,
+		OmitDuplicates = 1,
+	}
+}

mcs/class/System.XML/System.Xml/NewLineHandling.cs

@@ -0,0 +1,41 @@
+//
+// NewLineHandling.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+
+//
+// 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.
+//
+namespace System.Xml
+{
+#if NET_2_0
+	public
+#else
+	internal
+#endif
+	enum NewLineHandling
+	{
+		Replace,
+		Entitize,
+		None
+	}
+}

mcs/class/System.XML/System.Xml/ReadState.cs

@@ -0,0 +1,62 @@
+// ReadState.cs
+//
+// This code was automatically generated from
+// ECMA CLI XML Library Specification.
+// Generator: libgen.xsl [1.0; (C) Sergey Chaban (serge@wildwestsoftware.com)]
+// Created: Wed, 5 Sep 2001 06:31:27 UTC
+// Source file: AllTypes.xml
+// URL: http://msdn.microsoft.com/net/ecma/AllTypes.xml
+//
+// (C) 2001 Ximian, Inc.  http://www.ximian.com
+
+//
+// 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.
+//
+
+
+namespace System.Xml {
+
+
+	/// <summary>
+	/// </summary>
+	public enum ReadState {
+
+		/// <summary>
+		/// </summary>
+		Initial = 0,
+
+		/// <summary>
+		/// </summary>
+		Interactive = 1,
+
+		/// <summary>
+		/// </summary>
+		Error = 2,
+
+		/// <summary>
+		/// </summary>
+		EndOfFile = 3,
+
+		/// <summary>
+		/// </summary>
+		Closed = 4,
+	} // ReadState
+
+} // System.Xml