public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { uint num = 0; uint num1 = 0; return(UnixEncoding.InternalGetChars(bytes, byteIndex, byteCount, chars, charIndex, ref num, ref num1, true, true)); }
public override int GetMaxCharCount(int byteCount) { if (byteCount < 0) { throw new ArgumentOutOfRangeException("byteCount", UnixEncoding._("ArgRange_NonNegative")); } return(byteCount); }
// Determine if this object is equal to another. public override bool Equals(Object value) { UnixEncoding enc = (value as UnixEncoding); if (enc != null) { return(true); } else { return(false); } }
public void TestDecodingGetChars1() { UnixEncoding unixEnc = new UnixEncoding (); // 41 E2 89 A2 CE 91 2E may be decoded as "A<NOT IDENTICAL TO><ALPHA>." // see (RFC 2044) byte[] unixBytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E}; char[] UniCodeChars = unixEnc.GetChars(unixBytes); Assert.AreEqual (0x0041, UniCodeChars [0], "UTF #1"); Assert.AreEqual (0x2262, UniCodeChars [1], "UTF #2"); Assert.AreEqual (0x0391, UniCodeChars [2], "UTF #3"); Assert.AreEqual (0x002E, UniCodeChars [3], "UTF #4"); }
public void TestEncodingGetBytes1() { UnixEncoding unixEnc = new UnixEncoding (); string UniCode = "\u0041\u2262\u0391\u002E"; // "A<NOT IDENTICAL TO><ALPHA>." may be encoded as 41 E2 89 A2 CE 91 2E // see (RFC 2044) byte[] unixBytes = unixEnc.GetBytes (UniCode); Assert.AreEqual (0x41, unixBytes [0], "UTF #1"); Assert.AreEqual (0xE2, unixBytes [1], "UTF #2"); Assert.AreEqual (0x89, unixBytes [2], "UTF #3"); Assert.AreEqual (0xA2, unixBytes [3], "UTF #4"); Assert.AreEqual (0xCE, unixBytes [4], "UTF #5"); Assert.AreEqual (0x91, unixBytes [5], "UTF #6"); Assert.AreEqual (0x2E, unixBytes [6], "UTF #7"); }
private static void CopyRaw(byte[] raw, ref int next_raw, char[] chars, ref int posn, int length) { if (posn + next_raw * 2 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "chars"); } for (int i = 0; i < next_raw; i++) { int num = posn; int num1 = num; posn = num + 1; chars[num1] = UnixEncoding.EscapeByte; int num2 = posn; num1 = num2; posn = num2 + 1; chars[num1] = (char)raw[i]; } next_raw = 0; }
public void TestEncodingGetBytes2() { UnixEncoding unixEnc = new UnixEncoding (); string UniCode = "\u0048\u0069\u0020\u004D\u006F\u006D\u0020\u263A\u0021"; // "Hi Mom <WHITE SMILING FACE>!" may be encoded as 48 69 20 4D 6F 6D 20 E2 98 BA 21 // see (RFC 2044) byte[] unixBytes = new byte [11]; int ByteCnt = unixEnc.GetBytes (UniCode.ToCharArray(), 0, UniCode.Length, unixBytes, 0); Assert.AreEqual (11, ByteCnt, "UTF #1"); Assert.AreEqual (0x48, unixBytes [0], "UTF #2"); Assert.AreEqual (0x69, unixBytes [1], "UTF #3"); Assert.AreEqual (0x20, unixBytes [2], "UTF #4"); Assert.AreEqual (0x4D, unixBytes [3], "UTF #5"); Assert.AreEqual (0x6F, unixBytes [4], "UTF #6"); Assert.AreEqual (0x6D, unixBytes [5], "UTF #7"); Assert.AreEqual (0x20, unixBytes [6], "UTF #8"); Assert.AreEqual (0xE2, unixBytes [7], "UTF #9"); Assert.AreEqual (0x98, unixBytes [8], "UTF #10"); Assert.AreEqual (0xBA, unixBytes [9], "UTF #11"); Assert.AreEqual (0x21, unixBytes [10], "UTF #12"); }
public override int GetByteCount(char[] chars, int index, int count) { return(UnixEncoding.InternalGetByteCount(chars, index, count, 0, true)); }
public void Create () { unix = new UnixEncoding (); }
public void TestThrowOnInvalid () { UnixEncoding u = new UnixEncoding (); byte[] data = new byte [] { 0xC0, 0xAF }; string s = u.GetString (data); Assert.AreEqual (4, s.Length); Assert.AreEqual (0x0000, (int) s [0]); Assert.AreEqual (0xC0, (int) s [1]); Assert.AreEqual (0x0000, (int) s [2]); Assert.AreEqual (0xAF, (int) s [3]); Assert.AreEqual ("\u0000\xC0\u0000\xAF", s, "Output-TestThrowOnInvalid"); Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid"); data = new byte [] { 0x30, 0x31, 0xC0, 0xAF, 0x30, 0x32 }; s = u.GetString (data); Assert.AreEqual (8, s.Length); Assert.AreEqual (0x30, (int) s [0]); Assert.AreEqual (0x31, (int) s [1]); Assert.AreEqual (0x0000, (int) s [2]); Assert.AreEqual (0xC0, (int) s [3]); Assert.AreEqual (0x0000, (int) s [4]); Assert.AreEqual (0xAF, (int) s [5]); Assert.AreEqual (0x30, (int) s [6]); Assert.AreEqual (0x32, (int) s [7]); Assert.AreEqual ("\x30\x31\u0000\xC0\u0000\xAF\x30\x32", s, "Output-TestThrowOnInvalid2"); Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid2"); }
public override int GetCharCount(byte[] bytes, int index, int count) { return(UnixEncoding.InternalGetCharCount(bytes, index, count, 0, 0, true, true)); }
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteCount, bool flush) { int num = UnixEncoding.InternalGetBytes(chars, charIndex, charCount, bytes, byteCount, ref this.leftOver, flush); return(num); }
public override int GetByteCount(char[] chars, int index, int count, bool flush) { return(UnixEncoding.InternalGetByteCount(chars, index, count, this.leftOver, flush)); }
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return(UnixEncoding.InternalGetChars(bytes, byteIndex, byteCount, chars, charIndex, ref this.leftOverBits, ref this.leftOverCount, true, false)); }
public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) { uint num; if (s == null) { throw new ArgumentNullException("s"); } if (bytes == null) { throw new ArgumentNullException("bytes"); } if (charIndex < 0 || charIndex > s.Length) { throw new ArgumentOutOfRangeException("charIndex", UnixEncoding._("ArgRange_StringIndex")); } if (charCount < 0 || charCount > s.Length - charIndex) { throw new ArgumentOutOfRangeException("charCount", UnixEncoding._("ArgRange_StringRange")); } if (byteIndex < 0 || byteIndex > (int)bytes.Length) { throw new ArgumentOutOfRangeException("byteIndex", UnixEncoding._("ArgRange_Array")); } int length = (int)bytes.Length; int num1 = byteIndex; while (charCount > 0) { int num2 = charIndex; charIndex = num2 + 1; char chr = s[num2]; if (chr >= '\uD800' && chr <= '\uDBFF' && charCount > 1) { num = s[charIndex]; if (num < 56320 || num > 57343) { num = chr; } else { num = num - 56320 + (chr - 55296 << '\n') + 65536; charIndex++; charCount--; } } else if (chr != UnixEncoding.EscapeByte || charCount <= 1) { num = chr; } else { if (num1 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } charCount -= 2; if (charCount >= 0) { int num3 = num1; num1 = num3 + 1; int num4 = charIndex; charIndex = num4 + 1; bytes[num3] = (byte)s[num4]; } continue; } charCount--; if (num < 128) { if (num1 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num5 = num1; num1 = num5 + 1; bytes[num5] = (byte)num; } else if (num < 2048) { if (num1 + 2 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num6 = num1; num1 = num6 + 1; bytes[num6] = (byte)(192 | num >> 6); int num7 = num1; num1 = num7 + 1; bytes[num7] = (byte)(128 | num & 63); } else if (num >= 65536) { if (num1 + 4 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num8 = num1; num1 = num8 + 1; bytes[num8] = (byte)(240 | num >> 18); int num9 = num1; num1 = num9 + 1; bytes[num9] = (byte)(128 | num >> 12 & 63); int num10 = num1; num1 = num10 + 1; bytes[num10] = (byte)(128 | num >> 6 & 63); int num11 = num1; num1 = num11 + 1; bytes[num11] = (byte)(128 | num & 63); } else { if (num1 + 3 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num12 = num1; num1 = num12 + 1; bytes[num12] = (byte)(224 | num >> 12); int num13 = num1; num1 = num13 + 1; bytes[num13] = (byte)(128 | num >> 6 & 63); int num14 = num1; num1 = num14 + 1; bytes[num14] = (byte)(128 | num & 63); } } return(num1 - byteIndex); }
// bug #75065 and #73086. public void GetCharsFEFF () { byte [] data = new byte [] {0xEF, 0xBB, 0xBF}; Encoding enc = new UnixEncoding (); string s = enc.GetString (data); Assert.AreEqual (s, "\uFEFF"); Encoding utf = enc; char[] testChars = {'\uFEFF','A'}; byte[] bytes = utf.GetBytes(testChars); char[] chars = utf.GetChars(bytes); Assert.AreEqual ('\uFEFF', chars [0], "#1"); Assert.AreEqual ('A', chars [1], "#2"); }
private static int InternalGetCharCount(byte[] bytes, int index, int count, uint leftOverBits, uint leftOverCount, bool throwOnInvalid, bool flush) { if (bytes == null) { throw new ArgumentNullException("bytes"); } if (index < 0 || index > (int)bytes.Length) { throw new ArgumentOutOfRangeException("index", UnixEncoding._("ArgRange_Array")); } if (count < 0 || count > (int)bytes.Length - index) { throw new ArgumentOutOfRangeException("count", UnixEncoding._("ArgRange_Array")); } int num = 0; int num1 = 0; uint num2 = leftOverBits; uint num3 = leftOverCount & 15; uint num4 = leftOverCount >> 4 & 15; while (count > 0) { int num5 = index; index = num5 + 1; uint num6 = bytes[num5]; num++; count--; if (num4 != 0) { if ((num6 & 192) != 128) { !throwOnInvalid; if (num6 < 128) { index--; count++; num--; } num1 = num1 + num * 2; num4 = 0; num = 0; } else { num2 = num2 << 6 | num6 & 63; UInt32 num7 = num3 + 1; num3 = num7; if (num7 >= num4) { if (num2 < 65536) { bool flag = false; switch (num4) { case 2: { flag = num2 <= 127; break; } case 3: { flag = num2 <= 2047; break; } case 4: { flag = num2 <= 65535; break; } case 5: { flag = num2 <= 2097151; break; } case 6: { flag = num2 <= 67108863; break; } } if (!flag) { num1++; } else { num1 = num1 + num * 2; } } else if (num2 < 1114112) { num1 += 2; } else if (throwOnInvalid) { num1 = num1 + num * 2; } num4 = 0; num = 0; } } } else if (num6 < 128) { num1++; num = 0; } else if ((num6 & 224) == 192) { num2 = num6 & 31; num3 = 1; num4 = 2; } else if ((num6 & 240) == 224) { num2 = num6 & 15; num3 = 1; num4 = 3; } else if ((num6 & 248) == 240) { num2 = num6 & 7; num3 = 1; num4 = 4; } else if ((num6 & 252) == 248) { num2 = num6 & 3; num3 = 1; num4 = 5; } else if ((num6 & 254) != 252) { !throwOnInvalid; num1 = num1 + num * 2; num = 0; } else { num2 = num6 & 3; num3 = 1; num4 = 6; } } if (flush && num4 != 0 && throwOnInvalid) { num1 = num1 + num * 2; } return(num1); }
private static int InternalGetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, ref uint leftOver, bool flush) { uint num; if (chars == null) { throw new ArgumentNullException("chars"); } if (bytes == null) { throw new ArgumentNullException("bytes"); } if (charIndex < 0 || charIndex > (int)chars.Length) { throw new ArgumentOutOfRangeException("charIndex", UnixEncoding._("ArgRange_Array")); } if (charCount < 0 || charCount > (int)chars.Length - charIndex) { throw new ArgumentOutOfRangeException("charCount", UnixEncoding._("ArgRange_Array")); } if (byteIndex < 0 || byteIndex > (int)bytes.Length) { throw new ArgumentOutOfRangeException("byteIndex", UnixEncoding._("ArgRange_Array")); } int length = (int)bytes.Length; uint num1 = leftOver; int num2 = byteIndex; while (charCount > 0) { int num3 = charIndex; charIndex = num3 + 1; char chr = chars[num3]; charCount--; if (num1 != 0) { if (chr < '\uDC00' || chr > '\uDFFF') { num = num1; num1 = 0; charIndex--; charCount++; } else { num = (num1 - 55296 << 10) + (chr - 56320) + 65536; num1 = 0; } } else if (chr >= '\uD800' && chr <= '\uDBFF') { num1 = chr; continue; } else if (chr != UnixEncoding.EscapeByte) { num = chr; } else { if (num2 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num4 = charCount - 1; charCount = num4; if (num4 >= 0) { int num5 = num2; num2 = num5 + 1; int num6 = charIndex; charIndex = num6 + 1; bytes[num5] = (byte)chars[num6]; } continue; } if (num < 128) { if (num2 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num7 = num2; num2 = num7 + 1; bytes[num7] = (byte)num; } else if (num < 2048) { if (num2 + 2 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num8 = num2; num2 = num8 + 1; bytes[num8] = (byte)(192 | num >> 6); int num9 = num2; num2 = num9 + 1; bytes[num9] = (byte)(128 | num & 63); } else if (num >= 65536) { if (num2 + 4 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num10 = num2; num2 = num10 + 1; bytes[num10] = (byte)(240 | num >> 18); int num11 = num2; num2 = num11 + 1; bytes[num11] = (byte)(128 | num >> 12 & 63); int num12 = num2; num2 = num12 + 1; bytes[num12] = (byte)(128 | num >> 6 & 63); int num13 = num2; num2 = num13 + 1; bytes[num13] = (byte)(128 | num & 63); } else { if (num2 + 3 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num14 = num2; num2 = num14 + 1; bytes[num14] = (byte)(224 | num >> 12); int num15 = num2; num2 = num15 + 1; bytes[num15] = (byte)(128 | num >> 6 & 63); int num16 = num2; num2 = num16 + 1; bytes[num16] = (byte)(128 | num & 63); } } if (flush && num1 != 0) { if (num2 + 3 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "bytes"); } int num17 = num2; num2 = num17 + 1; bytes[num17] = (byte)(224 | num1 >> 12); int num18 = num2; num2 = num18 + 1; bytes[num18] = (byte)(128 | num1 >> 6 & 63); int num19 = num2; num2 = num19 + 1; bytes[num19] = (byte)(128 | num1 & 63); num1 = 0; } leftOver = num1; return(num2 - byteIndex); }
private static int InternalGetByteCount(char[] chars, int index, int count, uint leftOver, bool flush) { if (chars == null) { throw new ArgumentNullException("chars"); } if (index < 0 || index > (int)chars.Length) { throw new ArgumentOutOfRangeException("index", UnixEncoding._("ArgRange_Array")); } if (count < 0 || count > (int)chars.Length - index) { throw new ArgumentOutOfRangeException("count", UnixEncoding._("ArgRange_Array")); } int num = 0; uint num1 = leftOver; while (count > 0) { char chr = chars[index]; if (num1 != 0) { if (chr < '\uDC00' || chr > '\uDFFF') { num += 3; num1 = 0; continue; } else { num += 4; num1 = 0; } } else if (chr == UnixEncoding.EscapeByte && count > 1) { num++; index++; count--; } else if (chr < '\u0080') { num++; } else if (chr < '\u0800') { num += 2; } else if (chr < '\uD800' || chr > '\uDBFF') { num += 3; } else { num1 = chr; } index++; count--; } if (flush && num1 != 0) { num += 3; } return(num); }
private static int InternalGetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, ref uint leftOverBits, ref uint leftOverCount, bool throwOnInvalid, bool flush) { if (bytes == null) { throw new ArgumentNullException("bytes"); } if (chars == null) { throw new ArgumentNullException("chars"); } if (byteIndex < 0 || byteIndex > (int)bytes.Length) { throw new ArgumentOutOfRangeException("byteIndex", UnixEncoding._("ArgRange_Array")); } if (byteCount < 0 || byteCount > (int)bytes.Length - byteIndex) { throw new ArgumentOutOfRangeException("byteCount", UnixEncoding._("ArgRange_Array")); } if (charIndex < 0 || charIndex > (int)chars.Length) { throw new ArgumentOutOfRangeException("charIndex", UnixEncoding._("ArgRange_Array")); } if (charIndex == (int)chars.Length) { return(0); } byte[] numArray = new byte[6]; int num = 0; int length = (int)chars.Length; int num1 = charIndex; uint num2 = leftOverBits; uint num3 = leftOverCount & 15; uint num4 = leftOverCount >> 4 & 15; while (byteCount > 0) { int num5 = byteIndex; byteIndex = num5 + 1; uint num6 = bytes[num5]; int num7 = num; num = num7 + 1; numArray[num7] = (byte)num6; byteCount--; if (num4 != 0) { if ((num6 & 192) != 128) { !throwOnInvalid; if (num6 < 128) { byteIndex--; byteCount++; num--; } UnixEncoding.CopyRaw(numArray, ref num, chars, ref num1, length); num4 = 0; num = 0; } else { num2 = num2 << 6 | num6 & 63; UInt32 num8 = num3 + 1; num3 = num8; if (num8 >= num4) { if (num2 < 65536) { bool flag = false; switch (num4) { case 2: { flag = num2 <= 127; break; } case 3: { flag = num2 <= 2047; break; } case 4: { flag = num2 <= 65535; break; } case 5: { flag = num2 <= 2097151; break; } case 6: { flag = num2 <= 67108863; break; } } if (!flag) { if (num1 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "chars"); } int num9 = num1; num1 = num9 + 1; chars[num9] = (char)num2; } else { UnixEncoding.CopyRaw(numArray, ref num, chars, ref num1, length); } } else if (num2 < 1114112) { if (num1 + 2 > length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "chars"); } num2 -= 65536; int num10 = num1; num1 = num10 + 1; chars[num10] = (char)((num2 >> 10) + 55296); int num11 = num1; num1 = num11 + 1; chars[num11] = (char)((num2 & 1023) + 56320); } else if (throwOnInvalid) { UnixEncoding.CopyRaw(numArray, ref num, chars, ref num1, length); } num4 = 0; num = 0; } } } else if (num6 < 128) { if (num1 >= length) { throw new ArgumentException(UnixEncoding._("Arg_InsufficientSpace"), "chars"); } num = 0; int num12 = num1; num1 = num12 + 1; chars[num12] = (char)num6; } else if ((num6 & 224) == 192) { num2 = num6 & 31; num3 = 1; num4 = 2; } else if ((num6 & 240) == 224) { num2 = num6 & 15; num3 = 1; num4 = 3; } else if ((num6 & 248) == 240) { num2 = num6 & 7; num3 = 1; num4 = 4; } else if ((num6 & 252) == 248) { num2 = num6 & 3; num3 = 1; num4 = 5; } else if ((num6 & 254) != 252) { !throwOnInvalid; num = 0; int num13 = num1; num1 = num13 + 1; chars[num13] = UnixEncoding.EscapeByte; int num14 = num1; num1 = num14 + 1; chars[num14] = (char)num6; } else { num2 = num6 & 3; num3 = 1; num4 = 6; } } if (flush && num4 != 0 && throwOnInvalid) { UnixEncoding.CopyRaw(numArray, ref num, chars, ref num1, length); } leftOverBits = num2; leftOverCount = num3 | num4 << 4; return(num1 - charIndex); }
public override int GetCharCount(byte[] bytes, int index, int count) { return(UnixEncoding.InternalGetCharCount(bytes, index, count, this.leftOverBits, this.leftOverCount, true, false)); }
public void TestMaxByteCount() { UnixEncoding unixenc = new UnixEncoding (); Assert.AreEqual (200, unixenc.GetMaxByteCount(50), "UTF #1"); }
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { uint num = 0; return(UnixEncoding.InternalGetBytes(chars, charIndex, charCount, bytes, byteIndex, ref num, true)); }