From 60569e1803fa18a49fe54011bd3ffad4883d7959 Mon Sep 17 00:00:00 2001 From: Natalia Portillo Date: Fri, 19 Aug 2016 05:15:20 +0100 Subject: [PATCH] Added Atari ST encoding. --- Claunia.Encoding.Tests/AtariST.cs | 182 ++- Claunia.Encoding.Tests/ChangeLog | 5 + .../Claunia.Encoding.Tests.csproj | 1 + Claunia.Encoding/AtariST.cs | 1009 ++++++++++++++++- Claunia.Encoding/AtariST_1.cs | 999 ---------------- Claunia.Encoding/ChangeLog | 7 + Claunia.Encoding/Claunia.Encoding.csproj | 1 + Claunia.Encoding/Encoding.cs | 1 + 8 files changed, 1198 insertions(+), 1007 deletions(-) delete mode 100644 Claunia.Encoding/AtariST_1.cs diff --git a/Claunia.Encoding.Tests/AtariST.cs b/Claunia.Encoding.Tests/AtariST.cs index d393aa3..7eb9e58 100644 --- a/Claunia.Encoding.Tests/AtariST.cs +++ b/Claunia.Encoding.Tests/AtariST.cs @@ -23,14 +23,188 @@ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -using System; + +using NUnit.Framework; +using System.Runtime.InteropServices; + namespace Claunia.Encoding.Tests { + [TestFixture] public class AtariST { - public AtariST() + const string Punctuations = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; + readonly byte[] PunctuationsBytes = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, + 0x3F, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x7B, 0x7C, 0x7D, 0x7E }; + const string Digits = "0123456789"; + readonly byte[] DigitsBytes = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 }; + const string UpperLatin = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + readonly byte[] UpperLatinBytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, + 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A }; + const string LowerLatin = "abcdefghijklmnopqrstuvwxyz"; + readonly byte[] LowerLatinBytes = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, + 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A }; + + const string Spanish = "¡¿áéíóúüñÉÜÑ"; + readonly byte[] SpanishBytes = { 0xAD, 0xA8, 0xA0, 0x82, 0xA1, 0xA2, 0xA3, 0x81, 0xA4, 0x90, 0x9A, 0xA5 }; + const string French = "éÉàèùÀâêîôûëïüÿçÇœŒæÆ"; + readonly byte[] FrenchBytes = { 0x82, 0x90, 0x85, 0x8A, 0x97, 0xB6, 0x83, 0x88, 0x8C, 0x93, 0x96, 0x89, 0x8B, 0x81, 0x98, 0x87, 0x80, 0xB4, 0xB5, 0x91, 0x92 }; + const string German = "äöüßÄÖÜ"; + readonly byte[] GermanBytes = { 0x84, 0x94, 0x81, 0x9E, 0x8E, 0x99, 0x9A }; + const string Norwegian = "æøåÆØÅ"; + readonly byte[] NorwegianBytes = { 0x91, 0xB3, 0x86, 0x92, 0xB2, 0x8F }; + const string Portuguese = "áéíóúÉâêôãõÃÕçÇ"; + readonly byte[] PortugueseBytes = { 0xA0, 0x82, 0xA1, 0xA2, 0xA3, 0x90, 0x83, 0x88, 0x93, 0xB0, 0xB1, 0xB7, 0xB8, 0x87, 0x80 }; + const string Dutch = "ijIJ"; + readonly byte[] DutchBytes = { 0xC0, 0xC1 }; + const string Hebrew = "אבגדהוזחטיכלמנסעפצקרשתןךםףץ"; + readonly byte[] HebrewBytes = { 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, + 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC}; + const string Greek = "αβΓπΣσµτΦΘΩδ¯"; + readonly byte[] GreekBytes = { 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xFF }; + + const string Typographic = "ªº«»¨´†¶©®™§°∙·"; + readonly byte[] TypographicBytes = { 0xA6, 0xA7, 0xAE, 0xAF, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xDD, 0xF8, 0xF9, 0xFA }; + const string Currency = "¢£¥ƒ"; + readonly byte[] CurrencyBytes = { 0x9B, 0x9C, 0x9D, 0x9F }; + const string Mathematics = "⌐¬½¼∧∞∮ϕ∈∩≡±≥≤⌠⌡÷≈√ⁿ²³"; + readonly byte[] MathematicsBytes = { 0xA9, 0xAA, 0xAB, 0xAC, 0xDE, 0xDF, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xFB, 0xFC, + 0xFD, 0xFE}; + const string Symbols = "⇧⇩⇨⇦❎✓♪ə"; + readonly byte[] SymbolsBytes = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x08, 0x0B, 0x1A }; + // TODO: 0x09 => U+1F552, 0x0A => U+1F514 + /*const string SymbolsUnicode32 = "\ud83d\udd52\ud83d\udd14"; + readonly byte[] SymbolsUnicode32Bytes = { 0x09, 0x0A };*/ + + [Test] + public void UnicodeToAtariST() { + byte[] byteArray; + + byteArray = Encoding.AtariSTEncoding.GetBytes(Punctuations); + Assert.AreEqual(PunctuationsBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Digits); + Assert.AreEqual(DigitsBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(UpperLatin); + Assert.AreEqual(UpperLatinBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(LowerLatin); + Assert.AreEqual(LowerLatinBytes, byteArray); + + byteArray = Encoding.AtariSTEncoding.GetBytes(Spanish); + Assert.AreEqual(SpanishBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(French); + Assert.AreEqual(FrenchBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(German); + Assert.AreEqual(GermanBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Norwegian); + Assert.AreEqual(NorwegianBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Portuguese); + Assert.AreEqual(PortugueseBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Dutch); + Assert.AreEqual(DutchBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Hebrew); + Assert.AreEqual(HebrewBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Greek); + Assert.AreEqual(GreekBytes, byteArray); + + byteArray = Encoding.AtariSTEncoding.GetBytes(Typographic); + Assert.AreEqual(TypographicBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Currency); + Assert.AreEqual(CurrencyBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Mathematics); + Assert.AreEqual(MathematicsBytes, byteArray); + byteArray = Encoding.AtariSTEncoding.GetBytes(Symbols); + Assert.AreEqual(SymbolsBytes, byteArray); + // TODO: 0x09 => U+1F552, 0x0A => U+1F514 + /*byteArray = Encoding.AtariSTEncoding.GetBytes(SymbolsUnicode32); + Assert.AreEqual(SymbolsUnicode32Bytes, byteArray);*/ + } + + [Test] + public void AtariSTToUnicode() + { + string testString; + + testString = Encoding.AtariSTEncoding.GetString(PunctuationsBytes); + Assert.AreEqual(Punctuations, testString); + testString = Encoding.AtariSTEncoding.GetString(DigitsBytes); + Assert.AreEqual(Digits, testString); + testString = Encoding.AtariSTEncoding.GetString(UpperLatinBytes); + Assert.AreEqual(UpperLatin, testString); + testString = Encoding.AtariSTEncoding.GetString(LowerLatinBytes); + Assert.AreEqual(LowerLatin, testString); + + testString = Encoding.AtariSTEncoding.GetString(SpanishBytes); + Assert.AreEqual(Spanish, testString); + testString = Encoding.AtariSTEncoding.GetString(FrenchBytes); + Assert.AreEqual(French, testString); + testString = Encoding.AtariSTEncoding.GetString(GermanBytes); + Assert.AreEqual(German, testString); + testString = Encoding.AtariSTEncoding.GetString(NorwegianBytes); + Assert.AreEqual(Norwegian, testString); + testString = Encoding.AtariSTEncoding.GetString(PortugueseBytes); + Assert.AreEqual(Portuguese, testString); + testString = Encoding.AtariSTEncoding.GetString(DutchBytes); + Assert.AreEqual(Dutch, testString); + testString = Encoding.AtariSTEncoding.GetString(HebrewBytes); + Assert.AreEqual(Hebrew, testString); + testString = Encoding.AtariSTEncoding.GetString(GreekBytes); + Assert.AreEqual(Greek, testString); + + testString = Encoding.AtariSTEncoding.GetString(TypographicBytes); + Assert.AreEqual(Typographic, testString); + testString = Encoding.AtariSTEncoding.GetString(CurrencyBytes); + Assert.AreEqual(Currency, testString); + testString = Encoding.AtariSTEncoding.GetString(MathematicsBytes); + Assert.AreEqual(Mathematics, testString); + testString = Encoding.AtariSTEncoding.GetString(SymbolsBytes); + Assert.AreEqual(Symbols, testString); + // TODO: 0x09 => U+1F552, 0x0A => U+1F514 + /*testString = Encoding.AtariSTEncoding.GetString(SymbolsUnicode32Bytes); + Assert.AreEqual(SymbolsUnicode32, testString);*/ + } + + [Test] + public void AtariSTPangrams() + { + byte[] byteArray; + string testString; + + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Basque); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Basque, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Danish); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Danish, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.English); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.English, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Finnish); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Finnish, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.French); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.French, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Galician); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Galician, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.German); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.German, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Hebrew); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Hebrew, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Norwegian); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Norwegian, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Portuguese); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Portuguese, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Spanish); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Spanish, testString); + byteArray = Encoding.AtariSTEncoding.GetBytes(Pangrams.Swedish); + testString = Encoding.AtariSTEncoding.GetString(byteArray); + Assert.AreEqual(Pangrams.Swedish, testString); } } -} - +} \ No newline at end of file diff --git a/Claunia.Encoding.Tests/ChangeLog b/Claunia.Encoding.Tests/ChangeLog index b214147..d1a5122 100644 --- a/Claunia.Encoding.Tests/ChangeLog +++ b/Claunia.Encoding.Tests/ChangeLog @@ -1,3 +1,8 @@ +2016-08-19 Natalia Portillo + + * AtariST.cs: + * Claunia.Encoding.Tests.csproj: Added Atari ST encoding. + 2016-08-19 Natalia Portillo * LisaRoman.cs: Corrected classification of a character. diff --git a/Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj b/Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj index 007b91f..d34850b 100644 --- a/Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj +++ b/Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj @@ -35,6 +35,7 @@ + diff --git a/Claunia.Encoding/AtariST.cs b/Claunia.Encoding/AtariST.cs index 917c296..52cd51b 100644 --- a/Claunia.Encoding/AtariST.cs +++ b/Claunia.Encoding/AtariST.cs @@ -23,14 +23,1015 @@ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. + using System; + namespace Claunia.Encoding { - public class AtariST + /// + /// Represents an Atari ST character encoding of Unicode characters. + /// + // TODO: 0x09 => U+1F552, 0x0A => U+1F514 + public class AtariST : System.Text.Encoding { - public AtariST() + const string _bodyname = "atarist"; + const int _codepage = 0; + const string _encodingname = "Atari ST"; + const string _headername = "atarist"; + const string _webname = ""; + const int _windowsCodepage = 0; + + const bool browserDisplay = false; + const bool browserSave = false; + const bool mailNewsDisplay = false; + const bool mailNewsSave = false; + const bool readOnly = false; + const bool singleByte = true; + + /// + /// Gets a value indicating whether the current encoding can be used by browser clients for displaying content. + /// + public bool IsBrowserDisplay { + get { return browserDisplay; } + } + + /// + /// Gets a value indicating whether the current encoding can be used by browser clients for saving content. + /// + public bool IsBrowserSave { + get { return browserSave; } + } + + /// + /// Gets a value indicating whether the current encoding can be used by mail and news clients for displaying content. + /// + public bool IsMailNewsDisplay { + get { return mailNewsDisplay; } + } + + /// + /// Gets a value indicating whether the current encoding can be used by mail and news clients for saving content. + /// + public bool IsMailNewsSave { + get { return mailNewsSave; } + } + + /// + /// Gets a value indicating whether the current encoding is read-only. + /// + /// The is single byte. + public bool IsReadOnly { + get { return readOnly; } + } + + /// + /// Gets a value indicating whether the current encoding uses single-byte code points. + /// + public bool IsSingleByte { + get { return singleByte; } + } + + /// + /// Gets the code page identifier of the current Encoding. + /// + public int CodePage { + get { return _codepage; } + } + + /// + /// Gets a name for the current encoding that can be used with mail agent body tags + /// + public string BodyName { + get { return _bodyname; } + } + + /// + /// Gets a name for the current encoding that can be used with mail agent header tags + /// + public string HeaderName { + get { return _headername; } + } + + /// + /// Ggets the name registered with the Internet Assigned Numbers Authority (IANA) for the current encoding. + /// + public override string WebName { + get { return _webname; } + } + + /// + /// Gets the human-readable description of the current encoding. + /// + public string EncodingName { + get { return _encodingname; } + } + + /// + /// Gets the Windows operating system code page that most closely corresponds to the current encoding. + /// + public int WindowsCodePage { + get { return _windowsCodepage; } + } + + /// + /// Calculates the number of bytes produced by encoding the characters in the specified . + /// + /// The number of bytes produced by encoding the specified characters. + /// The containing the set of characters to encode. + public override int GetByteCount(string s) { + if(s == null) + throw new ArgumentNullException(nameof(s)); + + return s.Length; + } + + /// + /// Calculates the number of bytes produced by encoding a set of characters from the specified character array. + /// + /// The number of bytes produced by encoding the specified characters. + /// The character array containing the set of characters to encode. + /// The index of the first character to encode. + /// The number of characters to encode. + public override int GetByteCount(char[] chars, int index, int count) + { + if(chars == null) + throw new ArgumentNullException(nameof(chars)); + + if(index < 0 || index >= chars.Length) + throw new ArgumentOutOfRangeException(nameof(index)); + + if(count < 0 || index + count > chars.Length) + throw new ArgumentOutOfRangeException(nameof(index)); + + return count; + } + + /// + /// Calculates the number of bytes produced by encoding all the characters in the specified character array. + /// + /// The number of bytes produced by encoding all the characters in the specified character array. + /// The character array containing the characters to encode. + public override int GetByteCount(char[] chars) + { + if(chars == null) + throw new ArgumentNullException(nameof(chars)); + + return chars.Length; + } + + /// + /// Encodes a set of characters from the specified into the specified byte array. + /// + /// The actual number of bytes written into bytes. + /// The containing the set of characters to encode. + /// The index of the first character to encode. + /// The number of characters to encode. + /// The byte array to contain the resulting sequence of bytes. + /// The index at which to start writing the resulting sequence of bytes. + public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) + { + return GetBytes(s.ToCharArray(), charIndex, charCount, bytes, byteIndex); + } + + /// + /// Encodes all the characters in the specified string into a sequence of bytes. + /// + /// A byte array containing the results of encoding the specified set of characters. + /// The string containing the characters to encode. + public override byte[] GetBytes(string s) + { + if(s == null) + throw new ArgumentNullException(nameof(s)); + + return GetBytes(s.ToCharArray(), 0, s.Length); + } + + /// + /// Encodes a set of characters from the specified character array into the specified byte array. + /// + /// The actual number of bytes written into bytes. + /// The character array containing the set of characters to encode. + /// The index of the first character to encode. + /// The number of characters to encode. + /// The byte array to contain the resulting sequence of bytes. + /// The index at which to start writing the resulting sequence of bytes. + public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) + { + if(chars == null) + throw new ArgumentNullException(nameof(chars)); + + if(bytes == null) + throw new ArgumentNullException(nameof(bytes)); + + if(charIndex < 0) + throw new ArgumentOutOfRangeException(nameof(charIndex)); + + if(charCount < 0) + throw new ArgumentOutOfRangeException(nameof(charCount)); + + if(byteIndex < 0) + throw new ArgumentOutOfRangeException(nameof(byteIndex)); + + if(charIndex >= chars.Length) + throw new ArgumentOutOfRangeException(nameof(charIndex)); + + if(charCount + charIndex > chars.Length) + throw new ArgumentOutOfRangeException(nameof(charCount)); + + if(byteIndex >= bytes.Length) + throw new ArgumentOutOfRangeException(nameof(byteIndex)); + + if(byteIndex + charCount > bytes.Length) + throw new ArgumentException(nameof(bytes)); + + byte[] temp = GetBytes(chars, charIndex, charCount); + + for(int i = 0; i < temp.Length; i++) + bytes[i + byteIndex] = temp[i]; + + return charCount; + } + + /// + /// Encodes a set of characters from the specified character array into a sequence of bytes. + /// + /// A byte array containing the results of encoding the specified set of characters. + /// The character array containing the set of characters to encode. + /// The index of the first character to encode. + /// The number of characters to encode. + public override byte[] GetBytes(char[] chars, int index, int count) + { + if(chars == null) + throw new ArgumentNullException(nameof(chars)); + + if(index < 0) + throw new ArgumentOutOfRangeException(nameof(index)); + + if(count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + if(count + index > chars.Length) + throw new ArgumentOutOfRangeException(nameof(count)); + + byte[] bytes = new byte[count]; + + for(int i = 0; i < count; i++) + bytes[i] = GetByte(chars[index + i]); + + return bytes; + } + + /// + /// Encodes all the characters in the specified character array into a sequence of bytes. + /// + /// A byte array containing the results of encoding the specified set of characters. + /// The character array containing the characters to encode. + public override byte[] GetBytes(char[] chars) + { + return GetBytes(chars, 0, chars.Length); + } + + /// + /// Calculates the number of characters produced by decoding all the bytes in the specified byte array. + /// + /// The number of characters produced by decoding the specified sequence of bytes. + /// The byte array containing the sequence of bytes to decode. + public override int GetCharCount(byte[] bytes) + { + return GetCharCount(bytes, 0, bytes.Length); + } + + /// + /// Calculates the number of characters produced by decoding a sequence of bytes from the specified byte array. + /// + /// The number of characters produced by decoding the specified sequence of bytes. + /// The byte array containing the sequence of bytes to decode. + /// The index of the first byte to decode. + /// The number of bytes to decode. + public override int GetCharCount(byte[] bytes, int index, int count) + { + if(bytes == null) + throw new ArgumentNullException(nameof(bytes)); + + if(index < 0) + throw new ArgumentOutOfRangeException(nameof(index)); + + if(count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + if(count + index > bytes.Length) + throw new ArgumentOutOfRangeException(nameof(count)); + + return count; + } + + /// + /// Decodes a sequence of bytes from the specified byte array into the specified character array. + /// + /// The actual number of characters written into chars. + /// The byte array containing the sequence of bytes to decode. + /// The index of the first byte to decode. + /// The number of bytes to decode. + /// The character array to contain the resulting set of characters. + /// The index at which to start writing the resulting set of characters. + public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) + { + if(bytes == null) + throw new ArgumentNullException(nameof(bytes)); + + if(chars == null) + throw new ArgumentNullException(nameof(chars)); + + if(byteIndex < 0) + throw new ArgumentOutOfRangeException(nameof(byteIndex)); + + if(byteCount < 0) + throw new ArgumentOutOfRangeException(nameof(byteCount)); + + if(charIndex < 0) + throw new ArgumentOutOfRangeException(nameof(charIndex)); + + if(byteIndex >= bytes.Length) + throw new ArgumentOutOfRangeException(nameof(byteIndex)); + + if(byteCount + byteIndex > bytes.Length) + throw new ArgumentOutOfRangeException(nameof(byteCount)); + + if(charIndex >= chars.Length) + throw new ArgumentOutOfRangeException(nameof(charIndex)); + + if(charIndex + byteCount > chars.Length) + throw new ArgumentException(nameof(chars)); + + char[] temp = GetChars(bytes, byteIndex, byteCount); + + for(int i = 0; i < temp.Length; i++) + chars[i + charIndex] = temp[i]; + + return byteCount; + } + + /// + /// Decodes all the bytes in the specified byte array into a set of characters. + /// + /// A character array containing the results of decoding the specified sequence of bytes. + /// The byte array containing the sequence of bytes to decode. + public override char[] GetChars(byte[] bytes) + { + return GetChars(bytes, 0, bytes.Length); + } + + /// + /// Decodes a sequence of bytes from the specified byte array into a set of characters. + /// + /// The chars. + /// The byte array containing the sequence of bytes to decode. + /// The index of the first byte to decode. + /// The number of bytes to decode. + public override char[] GetChars(byte[] bytes, int index, int count) + { + if(bytes == null) + throw new ArgumentNullException(nameof(bytes)); + + if(index < 0) + throw new ArgumentOutOfRangeException(nameof(index)); + + if(count < 0) + throw new ArgumentOutOfRangeException(nameof(count)); + + if(count + index > bytes.Length) + throw new ArgumentOutOfRangeException(nameof(count)); + + char[] chars = new char[count]; + + for(int i = 0; i < count; i++) + chars[i] = GetChar(bytes[index + i]); + + return chars; + } + + /// + /// Calculates the maximum number of bytes produced by encoding the specified number of characters. + /// + /// The maximum number of bytes produced by encoding the specified number of characters. + /// The number of characters to encode. + public override int GetMaxByteCount(int charCount) + { + if(charCount < 0) + throw new ArgumentOutOfRangeException(nameof(charCount)); + + return charCount; + } + + /// + /// Calculates the maximum number of characters produced by decoding the specified number of bytes. + /// + /// The maximum number of characters produced by decoding the specified number of bytes. + /// The number of bytes to decode. + public override int GetMaxCharCount(int byteCount) + { + if(byteCount < 0) + throw new ArgumentOutOfRangeException(nameof(byteCount)); + + return byteCount; + } + + /// + /// Returns a sequence of bytes that specifies the encoding used. + /// + /// A byte array of length zero, as a preamble is not required. + public override byte[] GetPreamble() + { + return new byte[0]; + } + + /// + /// Decodes all the bytes in the specified byte array into a string. + /// + /// A string that contains the results of decoding the specified sequence of bytes. + /// The byte array containing the sequence of bytes to decode. + public string GetString(byte[] bytes) + { + return GetString(bytes, 0, bytes.Length); + } + + /// + /// Decodes a sequence of bytes from the specified byte array into a string. + /// + /// A string that contains the results of decoding the specified sequence of bytes. + /// The byte array containing the sequence of bytes to decode. + /// The index of the first byte to decode. + /// The number of bytes to decode. + public override string GetString(byte[] bytes, int index, int count) + { + return new string(GetChars(bytes, index, count)); + } + + /// + /// The Atari ST to Unicode character map. + /// + static readonly char[] AtariSTTable = { + // 0x00 + '\u0000','\u21E7','\u21E9','\u21E8','\u21E6','\u274E','\uFFFD','\uFFFD', + // 0x08 + '\u2713','\uFFFD','\uFFFD','\u266A','\u000C','\u000D','\uFFFD','\uFFFD', + // 0x10 + '\uFFFD','\uFFFD','\uFFFD','\uFFFD','\uFFFD','\uFFFD','\uFFFD','\uFFFD', + // 0x18 + '\uFFFD','\uFFFD','\u0259','\u001B','\uFFFD','\uFFFD','\uFFFD','\uFFFD', + // 0x20 + '\u0020','\u0021','\u0022','\u0023','\u0024','\u0025','\u0026','\u0027', + // 0x28 + '\u0028','\u0029','\u002A','\u002B','\u002C','\u002D','\u002E','\u002F', + // 0x30 + '\u0030','\u0031','\u0032','\u0033','\u0034','\u0035','\u0036','\u0037', + // 0x38 + '\u0038','\u0039','\u003A','\u003B','\u003C','\u003D','\u003E','\u003F', + // 0x40 + '\u0040','\u0041','\u0042','\u0043','\u0044','\u0045','\u0046','\u0047', + // 0x48 + '\u0048','\u0049','\u004A','\u004B','\u004C','\u004D','\u004E','\u004F', + // 0x50 + '\u0050','\u0051','\u0052','\u0053','\u0054','\u0055','\u0056','\u0057', + // 0x58 + '\u0058','\u0059','\u005A','\u005B','\u005C','\u005D','\u005E','\u005F', + // 0x60 + '\u0060','\u0061','\u0062','\u0063','\u0064','\u0065','\u0066','\u0067', + // 0x68 + '\u0068','\u0069','\u006A','\u006B','\u006C','\u006D','\u006E','\u006F', + // 0x70 + '\u0070','\u0071','\u0072','\u0073','\u0074','\u0075','\u0076','\u0077', + // 0x78 + '\u0078','\u0079','\u007A','\u007B','\u007C','\u007D','\u007E','\u2302', + // 0x80 + '\u00C7','\u00FC','\u00E9','\u00E2','\u00E4','\u00E0','\u00E5','\u00E7', + // 0x88 + '\u00EA','\u00EB','\u00E8','\u00EF','\u00EE','\u00EC','\u00C4','\u00C5', + // 0x90 + '\u00C9','\u00E6','\u00C6','\u00F4','\u00F6','\u00F2','\u00FB','\u00F9', + // 0x98 + '\u00FF','\u00D6','\u00DC','\u00A2','\u00A3','\u00A5','\u00DF','\u0192', + // 0xA0 + '\u00E1','\u00ED','\u00F3','\u00FA','\u00F1','\u00D1','\u00AA','\u00BA', + // 0xA8 + '\u00BF','\u2310','\u00AC','\u00BD','\u00BC','\u00A1','\u00AB','\u00BB', + // 0xB0 + '\u00E3','\u00F5','\u00D8','\u00F8','\u0153','\u0152','\u00C0','\u00C3', + // 0xB8 + '\u00D5','\u00A8','\u00B4','\u2020','\u00B6','\u00A9','\u00AE','\u2122', + // 0xC0 + '\u0133','\u0132','\u05D0','\u05D1','\u05D2','\u05D3','\u05D4','\u05D5', + // 0xC8 + '\u05D6','\u05D7','\u05D8','\u05D9','\u05DB','\u05DC','\u05DE','\u05E0', + // 0xD0 + '\u05E1','\u05E2','\u05E4','\u05E6','\u05E7','\u05E8','\u05E9','\u05EA', + // 0xD8 + '\u05DF','\u05DA','\u05DD','\u05E3','\u05E5','\u00A7','\u2227','\u221E', + // 0xE0 + '\u03B1','\u03B2','\u0393','\u03C0','\u03A3','\u03C3','\u00B5','\u03C4', + // 0xE8 + '\u03A6','\u0398','\u03A9','\u03B4','\u222E','\u03D5','\u2208','\u2229', + // 0xF0 + '\u2261','\u00B1','\u2265','\u2264','\u2320','\u2321','\u00F7','\u2248', + // 0xF8 + '\u00B0','\u2219','\u00B7','\u221A','\u207F','\u00B2','\u00B3','\u00AF' + }; + + /// + /// Converts a LisaRoman character to an Unicode character + /// + /// Unicode character. + /// LisaRoman character. + static char GetChar(byte character) + { + return AtariSTTable[character]; + } + + /// + /// Converts a Unicode character to an LisaRoman character + /// + /// LisaRoman character. + /// Unicode character. + static byte GetByte(char character) + { + switch(character) { + case '\u0000': + return 0x00; + case '\u21E7': + return 0x01; + case '\u21E9': + return 0x02; + case '\u21E8': + return 0x03; + case '\u21E6': + return 0x04; + case '\u274E': + return 0x05; + case '\u2713': + return 0x08; + case '\u266A': + return 0x0B; + case '\u000C': + return 0x0C; + case '\u000D': + return 0x0D; + case '\u0259': + return 0x1A; + case '\u001B': + return 0x1B; + case '\u0020': + return 0x20; + case '\u0021': + return 0x21; + case '\u0022': + return 0x22; + case '\u0023': + return 0x23; + case '\u0024': + return 0x24; + case '\u0025': + return 0x25; + case '\u0026': + return 0x26; + case '\u0027': + return 0x27; + case '\u0028': + return 0x28; + case '\u0029': + return 0x29; + case '\u002A': + return 0x2A; + case '\u002B': + return 0x2B; + case '\u002C': + return 0x2C; + case '\u002D': + return 0x2D; + case '\u002E': + return 0x2E; + case '\u002F': + return 0x2F; + case '\u0030': + return 0x30; + case '\u0031': + return 0x31; + case '\u0032': + return 0x32; + case '\u0033': + return 0x33; + case '\u0034': + return 0x34; + case '\u0035': + return 0x35; + case '\u0036': + return 0x36; + case '\u0037': + return 0x37; + case '\u0038': + return 0x38; + case '\u0039': + return 0x39; + case '\u003A': + return 0x3A; + case '\u003B': + return 0x3B; + case '\u003C': + return 0x3C; + case '\u003D': + return 0x3D; + case '\u003E': + return 0x3E; + case '\u003F': + return 0x3F; + case '\u0040': + return 0x40; + case '\u0041': + return 0x41; + case '\u0042': + return 0x42; + case '\u0043': + return 0x43; + case '\u0044': + return 0x44; + case '\u0045': + return 0x45; + case '\u0046': + return 0x46; + case '\u0047': + return 0x47; + case '\u0048': + return 0x48; + case '\u0049': + return 0x49; + case '\u004A': + return 0x4A; + case '\u004B': + return 0x4B; + case '\u004C': + return 0x4C; + case '\u004D': + return 0x4D; + case '\u004E': + return 0x4E; + case '\u004F': + return 0x4F; + case '\u0050': + return 0x50; + case '\u0051': + return 0x51; + case '\u0052': + return 0x52; + case '\u0053': + return 0x53; + case '\u0054': + return 0x54; + case '\u0055': + return 0x55; + case '\u0056': + return 0x56; + case '\u0057': + return 0x57; + case '\u0058': + return 0x58; + case '\u0059': + return 0x59; + case '\u005A': + return 0x5A; + case '\u005B': + return 0x5B; + case '\u005C': + return 0x5C; + case '\u005D': + return 0x5D; + case '\u005E': + return 0x5E; + case '\u005F': + return 0x5F; + case '\u0060': + return 0x60; + case '\u0061': + return 0x61; + case '\u0062': + return 0x62; + case '\u0063': + return 0x63; + case '\u0064': + return 0x64; + case '\u0065': + return 0x65; + case '\u0066': + return 0x66; + case '\u0067': + return 0x67; + case '\u0068': + return 0x68; + case '\u0069': + return 0x69; + case '\u006A': + return 0x6A; + case '\u006B': + return 0x6B; + case '\u006C': + return 0x6C; + case '\u006D': + return 0x6D; + case '\u006E': + return 0x6E; + case '\u006F': + return 0x6F; + case '\u0070': + return 0x70; + case '\u0071': + return 0x71; + case '\u0072': + return 0x72; + case '\u0073': + return 0x73; + case '\u0074': + return 0x74; + case '\u0075': + return 0x75; + case '\u0076': + return 0x76; + case '\u0077': + return 0x77; + case '\u0078': + return 0x78; + case '\u0079': + return 0x79; + case '\u007A': + return 0x7A; + case '\u007B': + return 0x7B; + case '\u007C': + return 0x7C; + case '\u007D': + return 0x7D; + case '\u007E': + return 0x7E; + case '\u2302': + return 0x7F; + case '\u00C7': + return 0x80; + case '\u00FC': + return 0x81; + case '\u00E9': + return 0x82; + case '\u00E2': + return 0x83; + case '\u00E4': + return 0x84; + case '\u00E0': + return 0x85; + case '\u00E5': + return 0x86; + case '\u00E7': + return 0x87; + case '\u00EA': + return 0x88; + case '\u00EB': + return 0x89; + case '\u00E8': + return 0x8A; + case '\u00EF': + return 0x8B; + case '\u00EE': + return 0x8C; + case '\u00EC': + return 0x8D; + case '\u00C4': + return 0x8E; + case '\u00C5': + return 0x8F; + case '\u00C9': + return 0x90; + case '\u00E6': + return 0x91; + case '\u00C6': + return 0x92; + case '\u00F4': + return 0x93; + case '\u00F6': + return 0x94; + case '\u00F2': + return 0x95; + case '\u00FB': + return 0x96; + case '\u00F9': + return 0x97; + case '\u00FF': + return 0x98; + case '\u00D6': + return 0x99; + case '\u00DC': + return 0x9A; + case '\u00A2': + return 0x9B; + case '\u00A3': + return 0x9C; + case '\u00A5': + return 0x9D; + case '\u00DF': + return 0x9E; + case '\u0192': + return 0x9F; + case '\u00E1': + return 0xA0; + case '\u00ED': + return 0xA1; + case '\u00F3': + return 0xA2; + case '\u00FA': + return 0xA3; + case '\u00F1': + return 0xA4; + case '\u00D1': + return 0xA5; + case '\u00AA': + return 0xA6; + case '\u00BA': + return 0xA7; + case '\u00BF': + return 0xA8; + case '\u2310': + return 0xA9; + case '\u00AC': + return 0xAA; + case '\u00BD': + return 0xAB; + case '\u00BC': + return 0xAC; + case '\u00A1': + return 0xAD; + case '\u00AB': + return 0xAE; + case '\u00BB': + return 0xAF; + case '\u00E3': + return 0xB0; + case '\u00F5': + return 0xB1; + case '\u00D8': + return 0xB2; + case '\u00F8': + return 0xB3; + case '\u0153': + return 0xB4; + case '\u0152': + return 0xB5; + case '\u00C0': + return 0xB6; + case '\u00C3': + return 0xB7; + case '\u00D5': + return 0xB8; + case '\u00A8': + return 0xB9; + case '\u00B4': + return 0xBA; + case '\u2020': + return 0xBB; + case '\u00B6': + return 0xBC; + case '\u00A9': + return 0xBD; + case '\u00AE': + return 0xBE; + case '\u2122': + return 0xBF; + case '\u0133': + return 0xC0; + case '\u0132': + return 0xC1; + case '\u05D0': + return 0xC2; + case '\u05D1': + return 0xC3; + case '\u05D2': + return 0xC4; + case '\u05D3': + return 0xC5; + case '\u05D4': + return 0xC6; + case '\u05D5': + return 0xC7; + case '\u05D6': + return 0xC8; + case '\u05D7': + return 0xC9; + case '\u05D8': + return 0xCA; + case '\u05D9': + return 0xCB; + case '\u05DB': + return 0xCC; + case '\u05DC': + return 0xCD; + case '\u05DE': + return 0xCE; + case '\u05E0': + return 0xCF; + case '\u05E1': + return 0xD0; + case '\u05E2': + return 0xD1; + case '\u05E4': + return 0xD2; + case '\u05E6': + return 0xD3; + case '\u05E7': + return 0xD4; + case '\u05E8': + return 0xD5; + case '\u05E9': + return 0xD6; + case '\u05EA': + return 0xD7; + case '\u05DF': + return 0xD8; + case '\u05DA': + return 0xD9; + case '\u05DD': + return 0xDA; + case '\u05E3': + return 0xDB; + case '\u05E5': + return 0xDC; + case '\u00A7': + return 0xDD; + case '\u2227': + return 0xDE; + case '\u221E': + return 0xDF; + case '\u03B1': + return 0xE0; + case '\u03B2': + return 0xE1; + case '\u0393': + return 0xE2; + case '\u03C0': + return 0xE3; + case '\u03A3': + return 0xE4; + case '\u03C3': + return 0xE5; + case '\u00B5': + return 0xE6; + case '\u03C4': + return 0xE7; + case '\u03A6': + return 0xE8; + case '\u0398': + return 0xE9; + case '\u03A9': + return 0xEA; + case '\u03B4': + return 0xEB; + case '\u222E': + return 0xEC; + case '\u03D5': + return 0xED; + case '\u2208': + return 0xEE; + case '\u2229': + return 0xEF; + case '\u2261': + return 0xF0; + case '\u00B1': + return 0xF1; + case '\u2265': + return 0xF2; + case '\u2264': + return 0xF3; + case '\u2320': + return 0xF4; + case '\u2321': + return 0xF5; + case '\u00F7': + return 0xF6; + case '\u2248': + return 0xF7; + case '\u00B0': + return 0xF8; + case '\u2219': + return 0xF9; + case '\u00B7': + return 0xFA; + case '\u221A': + return 0xFB; + case '\u207F': + return 0xFC; + case '\u00B2': + return 0xFD; + case '\u00B3': + return 0xFE; + case '\u00AF': + return 0xFF; + default: + // Fallback to '?' + return 0x3F; + } } } -} - +} \ No newline at end of file diff --git a/Claunia.Encoding/AtariST_1.cs b/Claunia.Encoding/AtariST_1.cs deleted file mode 100644 index 5f65d55..0000000 --- a/Claunia.Encoding/AtariST_1.cs +++ /dev/null @@ -1,999 +0,0 @@ -// -// LisaRoman.cs -// -// Author: -// Natalia Portillo -// -// Copyright (c) 2016 © Claunia.com -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -using System; - -namespace Claunia.Encoding -{ - /// - /// Represents an Apple Lisa character encoding of Unicode characters. - /// - public class LisaRoman : System.Text.Encoding - { - const string _bodyname = "lisa"; - const int _codepage = 0; - const string _encodingname = "Apple Lisa"; - const string _headername = "lisa"; - const string _webname = ""; - const int _windowsCodepage = 10000; - - const bool browserDisplay = false; - const bool browserSave = false; - const bool mailNewsDisplay = false; - const bool mailNewsSave = false; - const bool readOnly = false; - const bool singleByte = true; - - /// - /// Gets a value indicating whether the current encoding can be used by browser clients for displaying content. - /// - public bool IsBrowserDisplay { - get { return browserDisplay; } - } - - /// - /// Gets a value indicating whether the current encoding can be used by browser clients for saving content. - /// - public bool IsBrowserSave { - get { return browserSave; } - } - - /// - /// Gets a value indicating whether the current encoding can be used by mail and news clients for displaying content. - /// - public bool IsMailNewsDisplay { - get { return mailNewsDisplay; } - } - - /// - /// Gets a value indicating whether the current encoding can be used by mail and news clients for saving content. - /// - public bool IsMailNewsSave { - get { return mailNewsSave; } - } - - /// - /// Gets a value indicating whether the current encoding is read-only. - /// - /// The is single byte. - public bool IsReadOnly { - get { return readOnly; } - } - - /// - /// Gets a value indicating whether the current encoding uses single-byte code points. - /// - public bool IsSingleByte { - get { return singleByte; } - } - - /// - /// Gets the code page identifier of the current Encoding. - /// - public int CodePage { - get { return _codepage; } - } - - /// - /// Gets a name for the current encoding that can be used with mail agent body tags - /// - public string BodyName { - get { return _bodyname; } - } - - /// - /// Gets a name for the current encoding that can be used with mail agent header tags - /// - public string HeaderName { - get { return _headername; } - } - - /// - /// Ggets the name registered with the Internet Assigned Numbers Authority (IANA) for the current encoding. - /// - public override string WebName { - get { return _webname; } - } - - /// - /// Gets the human-readable description of the current encoding. - /// - public string EncodingName { - get { return _encodingname; } - } - - /// - /// Gets the Windows operating system code page that most closely corresponds to the current encoding. - /// - public int WindowsCodePage { - get { return _windowsCodepage; } - } - - /// - /// Calculates the number of bytes produced by encoding the characters in the specified . - /// - /// The number of bytes produced by encoding the specified characters. - /// The containing the set of characters to encode. - public override int GetByteCount(string s) - { - if(s == null) - throw new ArgumentNullException(nameof(s)); - - return s.Length; - } - - /// - /// Calculates the number of bytes produced by encoding a set of characters from the specified character array. - /// - /// The number of bytes produced by encoding the specified characters. - /// The character array containing the set of characters to encode. - /// The index of the first character to encode. - /// The number of characters to encode. - public override int GetByteCount(char[] chars, int index, int count) - { - if(chars == null) - throw new ArgumentNullException(nameof(chars)); - - if(index < 0 || index >= chars.Length) - throw new ArgumentOutOfRangeException(nameof(index)); - - if(count < 0 || index + count > chars.Length) - throw new ArgumentOutOfRangeException(nameof(index)); - - return count; - } - - /// - /// Calculates the number of bytes produced by encoding all the characters in the specified character array. - /// - /// The number of bytes produced by encoding all the characters in the specified character array. - /// The character array containing the characters to encode. - public override int GetByteCount(char[] chars) - { - if(chars == null) - throw new ArgumentNullException(nameof(chars)); - - return chars.Length; - } - - /// - /// Encodes a set of characters from the specified into the specified byte array. - /// - /// The actual number of bytes written into bytes. - /// The containing the set of characters to encode. - /// The index of the first character to encode. - /// The number of characters to encode. - /// The byte array to contain the resulting sequence of bytes. - /// The index at which to start writing the resulting sequence of bytes. - public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) - { - return GetBytes(s.ToCharArray(), charIndex, charCount, bytes, byteIndex); - } - - /// - /// Encodes all the characters in the specified string into a sequence of bytes. - /// - /// A byte array containing the results of encoding the specified set of characters. - /// The string containing the characters to encode. - public override byte[] GetBytes(string s) - { - if(s == null) - throw new ArgumentNullException(nameof(s)); - - return GetBytes(s.ToCharArray(), 0, s.Length); - } - - /// - /// Encodes a set of characters from the specified character array into the specified byte array. - /// - /// The actual number of bytes written into bytes. - /// The character array containing the set of characters to encode. - /// The index of the first character to encode. - /// The number of characters to encode. - /// The byte array to contain the resulting sequence of bytes. - /// The index at which to start writing the resulting sequence of bytes. - public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) - { - if(chars == null) - throw new ArgumentNullException(nameof(chars)); - - if(bytes == null) - throw new ArgumentNullException(nameof(bytes)); - - if(charIndex < 0) - throw new ArgumentOutOfRangeException(nameof(charIndex)); - - if(charCount < 0) - throw new ArgumentOutOfRangeException(nameof(charCount)); - - if(byteIndex < 0) - throw new ArgumentOutOfRangeException(nameof(byteIndex)); - - if(charIndex >= chars.Length) - throw new ArgumentOutOfRangeException(nameof(charIndex)); - - if(charCount + charIndex > chars.Length) - throw new ArgumentOutOfRangeException(nameof(charCount)); - - if(byteIndex >= bytes.Length) - throw new ArgumentOutOfRangeException(nameof(byteIndex)); - - if(byteIndex + charCount > bytes.Length) - throw new ArgumentException(nameof(bytes)); - - byte[] temp = GetBytes(chars, charIndex, charCount); - - for(int i = 0; i < temp.Length; i++) - bytes[i + byteIndex] = temp[i]; - - return charCount; - } - - /// - /// Encodes a set of characters from the specified character array into a sequence of bytes. - /// - /// A byte array containing the results of encoding the specified set of characters. - /// The character array containing the set of characters to encode. - /// The index of the first character to encode. - /// The number of characters to encode. - public override byte[] GetBytes(char[] chars, int index, int count) - { - if(chars == null) - throw new ArgumentNullException(nameof(chars)); - - if(index < 0) - throw new ArgumentOutOfRangeException(nameof(index)); - - if(count < 0) - throw new ArgumentOutOfRangeException(nameof(count)); - - if(count + index > chars.Length) - throw new ArgumentOutOfRangeException(nameof(count)); - - byte[] bytes = new byte[count]; - - for(int i = 0; i < count; i++) - bytes[i] = GetByte(chars[index + i]); - - return bytes; - } - - /// - /// Encodes all the characters in the specified character array into a sequence of bytes. - /// - /// A byte array containing the results of encoding the specified set of characters. - /// The character array containing the characters to encode. - public override byte[] GetBytes(char[] chars) - { - return GetBytes(chars, 0, chars.Length); - } - - /// - /// Calculates the number of characters produced by decoding all the bytes in the specified byte array. - /// - /// The number of characters produced by decoding the specified sequence of bytes. - /// The byte array containing the sequence of bytes to decode. - public override int GetCharCount(byte[] bytes) - { - return GetCharCount(bytes, 0, bytes.Length); - } - - /// - /// Calculates the number of characters produced by decoding a sequence of bytes from the specified byte array. - /// - /// The number of characters produced by decoding the specified sequence of bytes. - /// The byte array containing the sequence of bytes to decode. - /// The index of the first byte to decode. - /// The number of bytes to decode. - public override int GetCharCount(byte[] bytes, int index, int count) - { - if(bytes == null) - throw new ArgumentNullException(nameof(bytes)); - - if(index < 0) - throw new ArgumentOutOfRangeException(nameof(index)); - - if(count < 0) - throw new ArgumentOutOfRangeException(nameof(count)); - - if(count + index > bytes.Length) - throw new ArgumentOutOfRangeException(nameof(count)); - - return count; - } - - /// - /// Decodes a sequence of bytes from the specified byte array into the specified character array. - /// - /// The actual number of characters written into chars. - /// The byte array containing the sequence of bytes to decode. - /// The index of the first byte to decode. - /// The number of bytes to decode. - /// The character array to contain the resulting set of characters. - /// The index at which to start writing the resulting set of characters. - public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) - { - if(bytes == null) - throw new ArgumentNullException(nameof(bytes)); - - if(chars == null) - throw new ArgumentNullException(nameof(chars)); - - if(byteIndex < 0) - throw new ArgumentOutOfRangeException(nameof(byteIndex)); - - if(byteCount < 0) - throw new ArgumentOutOfRangeException(nameof(byteCount)); - - if(charIndex < 0) - throw new ArgumentOutOfRangeException(nameof(charIndex)); - - if(byteIndex >= bytes.Length) - throw new ArgumentOutOfRangeException(nameof(byteIndex)); - - if(byteCount + byteIndex > bytes.Length) - throw new ArgumentOutOfRangeException(nameof(byteCount)); - - if(charIndex >= chars.Length) - throw new ArgumentOutOfRangeException(nameof(charIndex)); - - if(charIndex + byteCount > chars.Length) - throw new ArgumentException(nameof(chars)); - - char[] temp = GetChars(bytes, byteIndex, byteCount); - - for(int i = 0; i < temp.Length; i++) - chars[i + charIndex] = temp[i]; - - return byteCount; - } - - /// - /// Decodes all the bytes in the specified byte array into a set of characters. - /// - /// A character array containing the results of decoding the specified sequence of bytes. - /// The byte array containing the sequence of bytes to decode. - public override char[] GetChars(byte[] bytes) - { - return GetChars(bytes, 0, bytes.Length); - } - - /// - /// Decodes a sequence of bytes from the specified byte array into a set of characters. - /// - /// The chars. - /// The byte array containing the sequence of bytes to decode. - /// The index of the first byte to decode. - /// The number of bytes to decode. - public override char[] GetChars(byte[] bytes, int index, int count) - { - if(bytes == null) - throw new ArgumentNullException(nameof(bytes)); - - if(index < 0) - throw new ArgumentOutOfRangeException(nameof(index)); - - if(count < 0) - throw new ArgumentOutOfRangeException(nameof(count)); - - if(count + index > bytes.Length) - throw new ArgumentOutOfRangeException(nameof(count)); - - char[] chars = new char[count]; - - for(int i = 0; i < count; i++) - chars[i] = GetChar(bytes[index + i]); - - return chars; - } - - /// - /// Calculates the maximum number of bytes produced by encoding the specified number of characters. - /// - /// The maximum number of bytes produced by encoding the specified number of characters. - /// The number of characters to encode. - public override int GetMaxByteCount(int charCount) - { - if(charCount < 0) - throw new ArgumentOutOfRangeException(nameof(charCount)); - - return charCount; - } - - /// - /// Calculates the maximum number of characters produced by decoding the specified number of bytes. - /// - /// The maximum number of characters produced by decoding the specified number of bytes. - /// The number of bytes to decode. - public override int GetMaxCharCount(int byteCount) - { - if(byteCount < 0) - throw new ArgumentOutOfRangeException(nameof(byteCount)); - - return byteCount; - } - - /// - /// Returns a sequence of bytes that specifies the encoding used. - /// - /// A byte array of length zero, as a preamble is not required. - public override byte[] GetPreamble() - { - return new byte[0]; - } - - /// - /// Decodes all the bytes in the specified byte array into a string. - /// - /// A string that contains the results of decoding the specified sequence of bytes. - /// The byte array containing the sequence of bytes to decode. - public string GetString(byte[] bytes) - { - return GetString(bytes, 0, bytes.Length); - } - - /// - /// Decodes a sequence of bytes from the specified byte array into a string. - /// - /// A string that contains the results of decoding the specified sequence of bytes. - /// The byte array containing the sequence of bytes to decode. - /// The index of the first byte to decode. - /// The number of bytes to decode. - public override string GetString(byte[] bytes, int index, int count) - { - return new string(GetChars(bytes, index, count)); - } - - /// - /// The Lisa to Unicode character map. - /// MacRoman is a superset of LisaRoman. - /// - static readonly char[] LisaRomanTable = { - // 0x00 - '\u0000','\u0001','\u0002','\u0003','\u0004','\u0005','\u0006','\u0007', - // 0x08 - '\u0008','\u0009','\u000A','\u000B','\u000C','\u000D','\u000E','\u000F', - // 0x10 - '\u0010','\u0011','\u0012','\u0013','\u0014','\u0015','\u0016','\u0017', - // 0x18 - '\u0018','\u0019','\u001A','\u001B','\u001C','\u001D','\u001E','\u001F', - // 0x20 - '\u0020','\u0021','\u0022','\u0023','\u0024','\u0025','\u0026','\u0027', - // 0x28 - '\u0028','\u0029','\u002A','\u002B','\u002C','\u002D','\u002E','\u002F', - // 0x30 - '\u0030','\u0031','\u0032','\u0033','\u0034','\u0035','\u0036','\u0037', - // 0x38 - '\u0038','\u0039','\u003A','\u003B','\u003C','\u003D','\u003E','\u003F', - // 0x40 - '\u0040','\u0041','\u0042','\u0043','\u0044','\u0045','\u0046','\u0047', - // 0x48 - '\u0048','\u0049','\u004A','\u004B','\u004C','\u004D','\u004E','\u004F', - // 0x50 - '\u0050','\u0051','\u0052','\u0053','\u0054','\u0055','\u0056','\u0057', - // 0x58 - '\u0058','\u0059','\u005A','\u005B','\u005C','\u005D','\u005E','\u005F', - // 0x60 - '\u0060','\u0061','\u0062','\u0063','\u0064','\u0065','\u0066','\u0067', - // 0x68 - '\u0068','\u0069','\u006A','\u006B','\u006C','\u006D','\u006E','\u006F', - // 0x70 - '\u0070','\u0071','\u0072','\u0073','\u0074','\u0075','\u0076','\u0077', - // 0x78 - '\u0078','\u0079','\u007A','\u007B','\u007C','\u007D','\u007E','\u2588', - // 0x80 - '\u00C4','\u00C5','\u00C7','\u00C9','\u00D1','\u00D6','\u00DC','\u00E1', - // 0x88 - '\u00E0','\u00E2','\u00E4','\u00E3','\u00E5','\u00E7','\u00E9','\u00E8', - // 0x90 - '\u00EA','\u00EB','\u00ED','\u00EC','\u00EE','\u00EF','\u00F1','\u00F3', - // 0x98 - '\u00F2','\u00F4','\u00F6','\u00F5','\u00FA','\u00F9','\u00FB','\u00FC', - // 0xA0 - '\u2020','\u00B0','\u00A2','\u00A3','\u00A7','\u2022','\u00B6','\u00DF', - // 0xA8 - '\u00AE','\u00A9','\u2122','\u00B4','\u00A8','\u2260','\u00C6','\u00D8', - // 0xB0 - '\u221E','\u00B1','\u2264','\u2265','\u00A5','\u00B5','\u2202','\u2211', - // 0xB8 - '\u220F','\u03C0','\u222B','\u00AA','\u00BA','\u03A9','\u00E6','\u00F8', - // 0xC0 - '\u00BF','\u00A1','\u00AC','\u221A','\u0192','\u2248','\u2206','\u00AB', - // 0xC8 - '\u00BB','\u2026','\u00A0','\u00C0','\u00C3','\u00D5','\u0152','\u0153', - // 0xD0 - '\u2013','\u2014','\u201C','\u201D','\u2018','\u2019','\u00F7','\u25CA', - // 0xD8 - '\u00FF','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000', - // 0xE0 - '\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000', - // 0xE8 - '\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000', - // 0xF0 - '\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000', - // 0xF8 - '\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000' - }; - - /// - /// Converts a LisaRoman character to an Unicode character - /// - /// Unicode character. - /// LisaRoman character. - static char GetChar(byte character) - { - return LisaRomanTable[character]; - } - - /// - /// Converts a Unicode character to an LisaRoman character - /// - /// LisaRoman character. - /// Unicode character. - static byte GetByte(char character) - { - switch(character) { - case '\u0000': - return 0x00; - case '\u0001': - return 0x01; - case '\u0002': - return 0x02; - case '\u0003': - return 0x03; - case '\u0004': - return 0x04; - case '\u0005': - return 0x05; - case '\u0006': - return 0x06; - case '\u0007': - return 0x07; - case '\u0008': - return 0x08; - case '\u0009': - return 0x09; - case '\u000A': - return 0x0A; - case '\u000B': - return 0x0B; - case '\u000C': - return 0x0C; - case '\u000D': - return 0x0D; - case '\u000E': - return 0x0E; - case '\u000F': - return 0x0F; - case '\u0010': - return 0x10; - case '\u0011': - return 0x11; - case '\u0012': - return 0x12; - case '\u0013': - return 0x13; - case '\u0014': - return 0x14; - case '\u0015': - return 0x15; - case '\u0016': - return 0x16; - case '\u0017': - return 0x17; - case '\u0018': - return 0x18; - case '\u0019': - return 0x19; - case '\u001A': - return 0x1A; - case '\u001B': - return 0x1B; - case '\u001C': - return 0x1C; - case '\u001D': - return 0x1D; - case '\u001E': - return 0x1E; - case '\u001F': - return 0x1F; - case '\u0020': - return 0x20; - case '\u0021': - return 0x21; - case '\u0022': - return 0x22; - case '\u0023': - return 0x23; - case '\u0024': - return 0x24; - case '\u0025': - return 0x25; - case '\u0026': - return 0x26; - case '\u0027': - return 0x27; - case '\u0028': - return 0x28; - case '\u0029': - return 0x29; - case '\u002A': - return 0x2A; - case '\u002B': - return 0x2B; - case '\u002C': - return 0x2C; - case '\u002D': - return 0x2D; - case '\u002E': - return 0x2E; - case '\u002F': - return 0x2F; - case '\u0030': - return 0x30; - case '\u0031': - return 0x31; - case '\u0032': - return 0x32; - case '\u0033': - return 0x33; - case '\u0034': - return 0x34; - case '\u0035': - return 0x35; - case '\u0036': - return 0x36; - case '\u0037': - return 0x37; - case '\u0038': - return 0x38; - case '\u0039': - return 0x39; - case '\u003A': - return 0x3A; - case '\u003B': - return 0x3B; - case '\u003C': - return 0x3C; - case '\u003D': - return 0x3D; - case '\u003E': - return 0x3E; - case '\u003F': - return 0x3F; - case '\u0040': - return 0x40; - case '\u0041': - return 0x41; - case '\u0042': - return 0x42; - case '\u0043': - return 0x43; - case '\u0044': - return 0x44; - case '\u0045': - return 0x45; - case '\u0046': - return 0x46; - case '\u0047': - return 0x47; - case '\u0048': - return 0x48; - case '\u0049': - return 0x49; - case '\u004A': - return 0x4A; - case '\u004B': - return 0x4B; - case '\u004C': - return 0x4C; - case '\u004D': - return 0x4D; - case '\u004E': - return 0x4E; - case '\u004F': - return 0x4F; - case '\u0050': - return 0x50; - case '\u0051': - return 0x51; - case '\u0052': - return 0x52; - case '\u0053': - return 0x53; - case '\u0054': - return 0x54; - case '\u0055': - return 0x55; - case '\u0056': - return 0x56; - case '\u0057': - return 0x57; - case '\u0058': - return 0x58; - case '\u0059': - return 0x59; - case '\u005A': - return 0x5A; - case '\u005B': - return 0x5B; - case '\u005C': - return 0x5C; - case '\u005D': - return 0x5D; - case '\u005E': - return 0x5E; - case '\u005F': - return 0x5F; - case '\u0060': - return 0x60; - case '\u0061': - return 0x61; - case '\u0062': - return 0x62; - case '\u0063': - return 0x63; - case '\u0064': - return 0x64; - case '\u0065': - return 0x65; - case '\u0066': - return 0x66; - case '\u0067': - return 0x67; - case '\u0068': - return 0x68; - case '\u0069': - return 0x69; - case '\u006A': - return 0x6A; - case '\u006B': - return 0x6B; - case '\u006C': - return 0x6C; - case '\u006D': - return 0x6D; - case '\u006E': - return 0x6E; - case '\u006F': - return 0x6F; - case '\u0070': - return 0x70; - case '\u0071': - return 0x71; - case '\u0072': - return 0x72; - case '\u0073': - return 0x73; - case '\u0074': - return 0x74; - case '\u0075': - return 0x75; - case '\u0076': - return 0x76; - case '\u0077': - return 0x77; - case '\u0078': - return 0x78; - case '\u0079': - return 0x79; - case '\u007A': - return 0x7A; - case '\u007B': - return 0x7B; - case '\u007C': - return 0x7C; - case '\u007D': - return 0x7D; - case '\u007E': - return 0x7E; - case '\u2588': - return 0x7F; - case '\u00C4': - return 0x80; - case '\u00C5': - return 0x81; - case '\u00C7': - return 0x82; - case '\u00C9': - return 0x83; - case '\u00D1': - return 0x84; - case '\u00D6': - return 0x85; - case '\u00DC': - return 0x86; - case '\u00E1': - return 0x87; - case '\u00E0': - return 0x88; - case '\u00E2': - return 0x89; - case '\u00E4': - return 0x8A; - case '\u00E3': - return 0x8B; - case '\u00E5': - return 0x8C; - case '\u00E7': - return 0x8D; - case '\u00E9': - return 0x8E; - case '\u00E8': - return 0x8F; - case '\u00EA': - return 0x90; - case '\u00EB': - return 0x91; - case '\u00ED': - return 0x92; - case '\u00EC': - return 0x93; - case '\u00EE': - return 0x94; - case '\u00EF': - return 0x95; - case '\u00F1': - return 0x96; - case '\u00F3': - return 0x97; - case '\u00F2': - return 0x98; - case '\u00F4': - return 0x99; - case '\u00F6': - return 0x9A; - case '\u00F5': - return 0x9B; - case '\u00FA': - return 0x9C; - case '\u00F9': - return 0x9D; - case '\u00FB': - return 0x9E; - case '\u00FC': - return 0x9F; - case '\u2020': - return 0xA0; - case '\u00B0': - return 0xA1; - case '\u00A2': - return 0xA2; - case '\u00A3': - return 0xA3; - case '\u00A7': - return 0xA4; - case '\u2022': - return 0xA5; - case '\u00B6': - return 0xA6; - case '\u00DF': - return 0xA7; - case '\u00AE': - return 0xA8; - case '\u00A9': - return 0xA9; - case '\u2122': - return 0xAA; - case '\u00B4': - return 0xAB; - case '\u00A8': - return 0xAC; - case '\u2260': - return 0xAD; - case '\u00C6': - return 0xAE; - case '\u00D8': - return 0xAF; - case '\u221E': - return 0xB0; - case '\u00B1': - return 0xB1; - case '\u2264': - return 0xB2; - case '\u2265': - return 0xB3; - case '\u00A5': - return 0xB4; - case '\u00B5': - return 0xB5; - case '\u2202': - return 0xB6; - case '\u2211': - return 0xB7; - case '\u220F': - return 0xB8; - case '\u03C0': - return 0xB9; - case '\u222B': - return 0xBA; - case '\u00AA': - return 0xBB; - case '\u00BA': - return 0xBC; - case '\u03A9': - return 0xBD; - case '\u00E6': - return 0xBE; - case '\u00F8': - return 0xBF; - case '\u00BF': - return 0xC0; - case '\u00A1': - return 0xC1; - case '\u00AC': - return 0xC2; - case '\u221A': - return 0xC3; - case '\u0192': - return 0xC4; - case '\u2248': - return 0xC5; - case '\u2206': - return 0xC6; - case '\u00AB': - return 0xC7; - case '\u00BB': - return 0xC8; - case '\u2026': - return 0xC9; - case '\u00A0': - return 0xCA; - case '\u00C0': - return 0xCB; - case '\u00C3': - return 0xCC; - case '\u00D5': - return 0xCD; - case '\u0152': - return 0xCE; - case '\u0153': - return 0xCF; - case '\u2013': - return 0xD0; - case '\u2014': - return 0xD1; - case '\u201C': - return 0xD2; - case '\u201D': - return 0xD3; - case '\u2018': - return 0xD4; - case '\u2019': - return 0xD5; - case '\u00F7': - return 0xD6; - case '\u25CA': - return 0xD7; - case '\u00FF': - return 0xD8; - default: - // Fallback to '?' - return 0x3F; - } - } - } -} diff --git a/Claunia.Encoding/ChangeLog b/Claunia.Encoding/ChangeLog index 3deb2c5..25e61e8 100644 --- a/Claunia.Encoding/ChangeLog +++ b/Claunia.Encoding/ChangeLog @@ -1,3 +1,10 @@ +2016-08-19 Natalia Portillo + + * AtariST.cs: + * Encoding.cs: + * AtariST_1.cs: + * Claunia.Encoding.csproj: Added Atari ST encoding. + 2016-08-19 Natalia Portillo * Pangrams.cs: Added XML documentation. diff --git a/Claunia.Encoding/Claunia.Encoding.csproj b/Claunia.Encoding/Claunia.Encoding.csproj index 955c41a..228d2ba 100644 --- a/Claunia.Encoding/Claunia.Encoding.csproj +++ b/Claunia.Encoding/Claunia.Encoding.csproj @@ -37,6 +37,7 @@ + diff --git a/Claunia.Encoding/Encoding.cs b/Claunia.Encoding/Encoding.cs index 6372acd..c474d45 100644 --- a/Claunia.Encoding/Encoding.cs +++ b/Claunia.Encoding/Encoding.cs @@ -30,6 +30,7 @@ namespace Claunia.Encoding { public static System.Text.Encoding LisaEncoding = new LisaRoman(); public static System.Text.Encoding AtariEncoding = new ATASCII(); + public static System.Text.Encoding AtariSTEncoding = new AtariST(); } }