2002-06-10 Ajay kumar Dwivedi <[email protected]>

	* XmlConstruct.cs : New Internal class with Helper methods for
	Checking XmlConstructs
	* XmlConvert.cs: Implemented most of the methods

svn path=/trunk/mcs/; revision=5198

mcs/class/System.XML/System.Xml/ChangeLog

@@ -1,3 +1,8 @@
+2002-06-10  Ajay kumar Dwivedi <[email protected]>
+	* XmlConstruct.cs : New Internal class with Helper methods for
+	Checking XmlConstructs
+	* XmlConvert.cs: Implemented most of the methods
+
 2002-06-08  Duncan Mak  <[email protected]>	
 
 	* XmlDocument.cs (Load):

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

@@ -0,0 +1,545 @@
+using System;
+
+namespace System.Xml
+{
+	/// <summary>
+	/// http://www.w3.org/TR/REC-xml
+	/// </summary>
+	/// <remarks>
+	/// Includes code and Ideas from  org.apache.xerces.util.XMLChar class of Xerces 2.0.1
+	/// However, No surrogate support is included in this class.
+	/// This class is currently public. Make it internal after testing completes
+	/// </remarks>
+	public class XmlConstructs
+	{
+		/** Character flags. */
+		internal static byte[] CHARS = new byte[1 << 16];
+
+		/** Valid character mask. */
+		internal static int VALID = 0x01;
+
+		/** Space character mask. */
+		internal static int SPACE = 0x02;
+
+		/** Name start character mask. */
+		internal static int NAME_START = 0x04;
+
+		/** Name character mask. */
+		internal static int NAME = 0x08;
+
+		/** Pubid character mask. */
+		internal static int PUBID = 0x10;
+		/** 
+			 * Content character mask. Special characters are those that can
+			 * be considered the start of markup, such as '&lt;' and '&amp;'. 
+			 * The various newline characters are considered special as well.
+			 * All other valid XML characters can be considered content.
+			 * <p>
+			 * This is an optimization for the inner loop of character scanning.
+			 */
+		internal static int CONTENT = 0x20;
+
+		/** NCName start character mask. */
+		internal static int NCNAME_START = 0x40;
+
+		/** NCName character mask. */
+		internal static int NCNAME = 0x80;
+	
+		static XmlConstructs()
+		{
+			//
+			// [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] |
+			//              [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+			//
+			int[] charRange = { 
+								  0x0009, 0x000A, 0x000D, 0x000D, 0x0020, 0xD7FF, 0xE000, 0xFFFD,
+			};
+
+			//
+			// [3] S ::= (#x20 | #x9 | #xD | #xA)+
+			//
+			int[] spaceChar = { 
+								  0x0020, 0x0009, 0x000D, 0x000A,
+			};
+
+			//
+			// [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+			//                  CombiningChar | Extender
+			//
+			int[] nameChar = { 
+								 0x002D, 0x002E, // '-' and '.'
+			};
+
+			//
+			// [5] Name ::= (Letter | '_' | ':') (NameChar)*
+			//
+
+			int[] nameStartChar = { 
+									  0x003A, 0x005F, // ':' and '_'
+			};
+
+			//
+			// [13] PubidChar ::= #x20 | 0xD | 0xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
+			//
+
+			int[] pubidChar = {
+								  0x000A, 0x000D, 0x0020, 0x0021, 0x0023, 0x0024, 0x0025, 0x003D,
+								  0x005F
+							  };
+
+			int[] pubidRange = {
+								   0x0027, 0x003B, 0x003F, 0x005A, 0x0061, 0x007A
+							   };
+
+			//
+			// [84] Letter ::= BaseChar | Ideographic
+			//
+
+			int[] letterRange = {
+									// BaseChar
+									0x0041, 0x005A, 0x0061, 0x007A, 0x00C0, 0x00D6, 0x00D8, 0x00F6,
+									0x00F8, 0x0131, 0x0134, 0x013E, 0x0141, 0x0148, 0x014A, 0x017E,
+									0x0180, 0x01C3, 0x01CD, 0x01F0, 0x01F4, 0x01F5, 0x01FA, 0x0217,
+									0x0250, 0x02A8, 0x02BB, 0x02C1, 0x0388, 0x038A, 0x038E, 0x03A1,
+									0x03A3, 0x03CE, 0x03D0, 0x03D6, 0x03E2, 0x03F3, 0x0401, 0x040C,
+									0x040E, 0x044F, 0x0451, 0x045C, 0x045E, 0x0481, 0x0490, 0x04C4,
+									0x04C7, 0x04C8, 0x04CB, 0x04CC, 0x04D0, 0x04EB, 0x04EE, 0x04F5,
+									0x04F8, 0x04F9, 0x0531, 0x0556, 0x0561, 0x0586, 0x05D0, 0x05EA,
+									0x05F0, 0x05F2, 0x0621, 0x063A, 0x0641, 0x064A, 0x0671, 0x06B7,
+									0x06BA, 0x06BE, 0x06C0, 0x06CE, 0x06D0, 0x06D3, 0x06E5, 0x06E6,
+									0x0905, 0x0939, 0x0958, 0x0961, 0x0985, 0x098C, 0x098F, 0x0990,
+									0x0993, 0x09A8, 0x09AA, 0x09B0, 0x09B6, 0x09B9, 0x09DC, 0x09DD,
+									0x09DF, 0x09E1, 0x09F0, 0x09F1, 0x0A05, 0x0A0A, 0x0A0F, 0x0A10,
+									0x0A13, 0x0A28, 0x0A2A, 0x0A30, 0x0A32, 0x0A33, 0x0A35, 0x0A36,
+									0x0A38, 0x0A39, 0x0A59, 0x0A5C, 0x0A72, 0x0A74, 0x0A85, 0x0A8B,
+									0x0A8F, 0x0A91, 0x0A93, 0x0AA8, 0x0AAA, 0x0AB0, 0x0AB2, 0x0AB3,
+									0x0AB5, 0x0AB9, 0x0B05, 0x0B0C, 0x0B0F, 0x0B10, 0x0B13, 0x0B28,
+									0x0B2A, 0x0B30, 0x0B32, 0x0B33, 0x0B36, 0x0B39, 0x0B5C, 0x0B5D,
+									0x0B5F, 0x0B61, 0x0B85, 0x0B8A, 0x0B8E, 0x0B90, 0x0B92, 0x0B95,
+									0x0B99, 0x0B9A, 0x0B9E, 0x0B9F, 0x0BA3, 0x0BA4, 0x0BA8, 0x0BAA,
+									0x0BAE, 0x0BB5, 0x0BB7, 0x0BB9, 0x0C05, 0x0C0C, 0x0C0E, 0x0C10,
+									0x0C12, 0x0C28, 0x0C2A, 0x0C33, 0x0C35, 0x0C39, 0x0C60, 0x0C61,
+									0x0C85, 0x0C8C, 0x0C8E, 0x0C90, 0x0C92, 0x0CA8, 0x0CAA, 0x0CB3,
+									0x0CB5, 0x0CB9, 0x0CE0, 0x0CE1, 0x0D05, 0x0D0C, 0x0D0E, 0x0D10,
+									0x0D12, 0x0D28, 0x0D2A, 0x0D39, 0x0D60, 0x0D61, 0x0E01, 0x0E2E,
+									0x0E32, 0x0E33, 0x0E40, 0x0E45, 0x0E81, 0x0E82, 0x0E87, 0x0E88,
+									0x0E94, 0x0E97, 0x0E99, 0x0E9F, 0x0EA1, 0x0EA3, 0x0EAA, 0x0EAB,
+									0x0EAD, 0x0EAE, 0x0EB2, 0x0EB3, 0x0EC0, 0x0EC4, 0x0F40, 0x0F47,
+									0x0F49, 0x0F69, 0x10A0, 0x10C5, 0x10D0, 0x10F6, 0x1102, 0x1103,
+									0x1105, 0x1107, 0x110B, 0x110C, 0x110E, 0x1112, 0x1154, 0x1155,
+									0x115F, 0x1161, 0x116D, 0x116E, 0x1172, 0x1173, 0x11AE, 0x11AF,
+									0x11B7, 0x11B8, 0x11BC, 0x11C2, 0x1E00, 0x1E9B, 0x1EA0, 0x1EF9,
+									0x1F00, 0x1F15, 0x1F18, 0x1F1D, 0x1F20, 0x1F45, 0x1F48, 0x1F4D,
+									0x1F50, 0x1F57, 0x1F5F, 0x1F7D, 0x1F80, 0x1FB4, 0x1FB6, 0x1FBC,
+									0x1FC2, 0x1FC4, 0x1FC6, 0x1FCC, 0x1FD0, 0x1FD3, 0x1FD6, 0x1FDB,
+									0x1FE0, 0x1FEC, 0x1FF2, 0x1FF4, 0x1FF6, 0x1FFC, 0x212A, 0x212B,
+									0x2180, 0x2182, 0x3041, 0x3094, 0x30A1, 0x30FA, 0x3105, 0x312C,
+									0xAC00, 0xD7A3,
+									// Ideographic
+									0x3021, 0x3029, 0x4E00, 0x9FA5,
+			};
+			int[] letterChar = {
+								   // BaseChar
+								   0x0386, 0x038C, 0x03DA, 0x03DC, 0x03DE, 0x03E0, 0x0559, 0x06D5,
+								   0x093D, 0x09B2, 0x0A5E, 0x0A8D, 0x0ABD, 0x0AE0, 0x0B3D, 0x0B9C,
+								   0x0CDE, 0x0E30, 0x0E84, 0x0E8A, 0x0E8D, 0x0EA5, 0x0EA7, 0x0EB0,
+								   0x0EBD, 0x1100, 0x1109, 0x113C, 0x113E, 0x1140, 0x114C, 0x114E,
+								   0x1150, 0x1159, 0x1163, 0x1165, 0x1167, 0x1169, 0x1175, 0x119E,
+								   0x11A8, 0x11AB, 0x11BA, 0x11EB, 0x11F0, 0x11F9, 0x1F59, 0x1F5B,
+								   0x1F5D, 0x1FBE, 0x2126, 0x212E,
+								   // Ideographic
+								   0x3007,
+			};
+
+			//
+			// [87] CombiningChar ::= ...
+			//
+
+			int[] combiningCharRange = {
+										   0x0300, 0x0345, 0x0360, 0x0361, 0x0483, 0x0486, 0x0591, 0x05A1,
+										   0x05A3, 0x05B9, 0x05BB, 0x05BD, 0x05C1, 0x05C2, 0x064B, 0x0652,
+										   0x06D6, 0x06DC, 0x06DD, 0x06DF, 0x06E0, 0x06E4, 0x06E7, 0x06E8,
+										   0x06EA, 0x06ED, 0x0901, 0x0903, 0x093E, 0x094C, 0x0951, 0x0954,
+										   0x0962, 0x0963, 0x0981, 0x0983, 0x09C0, 0x09C4, 0x09C7, 0x09C8,
+										   0x09CB, 0x09CD, 0x09E2, 0x09E3, 0x0A40, 0x0A42, 0x0A47, 0x0A48,
+										   0x0A4B, 0x0A4D, 0x0A70, 0x0A71, 0x0A81, 0x0A83, 0x0ABE, 0x0AC5,
+										   0x0AC7, 0x0AC9, 0x0ACB, 0x0ACD, 0x0B01, 0x0B03, 0x0B3E, 0x0B43,
+										   0x0B47, 0x0B48, 0x0B4B, 0x0B4D, 0x0B56, 0x0B57, 0x0B82, 0x0B83,
+										   0x0BBE, 0x0BC2, 0x0BC6, 0x0BC8, 0x0BCA, 0x0BCD, 0x0C01, 0x0C03,
+										   0x0C3E, 0x0C44, 0x0C46, 0x0C48, 0x0C4A, 0x0C4D, 0x0C55, 0x0C56,
+										   0x0C82, 0x0C83, 0x0CBE, 0x0CC4, 0x0CC6, 0x0CC8, 0x0CCA, 0x0CCD,
+										   0x0CD5, 0x0CD6, 0x0D02, 0x0D03, 0x0D3E, 0x0D43, 0x0D46, 0x0D48,
+										   0x0D4A, 0x0D4D, 0x0E34, 0x0E3A, 0x0E47, 0x0E4E, 0x0EB4, 0x0EB9,
+										   0x0EBB, 0x0EBC, 0x0EC8, 0x0ECD, 0x0F18, 0x0F19, 0x0F71, 0x0F84,
+										   0x0F86, 0x0F8B, 0x0F90, 0x0F95, 0x0F99, 0x0FAD, 0x0FB1, 0x0FB7,
+										   0x20D0, 0x20DC, 0x302A, 0x302F,
+			};
+
+			int[] combiningCharChar = {
+										  0x05BF, 0x05C4, 0x0670, 0x093C, 0x094D, 0x09BC, 0x09BE, 0x09BF,
+										  0x09D7, 0x0A02, 0x0A3C, 0x0A3E, 0x0A3F, 0x0ABC, 0x0B3C, 0x0BD7,
+										  0x0D57, 0x0E31, 0x0EB1, 0x0F35, 0x0F37, 0x0F39, 0x0F3E, 0x0F3F,
+										  0x0F97, 0x0FB9, 0x20E1, 0x3099, 0x309A,
+			};
+
+			//
+			// [88] Digit ::= ...
+			//
+
+			int[] digitRange = {
+								   0x0030, 0x0039, 0x0660, 0x0669, 0x06F0, 0x06F9, 0x0966, 0x096F,
+								   0x09E6, 0x09EF, 0x0A66, 0x0A6F, 0x0AE6, 0x0AEF, 0x0B66, 0x0B6F,
+								   0x0BE7, 0x0BEF, 0x0C66, 0x0C6F, 0x0CE6, 0x0CEF, 0x0D66, 0x0D6F,
+								   0x0E50, 0x0E59, 0x0ED0, 0x0ED9, 0x0F20, 0x0F29,
+			};
+
+			//
+			// [89] Extender ::= ...
+			//
+
+			int[] extenderRange = {
+									  0x3031, 0x3035, 0x309D, 0x309E, 0x30FC, 0x30FE,
+			};
+
+			int[] extenderChar = {
+									 0x00B7, 0x02D0, 0x02D1, 0x0387, 0x0640, 0x0E46, 0x0EC6, 0x3005,
+			};
+
+			//
+			// SpecialChar ::= '<', '&', '\n', '\r', ']'
+			//
+
+			int[] specialChar = {
+									'<', '&', '\n', '\r', ']',
+			};
+
+			//
+			// Initialize
+			//
+
+			// set valid characters
+			for (int i = 0; i < charRange.Length; i += 2) 
+			{
+				for (int j = charRange[i]; j <= charRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | VALID | CONTENT);
+				}
+			}
+
+			// remove special characters
+			for (int i = 0; i < specialChar.Length; i++) 
+			{
+				CHARS[specialChar[i]] = (byte)(CHARS[specialChar[i]] & ~CONTENT);
+			}
+
+			// set space characters
+			for (int i = 0; i < spaceChar.Length; i++) 
+			{
+				CHARS[spaceChar[i]] = (byte)(CHARS[spaceChar[i]] | SPACE);
+			}
+
+			// set name start characters
+			for (int i = 0; i < nameStartChar.Length; i++) 
+			{
+				CHARS[nameStartChar[i]] = (byte)(CHARS[nameStartChar[i]] | NAME_START | NAME | 
+					NCNAME_START | NCNAME);
+			}
+			for (int i = 0; i < letterRange.Length; i += 2) 
+			{
+				for (int j = letterRange[i]; j <= letterRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | NAME_START | NAME |	NCNAME_START | NCNAME);
+				}
+			}
+			for (int i = 0; i < letterChar.Length; i++) 
+			{
+				CHARS[letterChar[i]] = (byte)(CHARS[letterChar[i]] | NAME_START | NAME |
+					NCNAME_START | NCNAME);
+			}
+
+			// set name characters
+			for (int i = 0; i < nameChar.Length; i++) 
+			{
+				CHARS[nameChar[i]] = (byte)(CHARS[nameChar[i]] | NAME | NCNAME);
+			}
+			for (int i = 0; i < digitRange.Length; i += 2) 
+			{
+				for (int j = digitRange[i]; j <= digitRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | NAME | NCNAME);
+				}
+			}
+			for (int i = 0; i < combiningCharRange.Length; i += 2) 
+			{
+				for (int j = combiningCharRange[i]; j <= combiningCharRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | NAME | NCNAME);
+				}
+			}
+			for (int i = 0; i < combiningCharChar.Length; i++) 
+			{
+				CHARS[combiningCharChar[i]] = (byte)(CHARS[combiningCharChar[i]] | NAME | NCNAME);
+			}
+			for (int i = 0; i < extenderRange.Length; i += 2) 
+			{
+				for (int j = extenderRange[i]; j <= extenderRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | NAME | NCNAME);
+				}
+			}
+			for (int i = 0; i < extenderChar.Length; i++) 
+			{
+				CHARS[extenderChar[i]] = (byte)(CHARS[extenderChar[i]] | NAME | NCNAME);
+			}
+
+			// remove ':' from allowable NCNAME_START and NCNAME chars
+			CHARS[':'] = (byte)(CHARS[':'] & ~(NCNAME_START | NCNAME));
+
+			// set Pubid characters
+			for (int i = 0; i < pubidChar.Length; i++) 
+			{
+				CHARS[pubidChar[i]] = (byte)(CHARS[pubidChar[i]] | PUBID);
+			}
+			for (int i = 0; i < pubidRange.Length; i += 2) 
+			{
+				for (int j = pubidRange[i]; j <= pubidRange[i + 1]; j++) 
+				{
+					CHARS[j] = (byte)(CHARS[j] | PUBID);
+				}
+			}
+		}
+
+		private XmlConstructs()
+		{
+		}
+
+
+		//Static Methods
+
+		/// <summary>
+		/// Returns true if the specified character is valid.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsValid(char c) 
+		{
+			return (CHARS[c] & VALID) != 0;
+		}
+
+		/// <summary>
+		/// Returns true if the specified character is invalid.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsInvalid(char c) 
+		{
+			return !IsValid(c);
+		}
+
+		/// <summary>
+		/// Returns true if the specified character can be considered content.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsContent(char c) 
+		{
+			return (CHARS[c] & CONTENT) != 0;
+		}
+
+		/// <summary>
+		/// Returns true if the specified character can be considered markup.
+		/// Markup characters include '&lt;', '&amp;', and '%'.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsMarkup(char c) 
+		{
+			return c == '<' || c == '&' || c == '%';
+		}
+
+		/// <summary>
+		/// Returns true if the specified character is a space character
+		/// as defined by production [3] in the XML 1.0 specification. 
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		/// <returns></returns>
+		public static bool IsSpace(char c) 
+		{
+			return (CHARS[c] & SPACE) != 0;
+		}
+
+		/// <summary>
+		/// Returns true if the specified character is a valid name start
+		/// character as defined by production [5] in the XML 1.0 specification.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsNameStart(char c) 
+		{
+			return (CHARS[c] & NAME_START) != 0;
+		} 
+
+		/// <summary>
+		/// Returns true if the specified character is a valid name
+		/// character as defined by production [4] in the XML 1.0 specification.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		public static bool IsName(char c) 
+		{
+			return (CHARS[c] & NAME) != 0;
+		} 
+
+		/// <summary>
+		/// Returns true if the specified character is a valid NCName start
+		/// character as defined by production [4] in Namespaces in XML
+		/// recommendation.
+		/// </summary>
+		/// <param name="c">The character to check.</param>
+		/// <returns></returns>
+		public static bool IsNCNameStart(char c) 
+		{
+			return (CHARS[c] & NCNAME_START) != 0;
+		} 
+
+		/// <summary>
+		/// Returns true if the specified character is a valid NCName
+		/// character as defined by production [5] in Namespaces in XML
+		/// recommendation.
+		/// </summary>
+		/// <param name="c"></param>
+		/// <returns></returns>
+		public static bool IsNCName(char c) 
+		{
+			return (CHARS[c] & NCNAME) != 0;
+		} 
+
+		/// <summary>
+		/// Returns true if the specified character is a valid Pubid
+		/// character as defined by production [13] in the XML 1.0 specification.
+		/// </summary>
+		/// <param name="c">The character to check</param>
+		public static bool IsPubid(char c) 
+		{
+			return (CHARS[c] & PUBID) != 0;
+		}
+
+		/// <summary>
+		/// Check to see if a string is a valid Name according to [5]
+		/// in the XML 1.0 Recommendation
+		/// </summary>
+		/// <param name="name">The string to check</param>
+		public static bool IsValidName(String name, out Exception err) 
+		{
+			err = null;
+			if (name.Length == 0)
+			{
+				err = new XmlException("Name can not be an empty string",null);
+				return false;
+			}
+			char ch = name[0];
+			if( IsNameStart(ch) == false)
+			{
+				err = new XmlException("The character '"+ch+"' cannot start a Name",null);
+				return false;
+			}
+			for (int i = 1; i < name.Length; i++ ) 
+			{
+				ch = name[i];
+				if( IsName( ch ) == false )
+				{
+					err = new XmlException("The character '"+ch+"' is not allowed in a Name",null);
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/// <summary>
+		/// Check to see if a string is a valid NCName according to [4]
+		/// from the XML Namespaces 1.0 Recommendation
+		/// </summary>
+		/// <param name="ncName">The string to check</param>
+		public static bool IsValidNCName(String ncName, out Exception err) 
+		{
+			err = null;
+			if (ncName.Length == 0)
+			{
+				err = new XmlException("NCName can not be an empty string",null);
+				return false;
+			}
+			char ch = ncName[0];
+			if( IsNCNameStart(ch) == false)
+			{
+				err = new XmlException("The character '"+ch+"' cannot start a NCName",null);
+				return false;
+			}
+			for (int i = 1; i < ncName.Length; i++ ) 
+			{
+				ch = ncName[i];
+				if( IsNCName( ch ) == false )
+				{
+					err = new XmlException("The character '"+ch+"' is not allowed in a NCName",null);
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/// <summary>
+		/// Check to see if a string is a valid Nmtoken according to [7]
+		/// in the XML 1.0 Recommendation
+		/// </summary>
+		/// <param name="nmtoken">The string to check.</param>
+		public static bool IsValidNmtoken(String nmtoken, out Exception err) 
+		{
+			err = null;
+			if (nmtoken.Length == 0)
+			{
+				err = new XmlException("NMTOKEN can not be an empty string", null);
+				return false;
+			}
+			for (int i = 0; i < nmtoken.Length; i++ ) 
+			{
+				char ch = nmtoken[i];
+				if(  ! IsName( ch ) )
+				{
+					err = new XmlException("The character '"+ch+"' is not allowed in a NMTOKEN",null);
+					return false;
+				}
+			}
+			return true;
+		}
+
+		// encodings
+
+		/// <summary>
+		/// Returns true if the encoding name is a valid IANA encoding.
+		/// This method does not verify that there is a decoder available
+		/// for this encoding, only that the characters are valid for an
+		/// IANA encoding name.
+		/// </summary>
+		/// <param name="ianaEncoding">The encoding to check.</param>
+		/// <returns></returns>
+		public static bool IsValidIANAEncoding(String ianaEncoding) 
+		{
+			if (ianaEncoding != null) 
+			{
+				int length = ianaEncoding.Length;
+				if (length > 0) 
+				{
+					char c = ianaEncoding[0];
+					if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) 
+					{
+						for (int i = 1; i < length; i++) 
+						{
+							c = ianaEncoding[i];
+							if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
+								(c < '0' || c > '9') && c != '.' && c != '_' &&
+								c != '-') 
+							{
+								return false;
+							}
+						}
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+	}
+}

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

@@ -1,17 +1,240 @@
-//
+// Author: Dwivedi, Ajay kumar
+//            [email protected]
 // XmlConvert.cs: Xml data type conversion
-//
-// Only a stub for now
-//
+// 
 using System;
+using System.Globalization;
 
 namespace System.Xml {
 
 	public class XmlConvert {
 
-		public static string VerifyNCName (string name)
-		{
-			throw new NotImplementedException ();
+		public XmlConvert()
+		{}
+
+		// Methods
+		[MonoTODO]
+		public static string DecodeName(string name)
+		{
+			return null;
+		}
+		[MonoTODO]
+		public static string EncodeLocalName(string name)
+		{
+			return null;
+		}
+		[MonoTODO]
+		public static string EncodeName(string name)
+		{
+			return null;
+		}
+		[MonoTODO]
+		public static string EncodeNmToken(string name)
+		{
+			return null;
+		}
+
+		// {true, false, 1, 0}
+		public static bool ToBoolean(string s)
+		{
+			s = s.Trim();
+			switch(s)
+			{
+				case "1":
+					return true;
+				case "true":
+					return true;
+				case "0":
+					return false;
+				case "false":
+					return false;
+				default:
+					throw new FormatException(s + " is not a valid boolean value");
+			}
+		}
+
+		public static byte ToByte(string s)
+		{
+			return Byte.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static char ToChar(string s)
+		{
+			return char.Parse(s);
+		}
+
+		[MonoTODO]
+		public static DateTime ToDateTime(string s)
+		{
+			throw new NotImplementedException();
+		}
+
+		[MonoTODO]
+		public static DateTime ToDateTime(string s, string format)
+		{
+			throw new NotImplementedException();
+		}
+		
+		[MonoTODO]
+		public static DateTime ToDateTime(string s, string[] formats)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public static Decimal ToDecimal(string s)
+		{
+			return Decimal.Parse(s, CultureInfo.InvariantCulture);
+		}
+		
+		public static double ToDouble(string s)
+		{
+			return Double.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static Guid ToGuid(string s)
+		{
+			return new Guid(s);
+		}
+
+		public static short ToInt16(string s)
+		{
+			return Int16.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static int ToInt32(string s)
+		{
+			return Int32.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static long ToInt64(string s)
+		{
+			return Int64.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static SByte ToSByte(string s)
+		{
+			return SByte.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static float ToSingle(string s)
+		{
+			return Single.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(Guid value)
+		{
+			return value.ToString("D",CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(int value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(short value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(byte value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(long value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(char value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(bool value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+
+		public static string ToString(SByte value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(Decimal value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(UInt64 value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(TimeSpan value)
+		{
+			return value.ToString();
+		}
+		public static string ToString(double value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(float value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(UInt32 value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(UInt16 value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(DateTime value)
+		{
+			return value.ToString(CultureInfo.InvariantCulture);
+		}
+		public static string ToString(DateTime value, string format)
+		{
+			return value.ToString(format, CultureInfo.InvariantCulture);
+		}
+		public static TimeSpan ToTimeSpan(string s)
+		{
+			return TimeSpan.Parse(s);
+		}
+		public static UInt16 ToUInt16(string s)
+		{
+			return UInt16.Parse(s, CultureInfo.InvariantCulture);
+		}
+		public static UInt32 ToUInt32(string s)
+		{
+			return UInt32.Parse(s, CultureInfo.InvariantCulture);
+		}
+		public static UInt64 ToUInt64(string s)
+		{
+			return UInt64.Parse(s, CultureInfo.InvariantCulture);
+		}
+
+		public static string VerifyName(string name)
+		{
+			Exception innerEx;
+			if(name == null)
+				throw new ArgumentNullException("name");
+
+			if(XmlConstructs.IsValidName(name, out innerEx))
+				return name;
+			
+			throw new XmlException("'"+name+"' is not a valid XML Name",null);
+		}
+
+		public static string VerifyNCName(string ncname)
+		{
+			Exception innerEx;
+			if(ncname == null)
+				throw new ArgumentNullException("ncname");
+
+			if(XmlConstructs.IsValidName(ncname, out innerEx))
+				return ncname;
+			
+			throw new XmlException("'"+ncname+"' is not a valid XML NCName",innerEx);
 		}
 	}
 }