mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 3.6.0

Browse Source 
Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14
This commit is contained in:
Jo Shields
2014-08-13 10:39:27 +01:00
commit a575963da9
50588 changed files with 8155799 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

478
mcs/class/I18N/West/CP10000.cs Normal file
View File

@@ -0,0 +1,478 @@
/*
* CP10000.cs - Western European (Mac) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-1275.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP10000 : ByteEncoding
{
public CP10000()
: base(10000, ToChars, "Western European (Mac)",
"macintosh", "macintosh", "macintosh",
false, false, false, false, 1252)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u00C4', '\u00C5', '\u00C7', '\u00C9',
'\u00D1', '\u00D6', '\u00DC', '\u00E1', '\u00E0', '\u00E2',
'\u00E4', '\u00E3', '\u00E5', '\u00E7', '\u00E9', '\u00E8',
'\u00EA', '\u00EB', '\u00ED', '\u00EC', '\u00EE', '\u00EF',
'\u00F1', '\u00F3', '\u00F2', '\u00F4', '\u00F6', '\u00F5',
'\u00FA', '\u00F9', '\u00FB', '\u00FC', '\u2020', '\u00B0',
'\u00A2', '\u00A3', '\u00A7', '\u2022', '\u00B6', '\u00DF',
'\u00AE', '\u00A9', '\u2122', '\u00B4', '\u00A8', '\u2260',
'\u00C6', '\u00D8', '\u221E', '\u00B1', '\u2264', '\u2265',
'\u00A5', '\u00B5', '\u2202', '\u2211', '\u220F', '\u03C0',
'\u222B', '\u00AA', '\u00BA', '\u2126', '\u00E6', '\u00F8',
'\u00BF', '\u00A1', '\u00AC', '\u221A', '\u0192', '\u2248',
'\u2206', '\u00AB', '\u00BB', '\u2026', '\u00A0', '\u00C0',
'\u00C3', '\u00D5', '\u0152', '\u0153', '\u2013', '\u2014',
'\u201C', '\u201D', '\u2018', '\u2019', '\u00F7', '\u25CA',
'\u00FF', '\u0178', '\u2044', '\u00A4', '\u2039', '\u203A',
'\uFB01', '\uFB02', '\u2021', '\u00B7', '\u201A', '\u201E',
'\u2030', '\u00C2', '\u00CA', '\u00C1', '\u00CB', '\u00C8',
'\u00CD', '\u00CE', '\u00CF', '\u00CC', '\u00D3', '\u00D4',
'\uF8FF', '\u00D2', '\u00DA', '\u00DB', '\u00D9', '\u0131',
'\u02C6', '\u02DC', '\u00AF', '\u02D8', '\u02D9', '\u02DA',
'\u00B8', '\u02DD', '\u02DB', '\u02C7',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 128) switch(ch)
{
case 0x00A2:
case 0x00A3:
case 0x00A9:
case 0x00B1:
case 0x00B5:
break;
case 0x00A0: ch = 0xCA; break;
case 0x00A1: ch = 0xC1; break;
case 0x00A4: ch = 0xDB; break;
case 0x00A5: ch = 0xB4; break;
case 0x00A7: ch = 0xA4; break;
case 0x00A8: ch = 0xAC; break;
case 0x00AA: ch = 0xBB; break;
case 0x00AB: ch = 0xC7; break;
case 0x00AC: ch = 0xC2; break;
case 0x00AE: ch = 0xA8; break;
case 0x00AF: ch = 0xF8; break;
case 0x00B0: ch = 0xA1; break;
case 0x00B4: ch = 0xAB; break;
case 0x00B6: ch = 0xA6; break;
case 0x00B7: ch = 0xE1; break;
case 0x00B8: ch = 0xFC; break;
case 0x00BA: ch = 0xBC; break;
case 0x00BB: ch = 0xC8; break;
case 0x00BF: ch = 0xC0; break;
case 0x00C0: ch = 0xCB; break;
case 0x00C1: ch = 0xE7; break;
case 0x00C2: ch = 0xE5; break;
case 0x00C3: ch = 0xCC; break;
case 0x00C4: ch = 0x80; break;
case 0x00C5: ch = 0x81; break;
case 0x00C6: ch = 0xAE; break;
case 0x00C7: ch = 0x82; break;
case 0x00C8: ch = 0xE9; break;
case 0x00C9: ch = 0x83; break;
case 0x00CA: ch = 0xE6; break;
case 0x00CB: ch = 0xE8; break;
case 0x00CC: ch = 0xED; break;
case 0x00CD: ch = 0xEA; break;
case 0x00CE: ch = 0xEB; break;
case 0x00CF: ch = 0xEC; break;
case 0x00D1: ch = 0x84; break;
case 0x00D2: ch = 0xF1; break;
case 0x00D3: ch = 0xEE; break;
case 0x00D4: ch = 0xEF; break;
case 0x00D5: ch = 0xCD; break;
case 0x00D6: ch = 0x85; break;
case 0x00D8: ch = 0xAF; break;
case 0x00D9: ch = 0xF4; break;
case 0x00DA: ch = 0xF2; break;
case 0x00DB: ch = 0xF3; break;
case 0x00DC: ch = 0x86; break;
case 0x00DF: ch = 0xA7; break;
case 0x00E0: ch = 0x88; break;
case 0x00E1: ch = 0x87; break;
case 0x00E2: ch = 0x89; break;
case 0x00E3: ch = 0x8B; break;
case 0x00E4: ch = 0x8A; break;
case 0x00E5: ch = 0x8C; break;
case 0x00E6: ch = 0xBE; break;
case 0x00E7: ch = 0x8D; break;
case 0x00E8: ch = 0x8F; break;
case 0x00E9: ch = 0x8E; break;
case 0x00EA: ch = 0x90; break;
case 0x00EB: ch = 0x91; break;
case 0x00EC: ch = 0x93; break;
case 0x00ED: ch = 0x92; break;
case 0x00EE: ch = 0x94; break;
case 0x00EF: ch = 0x95; break;
case 0x00F1: ch = 0x96; break;
case 0x00F2: ch = 0x98; break;
case 0x00F3: ch = 0x97; break;
case 0x00F4: ch = 0x99; break;
case 0x00F5: ch = 0x9B; break;
case 0x00F6: ch = 0x9A; break;
case 0x00F7: ch = 0xD6; break;
case 0x00F8: ch = 0xBF; break;
case 0x00F9: ch = 0x9D; break;
case 0x00FA: ch = 0x9C; break;
case 0x00FB: ch = 0x9E; break;
case 0x00FC: ch = 0x9F; break;
case 0x00FF: ch = 0xD8; break;
case 0x0131: ch = 0xF5; break;
case 0x0152: ch = 0xCE; break;
case 0x0153: ch = 0xCF; break;
case 0x0178: ch = 0xD9; break;
case 0x0192: ch = 0xC4; break;
case 0x02C6: ch = 0xF6; break;
case 0x02C7: ch = 0xFF; break;
case 0x02D8: ch = 0xF9; break;
case 0x02D9: ch = 0xFA; break;
case 0x02DA: ch = 0xFB; break;
case 0x02DB: ch = 0xFE; break;
case 0x02DC: ch = 0xF7; break;
case 0x02DD: ch = 0xFD; break;
case 0x03C0: ch = 0xB9; break;
case 0x2013: ch = 0xD0; break;
case 0x2014: ch = 0xD1; break;
case 0x2018: ch = 0xD4; break;
case 0x2019: ch = 0xD5; break;
case 0x201A: ch = 0xE2; break;
case 0x201C: ch = 0xD2; break;
case 0x201D: ch = 0xD3; break;
case 0x201E: ch = 0xE3; break;
case 0x2020: ch = 0xA0; break;
case 0x2021: ch = 0xE0; break;
case 0x2022: ch = 0xA5; break;
case 0x2026: ch = 0xC9; break;
case 0x2030: ch = 0xE4; break;
case 0x2039: ch = 0xDC; break;
case 0x203A: ch = 0xDD; break;
case 0x2044: ch = 0xDA; break;
case 0x2122: ch = 0xAA; break;
case 0x2126: ch = 0xBD; break;
case 0x2202: ch = 0xB6; break;
case 0x2206: ch = 0xC6; break;
case 0x220F: ch = 0xB8; break;
case 0x2211: ch = 0xB7; break;
case 0x221A: ch = 0xC3; break;
case 0x221E: ch = 0xB0; break;
case 0x222B: ch = 0xBA; break;
case 0x2248: ch = 0xC5; break;
case 0x2260: ch = 0xAD; break;
case 0x2264: ch = 0xB2; break;
case 0x2265: ch = 0xB3; break;
case 0x2318: ch = 0x11; break;
case 0x25CA: ch = 0xD7; break;
case 0x2666: ch = 0x13; break;
case 0x2713: ch = 0x12; break;
case 0xF8FF: ch = 0xF0; break;
case 0xFB01: ch = 0xDE; break;
case 0xFB02: ch = 0xDF; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 128) switch(ch)
{
case 0x00A2:
case 0x00A3:
case 0x00A9:
case 0x00B1:
case 0x00B5:
break;
case 0x00A0: ch = 0xCA; break;
case 0x00A1: ch = 0xC1; break;
case 0x00A4: ch = 0xDB; break;
case 0x00A5: ch = 0xB4; break;
case 0x00A7: ch = 0xA4; break;
case 0x00A8: ch = 0xAC; break;
case 0x00AA: ch = 0xBB; break;
case 0x00AB: ch = 0xC7; break;
case 0x00AC: ch = 0xC2; break;
case 0x00AE: ch = 0xA8; break;
case 0x00AF: ch = 0xF8; break;
case 0x00B0: ch = 0xA1; break;
case 0x00B4: ch = 0xAB; break;
case 0x00B6: ch = 0xA6; break;
case 0x00B7: ch = 0xE1; break;
case 0x00B8: ch = 0xFC; break;
case 0x00BA: ch = 0xBC; break;
case 0x00BB: ch = 0xC8; break;
case 0x00BF: ch = 0xC0; break;
case 0x00C0: ch = 0xCB; break;
case 0x00C1: ch = 0xE7; break;
case 0x00C2: ch = 0xE5; break;
case 0x00C3: ch = 0xCC; break;
case 0x00C4: ch = 0x80; break;
case 0x00C5: ch = 0x81; break;
case 0x00C6: ch = 0xAE; break;
case 0x00C7: ch = 0x82; break;
case 0x00C8: ch = 0xE9; break;
case 0x00C9: ch = 0x83; break;
case 0x00CA: ch = 0xE6; break;
case 0x00CB: ch = 0xE8; break;
case 0x00CC: ch = 0xED; break;
case 0x00CD: ch = 0xEA; break;
case 0x00CE: ch = 0xEB; break;
case 0x00CF: ch = 0xEC; break;
case 0x00D1: ch = 0x84; break;
case 0x00D2: ch = 0xF1; break;
case 0x00D3: ch = 0xEE; break;
case 0x00D4: ch = 0xEF; break;
case 0x00D5: ch = 0xCD; break;
case 0x00D6: ch = 0x85; break;
case 0x00D8: ch = 0xAF; break;
case 0x00D9: ch = 0xF4; break;
case 0x00DA: ch = 0xF2; break;
case 0x00DB: ch = 0xF3; break;
case 0x00DC: ch = 0x86; break;
case 0x00DF: ch = 0xA7; break;
case 0x00E0: ch = 0x88; break;
case 0x00E1: ch = 0x87; break;
case 0x00E2: ch = 0x89; break;
case 0x00E3: ch = 0x8B; break;
case 0x00E4: ch = 0x8A; break;
case 0x00E5: ch = 0x8C; break;
case 0x00E6: ch = 0xBE; break;
case 0x00E7: ch = 0x8D; break;
case 0x00E8: ch = 0x8F; break;
case 0x00E9: ch = 0x8E; break;
case 0x00EA: ch = 0x90; break;
case 0x00EB: ch = 0x91; break;
case 0x00EC: ch = 0x93; break;
case 0x00ED: ch = 0x92; break;
case 0x00EE: ch = 0x94; break;
case 0x00EF: ch = 0x95; break;
case 0x00F1: ch = 0x96; break;
case 0x00F2: ch = 0x98; break;
case 0x00F3: ch = 0x97; break;
case 0x00F4: ch = 0x99; break;
case 0x00F5: ch = 0x9B; break;
case 0x00F6: ch = 0x9A; break;
case 0x00F7: ch = 0xD6; break;
case 0x00F8: ch = 0xBF; break;
case 0x00F9: ch = 0x9D; break;
case 0x00FA: ch = 0x9C; break;
case 0x00FB: ch = 0x9E; break;
case 0x00FC: ch = 0x9F; break;
case 0x00FF: ch = 0xD8; break;
case 0x0131: ch = 0xF5; break;
case 0x0152: ch = 0xCE; break;
case 0x0153: ch = 0xCF; break;
case 0x0178: ch = 0xD9; break;
case 0x0192: ch = 0xC4; break;
case 0x02C6: ch = 0xF6; break;
case 0x02C7: ch = 0xFF; break;
case 0x02D8: ch = 0xF9; break;
case 0x02D9: ch = 0xFA; break;
case 0x02DA: ch = 0xFB; break;
case 0x02DB: ch = 0xFE; break;
case 0x02DC: ch = 0xF7; break;
case 0x02DD: ch = 0xFD; break;
case 0x03C0: ch = 0xB9; break;
case 0x2013: ch = 0xD0; break;
case 0x2014: ch = 0xD1; break;
case 0x2018: ch = 0xD4; break;
case 0x2019: ch = 0xD5; break;
case 0x201A: ch = 0xE2; break;
case 0x201C: ch = 0xD2; break;
case 0x201D: ch = 0xD3; break;
case 0x201E: ch = 0xE3; break;
case 0x2020: ch = 0xA0; break;
case 0x2021: ch = 0xE0; break;
case 0x2022: ch = 0xA5; break;
case 0x2026: ch = 0xC9; break;
case 0x2030: ch = 0xE4; break;
case 0x2039: ch = 0xDC; break;
case 0x203A: ch = 0xDD; break;
case 0x2044: ch = 0xDA; break;
case 0x2122: ch = 0xAA; break;
case 0x2126: ch = 0xBD; break;
case 0x2202: ch = 0xB6; break;
case 0x2206: ch = 0xC6; break;
case 0x220F: ch = 0xB8; break;
case 0x2211: ch = 0xB7; break;
case 0x221A: ch = 0xC3; break;
case 0x221E: ch = 0xB0; break;
case 0x222B: ch = 0xBA; break;
case 0x2248: ch = 0xC5; break;
case 0x2260: ch = 0xAD; break;
case 0x2264: ch = 0xB2; break;
case 0x2265: ch = 0xB3; break;
case 0x2318: ch = 0x11; break;
case 0x25CA: ch = 0xD7; break;
case 0x2666: ch = 0x13; break;
case 0x2713: ch = 0x12; break;
case 0xF8FF: ch = 0xF0; break;
case 0xFB01: ch = 0xDE; break;
case 0xFB02: ch = 0xDF; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP10000
[Serializable]
public class ENCmacintosh : CP10000
{
public ENCmacintosh() : base() {}
}; // class ENCmacintosh
}; // namespace I18N.West

451
mcs/class/I18N/West/CP10079.cs Normal file
View File

@@ -0,0 +1,451 @@
/*
* CP10079.cs - Icelandic (Mac) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "windows-10079-2000.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP10079 : ByteEncoding
{
public CP10079()
: base(10079, ToChars, "Icelandic (Mac)",
"x-mac-icelandic", "x-mac-icelandic", "x-mac-icelandic",
false, false, false, false, 1252)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u00C4', '\u00C5', '\u00C7', '\u00C9',
'\u00D1', '\u00D6', '\u00DC', '\u00E1', '\u00E0', '\u00E2',
'\u00E4', '\u00E3', '\u00E5', '\u00E7', '\u00E9', '\u00E8',
'\u00EA', '\u00EB', '\u00ED', '\u00EC', '\u00EE', '\u00EF',
'\u00F1', '\u00F3', '\u00F2', '\u00F4', '\u00F6', '\u00F5',
'\u00FA', '\u00F9', '\u00FB', '\u00FC', '\u00DD', '\u00B0',
'\u00A2', '\u00A3', '\u00A7', '\u2022', '\u00B6', '\u00DF',
'\u00AE', '\u00A9', '\u2122', '\u00B4', '\u00A8', '\u2260',
'\u00C6', '\u00D8', '\u221E', '\u00B1', '\u2264', '\u2265',
'\u00A5', '\u00B5', '\u2202', '\u2211', '\u220F', '\u03C0',
'\u222B', '\u00AA', '\u00BA', '\u2126', '\u00E6', '\u00F8',
'\u00BF', '\u00A1', '\u00AC', '\u221A', '\u0192', '\u2248',
'\u2206', '\u00AB', '\u00BB', '\u2026', '\u00A0', '\u00C0',
'\u00C3', '\u00D5', '\u0152', '\u0153', '\u2013', '\u2014',
'\u201C', '\u201D', '\u2018', '\u2019', '\u00F7', '\u25CA',
'\u00FF', '\u0178', '\u2044', '\u00A4', '\u00D0', '\u00F0',
'\u00DE', '\u00FE', '\u00FD', '\u00B7', '\u201A', '\u201E',
'\u2030', '\u00C2', '\u00CA', '\u00C1', '\u00CB', '\u00C8',
'\u00CD', '\u00CE', '\u00CF', '\u00CC', '\u00D3', '\u00D4',
'\uF8FF', '\u00D2', '\u00DA', '\u00DB', '\u00D9', '\u0131',
'\u02C6', '\u02DC', '\u00AF', '\u02D8', '\u02D9', '\u02DA',
'\u00B8', '\u02DD', '\u02DB', '\u02C7',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 128) switch(ch)
{
case 0x00A2:
case 0x00A3:
case 0x00A9:
case 0x00B1:
case 0x00B5:
case 0x00DE:
break;
case 0x00A0: ch = 0xCA; break;
case 0x00A1: ch = 0xC1; break;
case 0x00A4: ch = 0xDB; break;
case 0x00A5: ch = 0xB4; break;
case 0x00A7: ch = 0xA4; break;
case 0x00A8: ch = 0xAC; break;
case 0x00AA: ch = 0xBB; break;
case 0x00AB: ch = 0xC7; break;
case 0x00AC: ch = 0xC2; break;
case 0x00AE: ch = 0xA8; break;
case 0x00AF: ch = 0xF8; break;
case 0x00B0: ch = 0xA1; break;
case 0x00B4: ch = 0xAB; break;
case 0x00B6: ch = 0xA6; break;
case 0x00B7: ch = 0xE1; break;
case 0x00B8: ch = 0xFC; break;
case 0x00BA: ch = 0xBC; break;
case 0x00BB: ch = 0xC8; break;
case 0x00BF: ch = 0xC0; break;
case 0x00C0: ch = 0xCB; break;
case 0x00C1: ch = 0xE7; break;
case 0x00C2: ch = 0xE5; break;
case 0x00C3: ch = 0xCC; break;
case 0x00C4: ch = 0x80; break;
case 0x00C5: ch = 0x81; break;
case 0x00C6: ch = 0xAE; break;
case 0x00C7: ch = 0x82; break;
case 0x00C8: ch = 0xE9; break;
case 0x00C9: ch = 0x83; break;
case 0x00CA: ch = 0xE6; break;
case 0x00CB: ch = 0xE8; break;
case 0x00CC: ch = 0xED; break;
case 0x00CD: ch = 0xEA; break;
case 0x00CE: ch = 0xEB; break;
case 0x00CF: ch = 0xEC; break;
case 0x00D0: ch = 0xDC; break;
case 0x00D1: ch = 0x84; break;
case 0x00D2: ch = 0xF1; break;
case 0x00D3: ch = 0xEE; break;
case 0x00D4: ch = 0xEF; break;
case 0x00D5: ch = 0xCD; break;
case 0x00D6: ch = 0x85; break;
case 0x00D8: ch = 0xAF; break;
case 0x00D9: ch = 0xF4; break;
case 0x00DA: ch = 0xF2; break;
case 0x00DB: ch = 0xF3; break;
case 0x00DC: ch = 0x86; break;
case 0x00DD: ch = 0xA0; break;
case 0x00DF: ch = 0xA7; break;
case 0x00E0: ch = 0x88; break;
case 0x00E1: ch = 0x87; break;
case 0x00E2: ch = 0x89; break;
case 0x00E3: ch = 0x8B; break;
case 0x00E4: ch = 0x8A; break;
case 0x00E5: ch = 0x8C; break;
case 0x00E6: ch = 0xBE; break;
case 0x00E7: ch = 0x8D; break;
case 0x00E8: ch = 0x8F; break;
case 0x00E9: ch = 0x8E; break;
case 0x00EA: ch = 0x90; break;
case 0x00EB: ch = 0x91; break;
case 0x00EC: ch = 0x93; break;
case 0x00ED: ch = 0x92; break;
case 0x00EE: ch = 0x94; break;
case 0x00EF: ch = 0x95; break;
case 0x00F0: ch = 0xDD; break;
case 0x00F1: ch = 0x96; break;
case 0x00F2: ch = 0x98; break;
case 0x00F3: ch = 0x97; break;
case 0x00F4: ch = 0x99; break;
case 0x00F5: ch = 0x9B; break;
case 0x00F6: ch = 0x9A; break;
case 0x00F7: ch = 0xD6; break;
case 0x00F8: ch = 0xBF; break;
case 0x00F9: ch = 0x9D; break;
case 0x00FA: ch = 0x9C; break;
case 0x00FB: ch = 0x9E; break;
case 0x00FC: ch = 0x9F; break;
case 0x00FD: ch = 0xE0; break;
case 0x00FE: ch = 0xDF; break;
case 0x00FF: ch = 0xD8; break;
case 0x0131: ch = 0xF5; break;
case 0x0152: ch = 0xCE; break;
case 0x0153: ch = 0xCF; break;
case 0x0178: ch = 0xD9; break;
case 0x0192: ch = 0xC4; break;
case 0x02C6: ch = 0xF6; break;
case 0x02C7: ch = 0xFF; break;
case 0x02D8: ch = 0xF9; break;
case 0x02D9: ch = 0xFA; break;
case 0x02DA: ch = 0xFB; break;
case 0x02DB: ch = 0xFE; break;
case 0x02DC: ch = 0xF7; break;
case 0x02DD: ch = 0xFD; break;
case 0x03C0: ch = 0xB9; break;
case 0x2013: ch = 0xD0; break;
case 0x2014: ch = 0xD1; break;
case 0x2018: ch = 0xD4; break;
case 0x2019: ch = 0xD5; break;
case 0x201A: ch = 0xE2; break;
case 0x201C: ch = 0xD2; break;
case 0x201D: ch = 0xD3; break;
case 0x201E: ch = 0xE3; break;
case 0x2022: ch = 0xA5; break;
case 0x2026: ch = 0xC9; break;
case 0x2030: ch = 0xE4; break;
case 0x2044: ch = 0xDA; break;
case 0x2122: ch = 0xAA; break;
case 0x2126: ch = 0xBD; break;
case 0x2202: ch = 0xB6; break;
case 0x2206: ch = 0xC6; break;
case 0x220F: ch = 0xB8; break;
case 0x2211: ch = 0xB7; break;
case 0x221A: ch = 0xC3; break;
case 0x221E: ch = 0xB0; break;
case 0x222B: ch = 0xBA; break;
case 0x2248: ch = 0xC5; break;
case 0x2260: ch = 0xAD; break;
case 0x2264: ch = 0xB2; break;
case 0x2265: ch = 0xB3; break;
case 0x25CA: ch = 0xD7; break;
case 0xF8FF: ch = 0xF0; break;
default:
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 128) switch(ch)
{
case 0x00A2:
case 0x00A3:
case 0x00A9:
case 0x00B1:
case 0x00B5:
case 0x00DE:
break;
case 0x00A0: ch = 0xCA; break;
case 0x00A1: ch = 0xC1; break;
case 0x00A4: ch = 0xDB; break;
case 0x00A5: ch = 0xB4; break;
case 0x00A7: ch = 0xA4; break;
case 0x00A8: ch = 0xAC; break;
case 0x00AA: ch = 0xBB; break;
case 0x00AB: ch = 0xC7; break;
case 0x00AC: ch = 0xC2; break;
case 0x00AE: ch = 0xA8; break;
case 0x00AF: ch = 0xF8; break;
case 0x00B0: ch = 0xA1; break;
case 0x00B4: ch = 0xAB; break;
case 0x00B6: ch = 0xA6; break;
case 0x00B7: ch = 0xE1; break;
case 0x00B8: ch = 0xFC; break;
case 0x00BA: ch = 0xBC; break;
case 0x00BB: ch = 0xC8; break;
case 0x00BF: ch = 0xC0; break;
case 0x00C0: ch = 0xCB; break;
case 0x00C1: ch = 0xE7; break;
case 0x00C2: ch = 0xE5; break;
case 0x00C3: ch = 0xCC; break;
case 0x00C4: ch = 0x80; break;
case 0x00C5: ch = 0x81; break;
case 0x00C6: ch = 0xAE; break;
case 0x00C7: ch = 0x82; break;
case 0x00C8: ch = 0xE9; break;
case 0x00C9: ch = 0x83; break;
case 0x00CA: ch = 0xE6; break;
case 0x00CB: ch = 0xE8; break;
case 0x00CC: ch = 0xED; break;
case 0x00CD: ch = 0xEA; break;
case 0x00CE: ch = 0xEB; break;
case 0x00CF: ch = 0xEC; break;
case 0x00D0: ch = 0xDC; break;
case 0x00D1: ch = 0x84; break;
case 0x00D2: ch = 0xF1; break;
case 0x00D3: ch = 0xEE; break;
case 0x00D4: ch = 0xEF; break;
case 0x00D5: ch = 0xCD; break;
case 0x00D6: ch = 0x85; break;
case 0x00D8: ch = 0xAF; break;
case 0x00D9: ch = 0xF4; break;
case 0x00DA: ch = 0xF2; break;
case 0x00DB: ch = 0xF3; break;
case 0x00DC: ch = 0x86; break;
case 0x00DD: ch = 0xA0; break;
case 0x00DF: ch = 0xA7; break;
case 0x00E0: ch = 0x88; break;
case 0x00E1: ch = 0x87; break;
case 0x00E2: ch = 0x89; break;
case 0x00E3: ch = 0x8B; break;
case 0x00E4: ch = 0x8A; break;
case 0x00E5: ch = 0x8C; break;
case 0x00E6: ch = 0xBE; break;
case 0x00E7: ch = 0x8D; break;
case 0x00E8: ch = 0x8F; break;
case 0x00E9: ch = 0x8E; break;
case 0x00EA: ch = 0x90; break;
case 0x00EB: ch = 0x91; break;
case 0x00EC: ch = 0x93; break;
case 0x00ED: ch = 0x92; break;
case 0x00EE: ch = 0x94; break;
case 0x00EF: ch = 0x95; break;
case 0x00F0: ch = 0xDD; break;
case 0x00F1: ch = 0x96; break;
case 0x00F2: ch = 0x98; break;
case 0x00F3: ch = 0x97; break;
case 0x00F4: ch = 0x99; break;
case 0x00F5: ch = 0x9B; break;
case 0x00F6: ch = 0x9A; break;
case 0x00F7: ch = 0xD6; break;
case 0x00F8: ch = 0xBF; break;
case 0x00F9: ch = 0x9D; break;
case 0x00FA: ch = 0x9C; break;
case 0x00FB: ch = 0x9E; break;
case 0x00FC: ch = 0x9F; break;
case 0x00FD: ch = 0xE0; break;
case 0x00FE: ch = 0xDF; break;
case 0x00FF: ch = 0xD8; break;
case 0x0131: ch = 0xF5; break;
case 0x0152: ch = 0xCE; break;
case 0x0153: ch = 0xCF; break;
case 0x0178: ch = 0xD9; break;
case 0x0192: ch = 0xC4; break;
case 0x02C6: ch = 0xF6; break;
case 0x02C7: ch = 0xFF; break;
case 0x02D8: ch = 0xF9; break;
case 0x02D9: ch = 0xFA; break;
case 0x02DA: ch = 0xFB; break;
case 0x02DB: ch = 0xFE; break;
case 0x02DC: ch = 0xF7; break;
case 0x02DD: ch = 0xFD; break;
case 0x03C0: ch = 0xB9; break;
case 0x2013: ch = 0xD0; break;
case 0x2014: ch = 0xD1; break;
case 0x2018: ch = 0xD4; break;
case 0x2019: ch = 0xD5; break;
case 0x201A: ch = 0xE2; break;
case 0x201C: ch = 0xD2; break;
case 0x201D: ch = 0xD3; break;
case 0x201E: ch = 0xE3; break;
case 0x2022: ch = 0xA5; break;
case 0x2026: ch = 0xC9; break;
case 0x2030: ch = 0xE4; break;
case 0x2044: ch = 0xDA; break;
case 0x2122: ch = 0xAA; break;
case 0x2126: ch = 0xBD; break;
case 0x2202: ch = 0xB6; break;
case 0x2206: ch = 0xC6; break;
case 0x220F: ch = 0xB8; break;
case 0x2211: ch = 0xB7; break;
case 0x221A: ch = 0xC3; break;
case 0x221E: ch = 0xB0; break;
case 0x222B: ch = 0xBA; break;
case 0x2248: ch = 0xC5; break;
case 0x2260: ch = 0xAD; break;
case 0x2264: ch = 0xB2; break;
case 0x2265: ch = 0xB3; break;
case 0x25CA: ch = 0xD7; break;
case 0xF8FF: ch = 0xF0; break;
default: ch = 0x3F; break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP10079
[Serializable]
public class ENCx_mac_icelandic : CP10079
{
public ENCx_mac_icelandic() : base() {}
}; // class ENCx_mac_icelandic
}; // namespace I18N.West

472
mcs/class/I18N/West/CP1250.cs Normal file
View File

@@ -0,0 +1,472 @@
/*
* CP1250.cs - Central European (Windows) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-5346.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP1250 : ByteEncoding
{
public CP1250()
: base(1250, ToChars, "Central European (Windows)",
"iso-8859-2", "windows-1250", "windows-1250",
true, true, true, true, 1250)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u20AC', '\u0081', '\u201A', '\u0083',
'\u201E', '\u2026', '\u2020', '\u2021', '\u0088', '\u2030',
'\u0160', '\u2039', '\u015A', '\u0164', '\u017D', '\u0179',
'\u0090', '\u2018', '\u2019', '\u201C', '\u201D', '\u2022',
'\u2013', '\u2014', '\u0098', '\u2122', '\u0161', '\u203A',
'\u015B', '\u0165', '\u017E', '\u017A', '\u00A0', '\u02C7',
'\u02D8', '\u0141', '\u00A4', '\u0104', '\u00A6', '\u00A7',
'\u00A8', '\u00A9', '\u015E', '\u00AB', '\u00AC', '\u00AD',
'\u00AE', '\u017B', '\u00B0', '\u00B1', '\u02DB', '\u0142',
'\u00B4', '\u00B5', '\u00B6', '\u00B7', '\u00B8', '\u0105',
'\u015F', '\u00BB', '\u013D', '\u02DD', '\u013E', '\u017C',
'\u0154', '\u00C1', '\u00C2', '\u0102', '\u00C4', '\u0139',
'\u0106', '\u00C7', '\u010C', '\u00C9', '\u0118', '\u00CB',
'\u011A', '\u00CD', '\u00CE', '\u010E', '\u0110', '\u0143',
'\u0147', '\u00D3', '\u00D4', '\u0150', '\u00D6', '\u00D7',
'\u0158', '\u016E', '\u00DA', '\u0170', '\u00DC', '\u00DD',
'\u0162', '\u00DF', '\u0155', '\u00E1', '\u00E2', '\u0103',
'\u00E4', '\u013A', '\u0107', '\u00E7', '\u010D', '\u00E9',
'\u0119', '\u00EB', '\u011B', '\u00ED', '\u00EE', '\u010F',
'\u0111', '\u0144', '\u0148', '\u00F3', '\u00F4', '\u0151',
'\u00F6', '\u00F7', '\u0159', '\u016F', '\u00FA', '\u0171',
'\u00FC', '\u00FD', '\u0163', '\u02D9',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x0083:
case 0x0088:
case 0x0090:
case 0x0098:
case 0x00A0:
case 0x00A4:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00B0:
case 0x00B1:
case 0x00B4:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B8:
case 0x00BB:
case 0x00C1:
case 0x00C2:
case 0x00C4:
case 0x00C7:
case 0x00C9:
case 0x00CB:
case 0x00CD:
case 0x00CE:
case 0x00D3:
case 0x00D4:
case 0x00D6:
case 0x00D7:
case 0x00DA:
case 0x00DC:
case 0x00DD:
case 0x00DF:
case 0x00E1:
case 0x00E2:
case 0x00E4:
case 0x00E7:
case 0x00E9:
case 0x00EB:
case 0x00ED:
case 0x00EE:
case 0x00F3:
case 0x00F4:
case 0x00F6:
case 0x00F7:
case 0x00FA:
case 0x00FC:
case 0x00FD:
break;
case 0x0102: ch = 0xC3; break;
case 0x0103: ch = 0xE3; break;
case 0x0104: ch = 0xA5; break;
case 0x0105: ch = 0xB9; break;
case 0x0106: ch = 0xC6; break;
case 0x0107: ch = 0xE6; break;
case 0x010C: ch = 0xC8; break;
case 0x010D: ch = 0xE8; break;
case 0x010E: ch = 0xCF; break;
case 0x010F: ch = 0xEF; break;
case 0x0110: ch = 0xD0; break;
case 0x0111: ch = 0xF0; break;
case 0x0118: ch = 0xCA; break;
case 0x0119: ch = 0xEA; break;
case 0x011A: ch = 0xCC; break;
case 0x011B: ch = 0xEC; break;
case 0x0139: ch = 0xC5; break;
case 0x013A: ch = 0xE5; break;
case 0x013D: ch = 0xBC; break;
case 0x013E: ch = 0xBE; break;
case 0x0141: ch = 0xA3; break;
case 0x0142: ch = 0xB3; break;
case 0x0143: ch = 0xD1; break;
case 0x0144: ch = 0xF1; break;
case 0x0147: ch = 0xD2; break;
case 0x0148: ch = 0xF2; break;
case 0x0150: ch = 0xD5; break;
case 0x0151: ch = 0xF5; break;
case 0x0154: ch = 0xC0; break;
case 0x0155: ch = 0xE0; break;
case 0x0158: ch = 0xD8; break;
case 0x0159: ch = 0xF8; break;
case 0x015A: ch = 0x8C; break;
case 0x015B: ch = 0x9C; break;
case 0x015E: ch = 0xAA; break;
case 0x015F: ch = 0xBA; break;
case 0x0160: ch = 0x8A; break;
case 0x0161: ch = 0x9A; break;
case 0x0162: ch = 0xDE; break;
case 0x0163: ch = 0xFE; break;
case 0x0164: ch = 0x8D; break;
case 0x0165: ch = 0x9D; break;
case 0x016E: ch = 0xD9; break;
case 0x016F: ch = 0xF9; break;
case 0x0170: ch = 0xDB; break;
case 0x0171: ch = 0xFB; break;
case 0x0179: ch = 0x8F; break;
case 0x017A: ch = 0x9F; break;
case 0x017B: ch = 0xAF; break;
case 0x017C: ch = 0xBF; break;
case 0x017D: ch = 0x8E; break;
case 0x017E: ch = 0x9E; break;
case 0x02C7: ch = 0xA1; break;
case 0x02D8: ch = 0xA2; break;
case 0x02D9: ch = 0xFF; break;
case 0x02DB: ch = 0xB2; break;
case 0x02DD: ch = 0xBD; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x0083:
case 0x0088:
case 0x0090:
case 0x0098:
case 0x00A0:
case 0x00A4:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00B0:
case 0x00B1:
case 0x00B4:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B8:
case 0x00BB:
case 0x00C1:
case 0x00C2:
case 0x00C4:
case 0x00C7:
case 0x00C9:
case 0x00CB:
case 0x00CD:
case 0x00CE:
case 0x00D3:
case 0x00D4:
case 0x00D6:
case 0x00D7:
case 0x00DA:
case 0x00DC:
case 0x00DD:
case 0x00DF:
case 0x00E1:
case 0x00E2:
case 0x00E4:
case 0x00E7:
case 0x00E9:
case 0x00EB:
case 0x00ED:
case 0x00EE:
case 0x00F3:
case 0x00F4:
case 0x00F6:
case 0x00F7:
case 0x00FA:
case 0x00FC:
case 0x00FD:
break;
case 0x0102: ch = 0xC3; break;
case 0x0103: ch = 0xE3; break;
case 0x0104: ch = 0xA5; break;
case 0x0105: ch = 0xB9; break;
case 0x0106: ch = 0xC6; break;
case 0x0107: ch = 0xE6; break;
case 0x010C: ch = 0xC8; break;
case 0x010D: ch = 0xE8; break;
case 0x010E: ch = 0xCF; break;
case 0x010F: ch = 0xEF; break;
case 0x0110: ch = 0xD0; break;
case 0x0111: ch = 0xF0; break;
case 0x0118: ch = 0xCA; break;
case 0x0119: ch = 0xEA; break;
case 0x011A: ch = 0xCC; break;
case 0x011B: ch = 0xEC; break;
case 0x0139: ch = 0xC5; break;
case 0x013A: ch = 0xE5; break;
case 0x013D: ch = 0xBC; break;
case 0x013E: ch = 0xBE; break;
case 0x0141: ch = 0xA3; break;
case 0x0142: ch = 0xB3; break;
case 0x0143: ch = 0xD1; break;
case 0x0144: ch = 0xF1; break;
case 0x0147: ch = 0xD2; break;
case 0x0148: ch = 0xF2; break;
case 0x0150: ch = 0xD5; break;
case 0x0151: ch = 0xF5; break;
case 0x0154: ch = 0xC0; break;
case 0x0155: ch = 0xE0; break;
case 0x0158: ch = 0xD8; break;
case 0x0159: ch = 0xF8; break;
case 0x015A: ch = 0x8C; break;
case 0x015B: ch = 0x9C; break;
case 0x015E: ch = 0xAA; break;
case 0x015F: ch = 0xBA; break;
case 0x0160: ch = 0x8A; break;
case 0x0161: ch = 0x9A; break;
case 0x0162: ch = 0xDE; break;
case 0x0163: ch = 0xFE; break;
case 0x0164: ch = 0x8D; break;
case 0x0165: ch = 0x9D; break;
case 0x016E: ch = 0xD9; break;
case 0x016F: ch = 0xF9; break;
case 0x0170: ch = 0xDB; break;
case 0x0171: ch = 0xFB; break;
case 0x0179: ch = 0x8F; break;
case 0x017A: ch = 0x9F; break;
case 0x017B: ch = 0xAF; break;
case 0x017C: ch = 0xBF; break;
case 0x017D: ch = 0x8E; break;
case 0x017E: ch = 0x9E; break;
case 0x02C7: ch = 0xA1; break;
case 0x02D8: ch = 0xA2; break;
case 0x02D9: ch = 0xFF; break;
case 0x02DB: ch = 0xB2; break;
case 0x02DD: ch = 0xBD; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP1250
[Serializable]
public class ENCwindows_1250 : CP1250
{
public ENCwindows_1250() : base() {}
}; // class ENCwindows_1250
}; // namespace I18N.West

472
mcs/class/I18N/West/CP1252.cs Normal file
View File

@@ -0,0 +1,472 @@
/*
* CP1252.cs - Western European (Windows) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-5348.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP1252 : ByteEncoding
{
public CP1252()
: base(1252, ToChars, "Western European (Windows)",
"iso-8859-1", "Windows-1252", "Windows-1252",
true, true, true, true, 1252)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u20AC', '\u0081', '\u201A', '\u0192',
'\u201E', '\u2026', '\u2020', '\u2021', '\u02C6', '\u2030',
'\u0160', '\u2039', '\u0152', '\u008D', '\u017D', '\u008F',
'\u0090', '\u2018', '\u2019', '\u201C', '\u201D', '\u2022',
'\u2013', '\u2014', '\u02DC', '\u2122', '\u0161', '\u203A',
'\u0153', '\u009D', '\u017E', '\u0178', '\u00A0', '\u00A1',
'\u00A2', '\u00A3', '\u00A4', '\u00A5', '\u00A6', '\u00A7',
'\u00A8', '\u00A9', '\u00AA', '\u00AB', '\u00AC', '\u00AD',
'\u00AE', '\u00AF', '\u00B0', '\u00B1', '\u00B2', '\u00B3',
'\u00B4', '\u00B5', '\u00B6', '\u00B7', '\u00B8', '\u00B9',
'\u00BA', '\u00BB', '\u00BC', '\u00BD', '\u00BE', '\u00BF',
'\u00C0', '\u00C1', '\u00C2', '\u00C3', '\u00C4', '\u00C5',
'\u00C6', '\u00C7', '\u00C8', '\u00C9', '\u00CA', '\u00CB',
'\u00CC', '\u00CD', '\u00CE', '\u00CF', '\u00D0', '\u00D1',
'\u00D2', '\u00D3', '\u00D4', '\u00D5', '\u00D6', '\u00D7',
'\u00D8', '\u00D9', '\u00DA', '\u00DB', '\u00DC', '\u00DD',
'\u00DE', '\u00DF', '\u00E0', '\u00E1', '\u00E2', '\u00E3',
'\u00E4', '\u00E5', '\u00E6', '\u00E7', '\u00E8', '\u00E9',
'\u00EA', '\u00EB', '\u00EC', '\u00ED', '\u00EE', '\u00EF',
'\u00F0', '\u00F1', '\u00F2', '\u00F3', '\u00F4', '\u00F5',
'\u00F6', '\u00F7', '\u00F8', '\u00F9', '\u00FA', '\u00FB',
'\u00FC', '\u00FD', '\u00FE', '\u00FF',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x008D:
case 0x008F:
case 0x0090:
case 0x009D:
case 0x00A0:
case 0x00A1:
case 0x00A2:
case 0x00A3:
case 0x00A4:
case 0x00A5:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00AF:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B8:
case 0x00B9:
case 0x00BA:
case 0x00BB:
case 0x00BC:
case 0x00BD:
case 0x00BE:
case 0x00BF:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C3:
case 0x00C4:
case 0x00C5:
case 0x00C6:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D0:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D5:
case 0x00D6:
case 0x00D7:
case 0x00D8:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DD:
case 0x00DE:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E3:
case 0x00E4:
case 0x00E5:
case 0x00E6:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F0:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F5:
case 0x00F6:
case 0x00F7:
case 0x00F8:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
case 0x00FD:
case 0x00FE:
case 0x00FF:
break;
case 0x0152: ch = 0x8C; break;
case 0x0153: ch = 0x9C; break;
case 0x0160: ch = 0x8A; break;
case 0x0161: ch = 0x9A; break;
case 0x0178: ch = 0x9F; break;
case 0x017D: ch = 0x8E; break;
case 0x017E: ch = 0x9E; break;
case 0x0192: ch = 0x83; break;
case 0x02C6: ch = 0x88; break;
case 0x02DC: ch = 0x98; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x008D:
case 0x008F:
case 0x0090:
case 0x009D:
case 0x00A0:
case 0x00A1:
case 0x00A2:
case 0x00A3:
case 0x00A4:
case 0x00A5:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00AF:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B8:
case 0x00B9:
case 0x00BA:
case 0x00BB:
case 0x00BC:
case 0x00BD:
case 0x00BE:
case 0x00BF:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C3:
case 0x00C4:
case 0x00C5:
case 0x00C6:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D0:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D5:
case 0x00D6:
case 0x00D7:
case 0x00D8:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DD:
case 0x00DE:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E3:
case 0x00E4:
case 0x00E5:
case 0x00E6:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F0:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F5:
case 0x00F6:
case 0x00F7:
case 0x00F8:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
case 0x00FD:
case 0x00FE:
case 0x00FF:
break;
case 0x0152: ch = 0x8C; break;
case 0x0153: ch = 0x9C; break;
case 0x0160: ch = 0x8A; break;
case 0x0161: ch = 0x9A; break;
case 0x0178: ch = 0x9F; break;
case 0x017D: ch = 0x8E; break;
case 0x017E: ch = 0x9E; break;
case 0x0192: ch = 0x83; break;
case 0x02C6: ch = 0x88; break;
case 0x02DC: ch = 0x98; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP1252
[Serializable]
public class ENCwindows_1252 : CP1252
{
public ENCwindows_1252() : base() {}
}; // class ENCwindows_1252
}; // namespace I18N.West

478
mcs/class/I18N/West/CP1253.cs Normal file
View File

@@ -0,0 +1,478 @@
/*
* CP1253.cs - Greek (Windows) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-5349.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP1253 : ByteEncoding
{
public CP1253()
: base(1253, ToChars, "Greek (Windows)",
"iso-8859-7", "windows-1253", "windows-1253",
true, true, true, true, 1253)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u20AC', '\u0081', '\u201A', '\u0192',
'\u201E', '\u2026', '\u2020', '\u2021', '\u0088', '\u2030',
'\u008A', '\u2039', '\u008C', '\u008D', '\u008E', '\u008F',
'\u0090', '\u2018', '\u2019', '\u201C', '\u201D', '\u2022',
'\u2013', '\u2014', '\u0098', '\u2122', '\u009A', '\u203A',
'\u009C', '\u009D', '\u009E', '\u009F', '\u00A0', '\u0385',
'\u0386', '\u00A3', '\u00A4', '\u00A5', '\u00A6', '\u00A7',
'\u00A8', '\u00A9', '\u00AA', '\u00AB', '\u00AC', '\u00AD',
'\u00AE', '\u2015', '\u00B0', '\u00B1', '\u00B2', '\u00B3',
'\u0384', '\u00B5', '\u00B6', '\u00B7', '\u0388', '\u0389',
'\u038A', '\u00BB', '\u038C', '\u00BD', '\u038E', '\u038F',
'\u0390', '\u0391', '\u0392', '\u0393', '\u0394', '\u0395',
'\u0396', '\u0397', '\u0398', '\u0399', '\u039A', '\u039B',
'\u039C', '\u039D', '\u039E', '\u039F', '\u03A0', '\u03A1',
'\u003F', '\u03A3', '\u03A4', '\u03A5', '\u03A6', '\u03A7',
'\u03A8', '\u03A9', '\u03AA', '\u03AB', '\u03AC', '\u03AD',
'\u03AE', '\u03AF', '\u03B0', '\u03B1', '\u03B2', '\u03B3',
'\u03B4', '\u03B5', '\u03B6', '\u03B7', '\u03B8', '\u03B9',
'\u03BA', '\u03BB', '\u03BC', '\u03BD', '\u03BE', '\u03BF',
'\u03C0', '\u03C1', '\u03C2', '\u03C3', '\u03C4', '\u03C5',
'\u03C6', '\u03C7', '\u03C8', '\u03C9', '\u03CA', '\u03CB',
'\u03CC', '\u03CD', '\u03CE', '\u003F',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x0088:
case 0x008A:
case 0x008C:
case 0x008D:
case 0x008E:
case 0x008F:
case 0x0090:
case 0x0098:
case 0x009A:
case 0x009C:
case 0x009D:
case 0x009E:
case 0x009F:
case 0x00A0:
case 0x00A3:
case 0x00A4:
case 0x00A5:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00BB:
case 0x00BD:
break;
case 0x0192: ch = 0x83; break;
case 0x0384: ch = 0xB4; break;
case 0x0385: ch = 0xA1; break;
case 0x0386: ch = 0xA2; break;
case 0x0388: ch = 0xB8; break;
case 0x0389: ch = 0xB9; break;
case 0x038A: ch = 0xBA; break;
case 0x038C: ch = 0xBC; break;
case 0x038E:
case 0x038F:
case 0x0390:
case 0x0391:
case 0x0392:
case 0x0393:
case 0x0394:
case 0x0395:
case 0x0396:
case 0x0397:
case 0x0398:
case 0x0399:
case 0x039A:
case 0x039B:
case 0x039C:
case 0x039D:
case 0x039E:
case 0x039F:
case 0x03A0:
case 0x03A1:
ch -= 0x02D0;
break;
case 0x03A3:
case 0x03A4:
case 0x03A5:
case 0x03A6:
case 0x03A7:
case 0x03A8:
case 0x03A9:
case 0x03AA:
case 0x03AB:
case 0x03AC:
case 0x03AD:
case 0x03AE:
case 0x03AF:
case 0x03B0:
case 0x03B1:
case 0x03B2:
case 0x03B3:
case 0x03B4:
case 0x03B5:
case 0x03B6:
case 0x03B7:
case 0x03B8:
case 0x03B9:
case 0x03BA:
case 0x03BB:
case 0x03BC:
case 0x03BD:
case 0x03BE:
case 0x03BF:
case 0x03C0:
case 0x03C1:
case 0x03C2:
case 0x03C3:
case 0x03C4:
case 0x03C5:
case 0x03C6:
case 0x03C7:
case 0x03C8:
case 0x03C9:
case 0x03CA:
case 0x03CB:
case 0x03CC:
case 0x03CD:
case 0x03CE:
ch -= 0x02D0;
break;
case 0x03D5: ch = 0xF6; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2015: ch = 0xAF; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 128) switch(ch)
{
case 0x0081:
case 0x0088:
case 0x008A:
case 0x008C:
case 0x008D:
case 0x008E:
case 0x008F:
case 0x0090:
case 0x0098:
case 0x009A:
case 0x009C:
case 0x009D:
case 0x009E:
case 0x009F:
case 0x00A0:
case 0x00A3:
case 0x00A4:
case 0x00A5:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00BB:
case 0x00BD:
break;
case 0x0192: ch = 0x83; break;
case 0x0384: ch = 0xB4; break;
case 0x0385: ch = 0xA1; break;
case 0x0386: ch = 0xA2; break;
case 0x0388: ch = 0xB8; break;
case 0x0389: ch = 0xB9; break;
case 0x038A: ch = 0xBA; break;
case 0x038C: ch = 0xBC; break;
case 0x038E:
case 0x038F:
case 0x0390:
case 0x0391:
case 0x0392:
case 0x0393:
case 0x0394:
case 0x0395:
case 0x0396:
case 0x0397:
case 0x0398:
case 0x0399:
case 0x039A:
case 0x039B:
case 0x039C:
case 0x039D:
case 0x039E:
case 0x039F:
case 0x03A0:
case 0x03A1:
ch -= 0x02D0;
break;
case 0x03A3:
case 0x03A4:
case 0x03A5:
case 0x03A6:
case 0x03A7:
case 0x03A8:
case 0x03A9:
case 0x03AA:
case 0x03AB:
case 0x03AC:
case 0x03AD:
case 0x03AE:
case 0x03AF:
case 0x03B0:
case 0x03B1:
case 0x03B2:
case 0x03B3:
case 0x03B4:
case 0x03B5:
case 0x03B6:
case 0x03B7:
case 0x03B8:
case 0x03B9:
case 0x03BA:
case 0x03BB:
case 0x03BC:
case 0x03BD:
case 0x03BE:
case 0x03BF:
case 0x03C0:
case 0x03C1:
case 0x03C2:
case 0x03C3:
case 0x03C4:
case 0x03C5:
case 0x03C6:
case 0x03C7:
case 0x03C8:
case 0x03C9:
case 0x03CA:
case 0x03CB:
case 0x03CC:
case 0x03CD:
case 0x03CE:
ch -= 0x02D0;
break;
case 0x03D5: ch = 0xF6; break;
case 0x2013: ch = 0x96; break;
case 0x2014: ch = 0x97; break;
case 0x2015: ch = 0xAF; break;
case 0x2018: ch = 0x91; break;
case 0x2019: ch = 0x92; break;
case 0x201A: ch = 0x82; break;
case 0x201C: ch = 0x93; break;
case 0x201D: ch = 0x94; break;
case 0x201E: ch = 0x84; break;
case 0x2020: ch = 0x86; break;
case 0x2021: ch = 0x87; break;
case 0x2022: ch = 0x95; break;
case 0x2026: ch = 0x85; break;
case 0x2030: ch = 0x89; break;
case 0x2039: ch = 0x8B; break;
case 0x203A: ch = 0x9B; break;
case 0x20AC: ch = 0x80; break;
case 0x2122: ch = 0x99; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP1253
[Serializable]
public class ENCwindows_1253 : CP1253
{
public ENCwindows_1253() : base() {}
}; // class ENCwindows_1253
}; // namespace I18N.West

544
mcs/class/I18N/West/CP28592.cs Normal file
View File

File diff suppressed because it is too large Load Diff

392
mcs/class/I18N/West/CP28593.cs Normal file
View File

@@ -0,0 +1,392 @@
/*
* CP28593.cs - Latin 3 (ISO) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-913.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP28593 : ByteEncoding
{
public CP28593()
: base(28593, ToChars, "Latin 3 (ISO)",
"iso-8859-3", "iso-8859-3", "iso-8859-3",
true, true, true, true, 28593)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u0080', '\u0081', '\u0082', '\u0083',
'\u0084', '\u0085', '\u0086', '\u0087', '\u0088', '\u0089',
'\u008A', '\u008B', '\u008C', '\u008D', '\u008E', '\u008F',
'\u0090', '\u0091', '\u0092', '\u0093', '\u0094', '\u0095',
'\u0096', '\u0097', '\u0098', '\u0099', '\u009A', '\u009B',
'\u009C', '\u009D', '\u009E', '\u009F', '\u00A0', '\u0126',
'\u02D8', '\u00A3', '\u00A4', '\u003F', '\u0124', '\u00A7',
'\u00A8', '\u0130', '\u015E', '\u011E', '\u0134', '\u00AD',
'\u003F', '\u017B', '\u00B0', '\u0127', '\u00B2', '\u00B3',
'\u00B4', '\u00B5', '\u0125', '\u00B7', '\u00B8', '\u0131',
'\u015F', '\u011F', '\u0135', '\u00BD', '\u003F', '\u017C',
'\u00C0', '\u00C1', '\u00C2', '\u003F', '\u00C4', '\u010A',
'\u0108', '\u00C7', '\u00C8', '\u00C9', '\u00CA', '\u00CB',
'\u00CC', '\u00CD', '\u00CE', '\u00CF', '\u003F', '\u00D1',
'\u00D2', '\u00D3', '\u00D4', '\u0120', '\u00D6', '\u00D7',
'\u011C', '\u00D9', '\u00DA', '\u00DB', '\u00DC', '\u016C',
'\u015C', '\u00DF', '\u00E0', '\u00E1', '\u00E2', '\u003F',
'\u00E4', '\u010B', '\u0109', '\u00E7', '\u00E8', '\u00E9',
'\u00EA', '\u00EB', '\u00EC', '\u00ED', '\u00EE', '\u00EF',
'\u003F', '\u00F1', '\u00F2', '\u00F3', '\u00F4', '\u0121',
'\u00F6', '\u00F7', '\u011D', '\u00F9', '\u00FA', '\u00FB',
'\u00FC', '\u016D', '\u015D', '\u02D9',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 161) switch(ch)
{
case 0x00A3:
case 0x00A4:
case 0x00A7:
case 0x00A8:
case 0x00AD:
case 0x00B0:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B5:
case 0x00B7:
case 0x00B8:
case 0x00BD:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C4:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D6:
case 0x00D7:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E4:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F6:
case 0x00F7:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
break;
case 0x0108: ch = 0xC6; break;
case 0x0109: ch = 0xE6; break;
case 0x010A: ch = 0xC5; break;
case 0x010B: ch = 0xE5; break;
case 0x011C: ch = 0xD8; break;
case 0x011D: ch = 0xF8; break;
case 0x011E: ch = 0xAB; break;
case 0x011F: ch = 0xBB; break;
case 0x0120: ch = 0xD5; break;
case 0x0121: ch = 0xF5; break;
case 0x0124: ch = 0xA6; break;
case 0x0125: ch = 0xB6; break;
case 0x0126: ch = 0xA1; break;
case 0x0127: ch = 0xB1; break;
case 0x0130: ch = 0xA9; break;
case 0x0131: ch = 0xB9; break;
case 0x0134: ch = 0xAC; break;
case 0x0135: ch = 0xBC; break;
case 0x015C: ch = 0xDE; break;
case 0x015D: ch = 0xFE; break;
case 0x015E: ch = 0xAA; break;
case 0x015F: ch = 0xBA; break;
case 0x016C: ch = 0xDD; break;
case 0x016D: ch = 0xFD; break;
case 0x017B: ch = 0xAF; break;
case 0x017C: ch = 0xBF; break;
case 0x02D8: ch = 0xA2; break;
case 0x02D9: ch = 0xFF; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 161) switch(ch)
{
case 0x00A3:
case 0x00A4:
case 0x00A7:
case 0x00A8:
case 0x00AD:
case 0x00B0:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B5:
case 0x00B7:
case 0x00B8:
case 0x00BD:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C4:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D6:
case 0x00D7:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E4:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F6:
case 0x00F7:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
break;
case 0x0108: ch = 0xC6; break;
case 0x0109: ch = 0xE6; break;
case 0x010A: ch = 0xC5; break;
case 0x010B: ch = 0xE5; break;
case 0x011C: ch = 0xD8; break;
case 0x011D: ch = 0xF8; break;
case 0x011E: ch = 0xAB; break;
case 0x011F: ch = 0xBB; break;
case 0x0120: ch = 0xD5; break;
case 0x0121: ch = 0xF5; break;
case 0x0124: ch = 0xA6; break;
case 0x0125: ch = 0xB6; break;
case 0x0126: ch = 0xA1; break;
case 0x0127: ch = 0xB1; break;
case 0x0130: ch = 0xA9; break;
case 0x0131: ch = 0xB9; break;
case 0x0134: ch = 0xAC; break;
case 0x0135: ch = 0xBC; break;
case 0x015C: ch = 0xDE; break;
case 0x015D: ch = 0xFE; break;
case 0x015E: ch = 0xAA; break;
case 0x015F: ch = 0xBA; break;
case 0x016C: ch = 0xDD; break;
case 0x016D: ch = 0xFD; break;
case 0x017B: ch = 0xAF; break;
case 0x017C: ch = 0xBF; break;
case 0x02D8: ch = 0xA2; break;
case 0x02D9: ch = 0xFF; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP28593
[Serializable]
public class ENCiso_8859_3 : CP28593
{
public ENCiso_8859_3() : base() {}
}; // class ENCiso_8859_3
}; // namespace I18N.West

412
mcs/class/I18N/West/CP28597.cs Normal file
View File

@@ -0,0 +1,412 @@
/*
* CP28597.cs - Greek (ISO) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-4909.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP28597 : ByteEncoding
{
public CP28597()
: base(28597, ToChars, "Greek (ISO)",
"iso-8859-7", "iso-8859-7", "iso-8859-7",
true, true, true, true, 1253)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u0080', '\u0081', '\u0082', '\u0083',
'\u0084', '\u0085', '\u0086', '\u0087', '\u0088', '\u0089',
'\u008A', '\u008B', '\u008C', '\u008D', '\u008E', '\u008F',
'\u0090', '\u0091', '\u0092', '\u0093', '\u0094', '\u0095',
'\u0096', '\u0097', '\u0098', '\u0099', '\u009A', '\u009B',
'\u009C', '\u009D', '\u009E', '\u009F', '\u00A0', '\u2018',
'\u2019', '\u00A3', '\u20AC', '\u003F', '\u00A6', '\u00A7',
'\u00A8', '\u00A9', '\u003F', '\u00AB', '\u00AC', '\u00AD',
'\u003F', '\u2015', '\u00B0', '\u00B1', '\u00B2', '\u00B3',
'\u00B4', '\u0385', '\u0386', '\u0387', '\u0388', '\u0389',
'\u038A', '\u00BB', '\u038C', '\u00BD', '\u038E', '\u038F',
'\u0390', '\u0391', '\u0392', '\u0393', '\u0394', '\u0395',
'\u0396', '\u0397', '\u0398', '\u0399', '\u039A', '\u039B',
'\u039C', '\u039D', '\u039E', '\u039F', '\u03A0', '\u03A1',
'\u003F', '\u03A3', '\u03A4', '\u03A5', '\u03A6', '\u03A7',
'\u03A8', '\u03A9', '\u03AA', '\u03AB', '\u03AC', '\u03AD',
'\u03AE', '\u03AF', '\u03B0', '\u03B1', '\u03B2', '\u03B3',
'\u03B4', '\u03B5', '\u03B6', '\u03B7', '\u03B8', '\u03B9',
'\u03BA', '\u03BB', '\u03BC', '\u03BD', '\u03BE', '\u03BF',
'\u03C0', '\u03C1', '\u03C2', '\u03C3', '\u03C4', '\u03C5',
'\u03C6', '\u03C7', '\u03C8', '\u03C9', '\u03CA', '\u03CB',
'\u03CC', '\u03CD', '\u03CE', '\u003F',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 161) switch(ch)
{
case 0x00A3:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B7:
case 0x00BB:
case 0x00BD:
break;
case 0x0385:
case 0x0386:
case 0x0387:
case 0x0388:
case 0x0389:
case 0x038A:
ch -= 0x02D0;
break;
case 0x038C: ch = 0xBC; break;
case 0x038E:
case 0x038F:
case 0x0390:
case 0x0391:
case 0x0392:
case 0x0393:
case 0x0394:
case 0x0395:
case 0x0396:
case 0x0397:
case 0x0398:
case 0x0399:
case 0x039A:
case 0x039B:
case 0x039C:
case 0x039D:
case 0x039E:
case 0x039F:
case 0x03A0:
case 0x03A1:
ch -= 0x02D0;
break;
case 0x03A3:
case 0x03A4:
case 0x03A5:
case 0x03A6:
case 0x03A7:
case 0x03A8:
case 0x03A9:
case 0x03AA:
case 0x03AB:
case 0x03AC:
case 0x03AD:
case 0x03AE:
case 0x03AF:
case 0x03B0:
case 0x03B1:
case 0x03B2:
case 0x03B3:
case 0x03B4:
case 0x03B5:
case 0x03B6:
case 0x03B7:
case 0x03B8:
case 0x03B9:
case 0x03BA:
case 0x03BB:
case 0x03BC:
case 0x03BD:
case 0x03BE:
case 0x03BF:
case 0x03C0:
case 0x03C1:
case 0x03C2:
case 0x03C3:
case 0x03C4:
case 0x03C5:
case 0x03C6:
case 0x03C7:
case 0x03C8:
case 0x03C9:
case 0x03CA:
case 0x03CB:
case 0x03CC:
case 0x03CD:
case 0x03CE:
ch -= 0x02D0;
break;
case 0x03D5: ch = 0xF6; break;
case 0x2015: ch = 0xAF; break;
case 0x2018: ch = 0xA1; break;
case 0x2019: ch = 0xA2; break;
case 0x20AC: ch = 0xA4; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 161) switch(ch)
{
case 0x00A3:
case 0x00A6:
case 0x00A7:
case 0x00A8:
case 0x00A9:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B4:
case 0x00B7:
case 0x00BB:
case 0x00BD:
break;
case 0x0385:
case 0x0386:
case 0x0387:
case 0x0388:
case 0x0389:
case 0x038A:
ch -= 0x02D0;
break;
case 0x038C: ch = 0xBC; break;
case 0x038E:
case 0x038F:
case 0x0390:
case 0x0391:
case 0x0392:
case 0x0393:
case 0x0394:
case 0x0395:
case 0x0396:
case 0x0397:
case 0x0398:
case 0x0399:
case 0x039A:
case 0x039B:
case 0x039C:
case 0x039D:
case 0x039E:
case 0x039F:
case 0x03A0:
case 0x03A1:
ch -= 0x02D0;
break;
case 0x03A3:
case 0x03A4:
case 0x03A5:
case 0x03A6:
case 0x03A7:
case 0x03A8:
case 0x03A9:
case 0x03AA:
case 0x03AB:
case 0x03AC:
case 0x03AD:
case 0x03AE:
case 0x03AF:
case 0x03B0:
case 0x03B1:
case 0x03B2:
case 0x03B3:
case 0x03B4:
case 0x03B5:
case 0x03B6:
case 0x03B7:
case 0x03B8:
case 0x03B9:
case 0x03BA:
case 0x03BB:
case 0x03BC:
case 0x03BD:
case 0x03BE:
case 0x03BF:
case 0x03C0:
case 0x03C1:
case 0x03C2:
case 0x03C3:
case 0x03C4:
case 0x03C5:
case 0x03C6:
case 0x03C7:
case 0x03C8:
case 0x03C9:
case 0x03CA:
case 0x03CB:
case 0x03CC:
case 0x03CD:
case 0x03CE:
ch -= 0x02D0;
break;
case 0x03D5: ch = 0xF6; break;
case 0x2015: ch = 0xAF; break;
case 0x2018: ch = 0xA1; break;
case 0x2019: ch = 0xA2; break;
case 0x20AC: ch = 0xA4; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP28597
[Serializable]
public class ENCiso_8859_7 : CP28597
{
public ENCiso_8859_7() : base() {}
}; // class ENCiso_8859_7
}; // namespace I18N.West

400
mcs/class/I18N/West/CP28605.cs Normal file
View File

@@ -0,0 +1,400 @@
/*
* CP28605.cs - Latin 9 (ISO) code page.
*
* Copyright (c) 2002 Southern Storm Software, Pty Ltd
*
* 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.
*/
// Generated from "ibm-923.ucm".
// WARNING: Modifying this file directly might be a bad idea.
// You should edit the code generator tools/ucm2cp.c instead for your changes
// to appear in all relevant classes.
namespace I18N.West
{
using System;
using System.Text;
using I18N.Common;
[Serializable]
public class CP28605 : ByteEncoding
{
public CP28605()
: base(28605, ToChars, "Latin 9 (ISO)",
"iso-8859-15", "iso-8859-15", "iso-8859-15",
false, true, true, true, 1252)
{}
private static readonly char[] ToChars = {
'\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
'\u0006', '\u0007', '\u0008', '\u0009', '\u000A', '\u000B',
'\u000C', '\u000D', '\u000E', '\u000F', '\u0010', '\u0011',
'\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017',
'\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D',
'\u001E', '\u001F', '\u0020', '\u0021', '\u0022', '\u0023',
'\u0024', '\u0025', '\u0026', '\u0027', '\u0028', '\u0029',
'\u002A', '\u002B', '\u002C', '\u002D', '\u002E', '\u002F',
'\u0030', '\u0031', '\u0032', '\u0033', '\u0034', '\u0035',
'\u0036', '\u0037', '\u0038', '\u0039', '\u003A', '\u003B',
'\u003C', '\u003D', '\u003E', '\u003F', '\u0040', '\u0041',
'\u0042', '\u0043', '\u0044', '\u0045', '\u0046', '\u0047',
'\u0048', '\u0049', '\u004A', '\u004B', '\u004C', '\u004D',
'\u004E', '\u004F', '\u0050', '\u0051', '\u0052', '\u0053',
'\u0054', '\u0055', '\u0056', '\u0057', '\u0058', '\u0059',
'\u005A', '\u005B', '\u005C', '\u005D', '\u005E', '\u005F',
'\u0060', '\u0061', '\u0062', '\u0063', '\u0064', '\u0065',
'\u0066', '\u0067', '\u0068', '\u0069', '\u006A', '\u006B',
'\u006C', '\u006D', '\u006E', '\u006F', '\u0070', '\u0071',
'\u0072', '\u0073', '\u0074', '\u0075', '\u0076', '\u0077',
'\u0078', '\u0079', '\u007A', '\u007B', '\u007C', '\u007D',
'\u007E', '\u007F', '\u0080', '\u0081', '\u0082', '\u0083',
'\u0084', '\u0085', '\u0086', '\u0087', '\u0088', '\u0089',
'\u008A', '\u008B', '\u008C', '\u008D', '\u008E', '\u008F',
'\u0090', '\u0091', '\u0092', '\u0093', '\u0094', '\u0095',
'\u0096', '\u0097', '\u0098', '\u0099', '\u009A', '\u009B',
'\u009C', '\u009D', '\u009E', '\u009F', '\u00A0', '\u00A1',
'\u00A2', '\u00A3', '\u20AC', '\u00A5', '\u0160', '\u00A7',
'\u0161', '\u00A9', '\u00AA', '\u00AB', '\u00AC', '\u00AD',
'\u00AE', '\u00AF', '\u00B0', '\u00B1', '\u00B2', '\u00B3',
'\u017D', '\u00B5', '\u00B6', '\u00B7', '\u017E', '\u00B9',
'\u00BA', '\u00BB', '\u0152', '\u0153', '\u0178', '\u00BF',
'\u00C0', '\u00C1', '\u00C2', '\u00C3', '\u00C4', '\u00C5',
'\u00C6', '\u00C7', '\u00C8', '\u00C9', '\u00CA', '\u00CB',
'\u00CC', '\u00CD', '\u00CE', '\u00CF', '\u00D0', '\u00D1',
'\u00D2', '\u00D3', '\u00D4', '\u00D5', '\u00D6', '\u00D7',
'\u00D8', '\u00D9', '\u00DA', '\u00DB', '\u00DC', '\u00DD',
'\u00DE', '\u00DF', '\u00E0', '\u00E1', '\u00E2', '\u00E3',
'\u00E4', '\u00E5', '\u00E6', '\u00E7', '\u00E8', '\u00E9',
'\u00EA', '\u00EB', '\u00EC', '\u00ED', '\u00EE', '\u00EF',
'\u00F0', '\u00F1', '\u00F2', '\u00F3', '\u00F4', '\u00F5',
'\u00F6', '\u00F7', '\u00F8', '\u00F9', '\u00FA', '\u00FB',
'\u00FC', '\u00FD', '\u00FE', '\u00FF',
};
// Get the number of bytes needed to encode a character buffer.
public unsafe override int GetByteCountImpl (char* chars, int count)
{
if (this.EncoderFallback != null) {
//Calculate byte count by actually doing encoding and discarding the data.
return GetBytesImpl(chars, count, null, 0);
}
else
{
return count;
}
}
// Get the number of bytes needed to encode a character buffer.
public override int GetByteCount (String s)
{
if (this.EncoderFallback != null)
{
//Calculate byte count by actually doing encoding and discarding the data.
unsafe
{
fixed (char *s_ptr = s)
{
return GetBytesImpl(s_ptr, s.Length, null, 0);
}
}
}
else
{
//byte count equals character count because no EncoderFallback set
return s.Length;
}
}
//ToBytes is just an alias for GetBytesImpl, but doesn't return byte count
protected unsafe override void ToBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
//Calling ToBytes with null destination buffer doesn't make any sense
if (bytes == null)
throw new ArgumentNullException("bytes");
GetBytesImpl(chars, charCount, bytes, byteCount);
}
public unsafe override int GetBytesImpl (char* chars, int charCount,
byte* bytes, int byteCount)
{
int ch;
int charIndex = 0;
int byteIndex = 0;
#if NET_2_0
EncoderFallbackBuffer buffer = null;
#endif
while (charCount > 0)
{
ch = (int)(chars[charIndex]);
charIndex++;
charCount--;
if(ch >= 164) switch(ch)
{
case 0x00A5:
case 0x00A7:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00AF:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B9:
case 0x00BA:
case 0x00BB:
case 0x00BF:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C3:
case 0x00C4:
case 0x00C5:
case 0x00C6:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D0:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D5:
case 0x00D6:
case 0x00D7:
case 0x00D8:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DD:
case 0x00DE:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E3:
case 0x00E4:
case 0x00E5:
case 0x00E6:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F0:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F5:
case 0x00F6:
case 0x00F7:
case 0x00F8:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
case 0x00FD:
case 0x00FE:
case 0x00FF:
break;
case 0x0152: ch = 0xBC; break;
case 0x0153: ch = 0xBD; break;
case 0x0160: ch = 0xA6; break;
case 0x0161: ch = 0xA8; break;
case 0x0178: ch = 0xBE; break;
case 0x017D: ch = 0xB4; break;
case 0x017E: ch = 0xB8; break;
case 0x20AC: ch = 0xA4; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
HandleFallback (ref buffer, chars, ref charIndex, ref charCount, bytes, ref byteIndex, ref byteCount);
continue;
}
}
break;
}
//Write encoded byte to buffer, if buffer is defined and fallback was not used
if (bytes != null)
bytes[byteIndex] = (byte)ch;
byteIndex++;
byteCount--;
}
return byteIndex;
}
/*
protected override void ToBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
int ch;
while(charCount > 0)
{
ch = (int)(s[charIndex++]);
if(ch >= 164) switch(ch)
{
case 0x00A5:
case 0x00A7:
case 0x00A9:
case 0x00AA:
case 0x00AB:
case 0x00AC:
case 0x00AD:
case 0x00AE:
case 0x00AF:
case 0x00B0:
case 0x00B1:
case 0x00B2:
case 0x00B3:
case 0x00B5:
case 0x00B6:
case 0x00B7:
case 0x00B9:
case 0x00BA:
case 0x00BB:
case 0x00BF:
case 0x00C0:
case 0x00C1:
case 0x00C2:
case 0x00C3:
case 0x00C4:
case 0x00C5:
case 0x00C6:
case 0x00C7:
case 0x00C8:
case 0x00C9:
case 0x00CA:
case 0x00CB:
case 0x00CC:
case 0x00CD:
case 0x00CE:
case 0x00CF:
case 0x00D0:
case 0x00D1:
case 0x00D2:
case 0x00D3:
case 0x00D4:
case 0x00D5:
case 0x00D6:
case 0x00D7:
case 0x00D8:
case 0x00D9:
case 0x00DA:
case 0x00DB:
case 0x00DC:
case 0x00DD:
case 0x00DE:
case 0x00DF:
case 0x00E0:
case 0x00E1:
case 0x00E2:
case 0x00E3:
case 0x00E4:
case 0x00E5:
case 0x00E6:
case 0x00E7:
case 0x00E8:
case 0x00E9:
case 0x00EA:
case 0x00EB:
case 0x00EC:
case 0x00ED:
case 0x00EE:
case 0x00EF:
case 0x00F0:
case 0x00F1:
case 0x00F2:
case 0x00F3:
case 0x00F4:
case 0x00F5:
case 0x00F6:
case 0x00F7:
case 0x00F8:
case 0x00F9:
case 0x00FA:
case 0x00FB:
case 0x00FC:
case 0x00FD:
case 0x00FE:
case 0x00FF:
break;
case 0x0152: ch = 0xBC; break;
case 0x0153: ch = 0xBD; break;
case 0x0160: ch = 0xA6; break;
case 0x0161: ch = 0xA8; break;
case 0x0178: ch = 0xBE; break;
case 0x017D: ch = 0xB4; break;
case 0x017E: ch = 0xB8; break;
case 0x20AC: ch = 0xA4; break;
default:
{
if(ch >= 0xFF01 && ch <= 0xFF5E)
{
ch -= 0xFEE0;
}
else
{
ch = 0x3F;
}
}
break;
}
bytes[byteIndex++] = (byte)ch;
--charCount;
}
}
*/
}; // class CP28605
[Serializable]
public class ENCiso_8859_15 : CP28605
{
public ENCiso_8859_15() : base() {}
}; // class ENCiso_8859_15
}; // namespace I18N.West

1409
mcs/class/I18N/West/CP437.cs Normal file
View File

File diff suppressed because it is too large Load Diff

754
mcs/class/I18N/West/CP850.cs Normal file
View File

File diff suppressed because it is too large Load Diff

754
mcs/class/I18N/West/CP860.cs Normal file
View File

File diff suppressed because it is too large Load Diff

754
mcs/class/I18N/West/CP861.cs Normal file
View File

File diff suppressed because it is too large Load Diff

752
mcs/class/I18N/West/CP863.cs Normal file
View File

File diff suppressed because it is too large Load Diff

754
mcs/class/I18N/West/CP865.cs Normal file
View File

File diff suppressed because it is too large Load Diff

64
mcs/class/I18N/West/ChangeLog Normal file
View File

@@ -0,0 +1,64 @@
2010-02-11 Zoltan Varga <vargaz@gmail.com>
* CP1250.cs CP1252.cs: Move the '--charCount' line to the beginning of the loop,
since it can be skipped in case of HandleFallback. Add brances around the
call to HandleFallback so the 'continue' call is only done if it is called.
Should fix #573682.
2008-07-11 Atsushi Enomoto <atsushi@ximian.com>
* CP1252.cs : continue after fallback was missing.
Fixed bug #408381, patch by Jonathan Gagnon.
2008-05-16 Atsushi Enomoto <atsushi@ximian.com>
* Makefile : added Test/texts/*.txt to EXTRA_DISTFILES.
2006-11-20 Atsushi Enomoto <atsushi@ximian.com>
* windows-437-2000.ucm: copied from ICU: http://dev.icu-project.org/cgi-bin/viewcvs.cgi/charset/data/ucm/windows-437-2000.ucm?revision=1.2
* windows-10079-2000.ucm: copied from ICU: http://dev.icu-project.org/cgi-bin/viewcvs.cgi/charset/data/ucm/windows-10079-2000.ucm?revision=1.2
* CP437.cs : now it is autogenerated from windows-437-2000.ucm
Fixed bug #79951
* CP10079.cs : now it is autogenerated from windows-10079-2000.ucm.
2006-11-20 Atsushi Enomoto <atsushi@ximian.com>
* CP28605.cs, CP10000.cs:
cosmetic indent fix (now they are correctly auto-generated).
2006-01-17 Atsushi Enomoto <atsushi@ximian.com>
* CP1252.cs CP28592.cs CP437.cs CP861.cs CP10079.cs CP863.cs
CP865.cs CP28593.cs CP1253.cs CP28597.cs CP10000.cs CP850.cs
CP860.cs CP28605.cs CP1250.cs (All) :
Marked as [Serializable].
2006-01-12 Atsushi Enomoto <atsushi@ximian.com>
* CP10079.cs : oops, silly debugging code was remaining.
2005-12-02 Atsushi Enomoto <atsushi@ximian.com>
* Makefile : now it has tests.
* CP10079.cs : fixed some encoder/decoder mapping bugs.
2005-12-01 Atsushi Enomoto <atsushi@ximian.com>
* CP437.cs : forgot to comment out GetBytes(string).
2005-11-30 Atsushi Enomoto <atsushi@ximian.com>
* CP1252.cs CP28592.cs CP437.cs CP861.cs CP10079.cs CP863.cs CP865.cs
CP28593.cs CP1253.cs CP28597.cs CP850.cs CP860.cs CP28605.cs
CP1250.cs : made the same changes as CP10000.cs had in the previous
commit.
2005-11-30 Atsushi Enomoto <atsushi@ximian.com>
(initial changelog entry here.)
* Makefile : now it uses unsafe pointers.
* CP10000.cs : Added 2.0 fallback support and modified ToBytes() from
array to pointers, and commented ToBytes(string) out (uses virtual
implementation in ByteEncoding).

17
mcs/class/I18N/West/I18N.West.dll.sources Executable file
View File

@@ -0,0 +1,17 @@
../Assembly/AssemblyInfo.cs
../../../build/common/Consts.cs
CP10000.cs
CP10079.cs
CP1250.cs
CP1252.cs
CP1253.cs
CP28592.cs
CP28593.cs
CP28597.cs
CP28605.cs
CP437.cs
CP850.cs
CP860.cs
CP861.cs
CP863.cs
CP865.cs

1
mcs/class/I18N/West/I18N.West_test.dll.sources Normal file
View File

@@ -0,0 +1 @@
I18N.West.Test.cs

12
mcs/class/I18N/West/Makefile Normal file
View File

@@ -0,0 +1,12 @@
thisdir = class/I18N/West
SUBDIRS =
include ../../../build/rules.make
LIBRARY = I18N.West.dll
LOCAL_MCS_FLAGS = /r:$(corlib) /r:I18N.dll /unsafe
#NO_TEST = yes
EXTRA_DISTFILES = $(wildcard *.ucm) \
$(wildcard Test/texts/*.txt)
include ../../../build/library.make

12
mcs/class/I18N/West/Test/ChangeLog Normal file
View File

@@ -0,0 +1,12 @@
2008-07-11 Atsushi Enomoto <atsushi@ximian.com>
* I18N.West.Test.cs : added test for bug #408381, by Jonathan Gagnon.
2006-11-20 Atsushi Enomoto <atsushi@ximian.com>
* I18N.West.Test.cs : added test for bug #79951.
2005-12-02 Atsushi Enomoto <atsushi@ximian.com>
* I18N.West.Test.cs : NUnit test for I18N.West encodings.

Some files were not shown because too many files have changed in this diff Show More