utf32encoding.cs

来自「没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没」· CS 代码 · 共 813 行 · 第 1/2 页

			}

	// Internal version of "GetChars".
	private static int InternalGetChars(ByteOrder byteOrder,
										byte[] leftOver, ref int leftOverLen,
										byte[] bytes, int byteIndex,
										int byteCount,
								 		char[] chars, int charIndex)
			{
				// Validate the parameters.
				if(bytes == null)
				{
					throw new ArgumentNullException("bytes");
				}
				if(chars == null)
				{
					throw new ArgumentNullException("chars");
				}
				if(byteIndex < 0 || byteIndex > bytes.Length)
				{
					throw new ArgumentOutOfRangeException
						("byteIndex", _("ArgRange_Array"));
				}
				if(byteCount < 0 || byteCount > (bytes.Length - byteIndex))
				{
					throw new ArgumentOutOfRangeException
						("byteCount", _("ArgRange_Array"));
				}
				if(charIndex < 0 || charIndex > chars.Length)
				{
					throw new ArgumentOutOfRangeException
						("charIndex", _("ArgRange_Array"));
				}

				// Handle the left-over buffer.
				uint value;
				int start = charIndex;
				int charCount = chars.Length - charIndex;
				if(leftOverLen > 0)
				{
					if((leftOverLen + byteCount) < 4)
					{
						Array.Copy(bytes, byteIndex, leftOver,
								   leftOverLen, byteCount);
						leftOverLen += byteCount;
						return 0;
					}
					Array.Copy(bytes, byteIndex, leftOver, leftOverLen,
							   4 - leftOverLen);
					value = ReadChar(byteOrder, leftOver, 0);
					if(value != (uint)0x0000FEFF)
					{
						if(value > (uint)0x0000FFFF)
						{
							if(charCount < 2)
							{
								throw new ArgumentException
									(_("Arg_InsufficientSpace"));
							}
							value -= (uint)0x10000;
							chars[charIndex++] =
								(char)((value >> 10) + (uint)0xD800);
							chars[charIndex++] =
								(char)((value & (uint)0x03FF) + (uint)0xDC00);
							charCount -= 2;
						}
						else
						{
							if(charCount < 1)
							{
								throw new ArgumentException
									(_("Arg_InsufficientSpace"));
							}
							chars[charIndex++] = (char)value;
							--charCount;
						}
					}
					byteIndex += 4 - leftOverLen;
					byteCount -= 4 - leftOverLen;
					leftOverLen = 0;
				}

				// Handle the main buffer contents.
				while(byteCount >= 4)
				{
					value = ReadChar(byteOrder, bytes, byteIndex);
					if(value != (uint)0x0000FEFF)
					{
						if(value > (uint)0x0000FFFF)
						{
							if(charCount < 2)
							{
								throw new ArgumentException
									(_("Arg_InsufficientSpace"));
							}
							value -= (uint)0x10000;
							chars[charIndex++] =
								(char)((value >> 10) + (uint)0xD800);
							chars[charIndex++] =
								(char)((value & (uint)0x03FF) + (uint)0xDC00);
							charCount -= 2;
						}
						else
						{
							if(charCount < 1)
							{
								throw new ArgumentException
									(_("Arg_InsufficientSpace"));
							}
							chars[charIndex++] = (char)value;
							--charCount;
						}
					}
					byteIndex += 4;
					byteCount -= 4;
				}
				if(byteCount > 0)
				{
					Array.Copy(bytes, byteIndex, leftOver, 0, byteCount);
					leftOverLen = byteCount;
				}
				return charIndex - start;
			}

	// Get the characters that result from decoding a byte buffer.
	public override int GetChars(byte[] bytes, int byteIndex, int byteCount,
								 char[] chars, int charIndex)
			{
				int leftOverLen = 0;
				return InternalGetChars(byteOrder, null, ref leftOverLen,
									    bytes, byteIndex, byteCount,
										chars, charIndex);
			}

	// Decode a buffer of bytes into a string.
	public override String GetString(byte[] bytes, int index, int count)
			{
				return base.GetString(bytes, index, count);
			}

	// Get the maximum number of bytes needed to encode a
	// specified number of characters.
	public override int GetMaxByteCount(int charCount)
			{
				if(charCount < 0)
				{
					throw new ArgumentOutOfRangeException
						("charCount", _("ArgRange_NonNegative"));
				}
				return charCount * 4;
			}

	// Get the maximum number of characters needed to decode a
	// specified number of bytes.
	public override int GetMaxCharCount(int byteCount)
			{
				if(byteCount < 0)
				{
					throw new ArgumentOutOfRangeException
						("byteCount", _("ArgRange_NonNegative"));
				}
				// We may need to account for surrogate pairs,
				// so use / 2 rather than / 4.
				return byteCount / 2;
			}

	// Get a UCS4-specific encoder that is attached to this instance.
	public override Encoder GetEncoder()
			{
				return base.GetEncoder();
			}

	// Get a UCS4-specific decoder that is attached to this instance.
	public override Decoder GetDecoder()
			{
				return new UCS4Decoder(byteOrder);
			}

	// Get the UCS4 preamble.
	public override byte[] GetPreamble()
			{
				if(!byteOrderMark)
				{
					return new byte [0];
				}
				byte[] preamble = new byte[4];
				switch(byteOrder)
				{
					case ByteOrder.Order_1234:
					{
						preamble[0] = (byte)0x00;
						preamble[1] = (byte)0x00;
						preamble[2] = (byte)0xFE;
						preamble[3] = (byte)0xFF;
					}
					break;

					case ByteOrder.Order_4321:
					{
						preamble[0] = (byte)0xFF;
						preamble[1] = (byte)0xFE;
						preamble[2] = (byte)0x00;
						preamble[3] = (byte)0x00;
					}
					break;

					case ByteOrder.Order_3412:
					{
						preamble[0] = (byte)0xFE;
						preamble[1] = (byte)0xFF;
						preamble[2] = (byte)0x00;
						preamble[3] = (byte)0x00;
					}
					break;

					case ByteOrder.Order_2143:
					{
						preamble[0] = (byte)0x00;
						preamble[1] = (byte)0x00;
						preamble[2] = (byte)0xFF;
						preamble[3] = (byte)0xFE;
					}
					break;
				}
				return preamble;
			}

	// Determine if this object is equal to another.
	public override bool Equals(Object value)
			{
				UTF32Encoding enc = (value as UTF32Encoding);
				if(enc != null)
				{
					return (byteOrder == enc.byteOrder);
				}
				else
				{
					return false;
				}
			}

	// Get the hash code for this object.
	public override int GetHashCode()
			{
				return base.GetHashCode();
			}

#if !ECMA_COMPAT

	// Get the mail body name for this encoding.
	internal override String InternalBodyName
			{
				get
				{
					switch(byteOrder)
					{
						case ByteOrder.Order_1234:
							return "ucs-4-be";

						case ByteOrder.Order_4321:
							return "ucs-4";

						case ByteOrder.Order_3412:
							return "ucs-4-3412";

						case ByteOrder.Order_2143:
							return "ucs-4-2143";
					}
					return null;
				}
			}

	// Get the human-readable name for this encoding.
	internal override String InternalEncodingName
			{
				get
				{
					switch(byteOrder)
					{
						case ByteOrder.Order_1234:
							return "Unicode (UCS-4 Big-Endian)";

						case ByteOrder.Order_4321:
							return "Unicode (UCS-4)";

						case ByteOrder.Order_3412:
							return "Unicode (UCS-4 Order 3412)";

						case ByteOrder.Order_2143:
							return "Unicode (UCS-4 Order 2143)";
					}
					return null;
				}
			}

	// Get the mail agent header name for this encoding.
	internal override String InternalHeaderName
			{
				get
				{
					return BodyName;
				}
			}

	// Determine if this encoding can be displayed in a Web browser.
	internal override bool InternalIsBrowserDisplay
			{
				get
				{
					return false;
				}
			}

	// Determine if this encoding can be saved from a Web browser.
	internal override bool InternalIsBrowserSave
			{
				get
				{
					return false;
				}
			}

	// Determine if this encoding can be displayed in a mail/news agent.
	internal override bool InternalIsMailNewsDisplay
			{
				get
				{
					return false;
				}
			}

	// Determine if this encoding can be saved from a mail/news agent.
	internal override bool InternalIsMailNewsSave
			{
				get
				{
					return false;
				}
			}

	// Get the IANA-preferred Web name for this encoding.
	internal override String InternalWebName
			{
				get
				{
					return BodyName;
				}
			}

	// Get the Windows code page represented by this object.
	internal override int InternalWindowsCodePage
			{
				get
				{
					// Use UCS-2 as the underlying "real" code page.
					if(byteOrder == ByteOrder.Order_1234)
					{
						return 1201;
					}
					else
					{
						return 1200;
					}
				}
			}

#endif // !ECMA_COMPAT

	// UCS4 decoder implementation.
	private sealed class UCS4Decoder : Decoder
	{
		// Internal state.
		private ByteOrder byteOrder;
		private byte[] buffer;
		private int bufferUsed;

		// Constructor.
		public UCS4Decoder(ByteOrder order)
				{
					byteOrder = order;
					buffer = new byte [4];
					bufferUsed = 0;
				}

		// Override inherited methods.
		public override int GetCharCount(byte[] bytes, int index, int count)
				{
					return InternalGetCharCount(byteOrder, buffer, bufferUsed,
												bytes, index, count);
				}
		public override int GetChars(byte[] bytes, int byteIndex,
									 int byteCount, char[] chars,
									 int charIndex)
				{
					return InternalGetChars(byteOrder, buffer,
											ref bufferUsed,
											bytes, byteIndex, byteCount,
											chars, charIndex);
				}

	} // class UCS4Decoder

}; // class UTF32Encoding

}; // System.Text