claunia/Claunia.Encoding
1
0
Fork 0
mirror of https://github.com/claunia/Claunia.Encoding.git synced 2025-12-16 19:24:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

* README.md:

Browse Source 
* Claunia.Encoding/ATASCII.cs:
	* Claunia.Encoding.Tests/ATASCII.cs:
	  Added ATASCII.

	* Claunia.Encoding/Encoding.cs:
	* Claunia.Encoding/Claunia.Encoding.csproj:
	* Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj:
	  A
This commit is contained in:
Natalia Portillo
2016-08-19 00:59:19 +01:00
parent 7b7506cf94
commit 55b42ee99c
8 changed files with 879 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
Claunia.Encoding.Tests/ATASCII.cs
View File

@@ -23,14 +23,87 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // 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 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE. // THE SOFTWARE.
using System;
using NUnit.Framework;
namespace Claunia.Encoding.Tests namespace Claunia.Encoding.Tests
{ {
[TestFixture]
public class ATASCII public class ATASCII
{ {
public ATASCII() 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, 0x7C };
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 Graphics = "├┘┤┐╱╲◢▗◣▝▘▂▖┌─┼●▄▎┬┴▌└";
readonly byte[] GraphicsBytes = { 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0E, 0x0F, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1A};
const string Arrows = "↑↓←→↰◀▶";
readonly byte[] ArrowsBytes = { 0x1C, 0x1D, 0x1E, 0x1F, 0x7D, 0x7E, 0x7F };
const string Decks = "♥♣♦♠";
readonly byte[] DecksBytes = { 0x00, 0x10, 0x60, 0x7B };
[Test]
public void UnicodeToAtari()
{ {
byte[] byteArray;
byteArray = Encoding.AtariEncoding.GetBytes(Punctuations);
Assert.AreEqual(PunctuationsBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(Digits);
Assert.AreEqual(DigitsBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(UpperLatin);
Assert.AreEqual(UpperLatinBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(LowerLatin);
Assert.AreEqual(LowerLatinBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(Graphics);
Assert.AreEqual(GraphicsBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(Arrows);
Assert.AreEqual(ArrowsBytes, byteArray);
byteArray = Encoding.AtariEncoding.GetBytes(Decks);
Assert.AreEqual(DecksBytes, byteArray);
}
[Test]
public void AtariToUnicode()
{
string testString;
testString = Encoding.AtariEncoding.GetString(PunctuationsBytes);
Assert.AreEqual(Punctuations, testString);
testString = Encoding.AtariEncoding.GetString(DigitsBytes);
Assert.AreEqual(Digits, testString);
testString = Encoding.AtariEncoding.GetString(UpperLatinBytes);
Assert.AreEqual(UpperLatin, testString);
testString = Encoding.AtariEncoding.GetString(LowerLatinBytes);
Assert.AreEqual(LowerLatin, testString);
testString = Encoding.AtariEncoding.GetString(GraphicsBytes);
Assert.AreEqual(Graphics, testString);
testString = Encoding.AtariEncoding.GetString(ArrowsBytes);
Assert.AreEqual(Arrows, testString);
testString = Encoding.AtariEncoding.GetString(DecksBytes);
Assert.AreEqual(Decks, testString);
}
[Test]
public void AtariPangrams()
{
byte[] byteArray;
string testString;
byteArray = Encoding.AtariEncoding.GetBytes(Pangrams.English);
testString = Encoding.AtariEncoding.GetString(byteArray);
Assert.AreEqual(Pangrams.English, testString);
} }
} }
} }

6
Claunia.Encoding.Tests/ChangeLog
View File

@@ -1,3 +1,9 @@
2016-08-19 Natalia Portillo <claunia@claunia.com>
* ATASCII.cs: Added ATASCII.
* Claunia.Encoding.Tests.csproj: A
2016-08-19 Natalia Portillo <claunia@claunia.com> 2016-08-19 Natalia Portillo <claunia@claunia.com>
* LisaRoman.cs: Code cleanup. * LisaRoman.cs: Code cleanup.

1
Claunia.Encoding.Tests/Claunia.Encoding.Tests.csproj
View File

@@ -34,6 +34,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="LisaRoman.cs" /> <Compile Include="LisaRoman.cs" />
<Compile Include="ATASCII.cs" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="packages.config" /> <None Include="packages.config" />

787
Claunia.Encoding/ATASCII.cs
View File

@@ -23,14 +23,795 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // 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 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE. // THE SOFTWARE.
using System; using System;
namespace Claunia.Encoding namespace Claunia.Encoding
{ {
public class ATASCII /// <summary>
/// Represents an Apple Lisa character encoding of Unicode characters.
/// </summary>
public class ATASCII : System.Text.Encoding
{ {
public ATASCII() const string _bodyname = "atascii";
const int _codepage = 0;
const string _encodingname = "ATARI Standard Code for Information Interchange";
const string _headername = "atascii";
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;
/// <summary>
/// Gets a value indicating whether the current encoding can be used by browser clients for displaying content.
/// </summary>
public bool IsBrowserDisplay {
get { return browserDisplay; }
}
/// <summary>
/// Gets a value indicating whether the current encoding can be used by browser clients for saving content.
/// </summary>
public bool IsBrowserSave {
get { return browserSave; }
}
/// <summary>
/// Gets a value indicating whether the current encoding can be used by mail and news clients for displaying content.
/// </summary>
public bool IsMailNewsDisplay {
get { return mailNewsDisplay; }
}
/// <summary>
/// Gets a value indicating whether the current encoding can be used by mail and news clients for saving content.
/// </summary>
public bool IsMailNewsSave {
get { return mailNewsSave; }
}
/// <summary>
/// Gets a value indicating whether the current encoding is read-only.
/// </summary>
/// <value>The is single byte.</value>
public bool IsReadOnly {
get { return readOnly; }
}
/// <summary>
/// Gets a value indicating whether the current encoding uses single-byte code points.
/// </summary>
public bool IsSingleByte {
get { return singleByte; }
}
/// <summary>
/// Gets the code page identifier of the current Encoding.
/// </summary>
public int CodePage {
get { return _codepage; }
}
/// <summary>
/// Gets a name for the current encoding that can be used with mail agent body tags
/// </summary>
public string BodyName {
get { return _bodyname; }
}
/// <summary>
/// Gets a name for the current encoding that can be used with mail agent header tags
/// </summary>
public string HeaderName {
get { return _headername; }
}
/// <summary>
/// Ggets the name registered with the Internet Assigned Numbers Authority (IANA) for the current encoding.
/// </summary>
public override string WebName {
get { return _webname; }
}
/// <summary>
/// Gets the human-readable description of the current encoding.
/// </summary>
public string EncodingName {
get { return _encodingname; }
}
/// <summary>
/// Gets the Windows operating system code page that most closely corresponds to the current encoding.
/// </summary>
public int WindowsCodePage {
get { return _windowsCodepage; }
}
/// <summary>
/// Calculates the number of bytes produced by encoding the characters in the specified <see cref="string"/>.
/// </summary>
/// <returns>The number of bytes produced by encoding the specified characters.</returns>
/// <param name="s">The <see cref="string"/> containing the set of characters to encode.</param>
public override int GetByteCount(string s)
{ {
if(s == null)
throw new ArgumentNullException(nameof(s));
return s.Length;
}
/// <summary>
/// Calculates the number of bytes produced by encoding a set of characters from the specified character array.
/// </summary>
/// <returns>The number of bytes produced by encoding the specified characters.</returns>
/// <param name="chars">The character array containing the set of characters to encode.</param>
/// <param name="index">The index of the first character to encode.</param>
/// <param name="count">The number of characters to encode.</param>
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;
}
/// <summary>
/// Calculates the number of bytes produced by encoding all the characters in the specified character array.
/// </summary>
/// <returns>The number of bytes produced by encoding all the characters in the specified character array.</returns>
/// <param name="chars">The character array containing the characters to encode.</param>
public override int GetByteCount(char[] chars)
{
if(chars == null)
throw new ArgumentNullException(nameof(chars));
return chars.Length;
}
/// <summary>
/// Encodes a set of characters from the specified <see cref="string"/> into the specified byte array.
/// </summary>
/// <returns>The actual number of bytes written into bytes.</returns>
/// <param name="s">The <see cref="string"/> containing the set of characters to encode.</param>
/// <param name="charIndex">The index of the first character to encode.</param>
/// <param name="charCount">The number of characters to encode.</param>
/// <param name="bytes">The byte array to contain the resulting sequence of bytes.</param>
/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes.</param>
public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
{
return GetBytes(s.ToCharArray(), charIndex, charCount, bytes, byteIndex);
}
/// <summary>
/// Encodes all the characters in the specified string into a sequence of bytes.
/// </summary>
/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
/// <param name="s">The string containing the characters to encode.</param>
public override byte[] GetBytes(string s)
{
if(s == null)
throw new ArgumentNullException(nameof(s));
return GetBytes(s.ToCharArray(), 0, s.Length);
}
/// <summary>
/// Encodes a set of characters from the specified character array into the specified byte array.
/// </summary>
/// <returns>The actual number of bytes written into bytes.</returns>
/// <param name="chars">The character array containing the set of characters to encode.</param>
/// <param name="charIndex">The index of the first character to encode.</param>
/// <param name="charCount">The number of characters to encode.</param>
/// <param name="bytes">The byte array to contain the resulting sequence of bytes.</param>
/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes.</param>
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;
}
/// <summary>
/// Encodes a set of characters from the specified character array into a sequence of bytes.
/// </summary>
/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
/// <param name="chars">The character array containing the set of characters to encode.</param>
/// <param name="index">The index of the first character to encode.</param>
/// <param name="count">The number of characters to encode.</param>
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;
}
/// <summary>
/// Encodes all the characters in the specified character array into a sequence of bytes.
/// </summary>
/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
/// <param name="chars">The character array containing the characters to encode.</param>
public override byte[] GetBytes(char[] chars)
{
return GetBytes(chars, 0, chars.Length);
}
/// <summary>
/// Calculates the number of characters produced by decoding all the bytes in the specified byte array.
/// </summary>
/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
public override int GetCharCount(byte[] bytes)
{
return GetCharCount(bytes, 0, bytes.Length);
}
/// <summary>
/// Calculates the number of characters produced by decoding a sequence of bytes from the specified byte array.
/// </summary>
/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
/// <param name="index">The index of the first byte to decode.</param>
/// <param name="count">The number of bytes to decode.</param>
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;
}
/// <summary>
/// Decodes a sequence of bytes from the specified byte array into the specified character array.
/// </summary>
/// <returns>The actual number of characters written into chars.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
/// <param name="byteIndex">The index of the first byte to decode.</param>
/// <param name="byteCount">The number of bytes to decode.</param>
/// <param name="chars">The character array to contain the resulting set of characters.</param>
/// <param name="charIndex">The index at which to start writing the resulting set of characters.</param>
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;
}
/// <summary>
/// Decodes all the bytes in the specified byte array into a set of characters.
/// </summary>
/// <returns>A character array containing the results of decoding the specified sequence of bytes.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
public override char[] GetChars(byte[] bytes)
{
return GetChars(bytes, 0, bytes.Length);
}
/// <summary>
/// Decodes a sequence of bytes from the specified byte array into a set of characters.
/// </summary>
/// <returns>The chars.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
/// <param name="index">The index of the first byte to decode.</param>
/// <param name="count">The number of bytes to decode.</param>
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;
}
/// <summary>
/// Calculates the maximum number of bytes produced by encoding the specified number of characters.
/// </summary>
/// <returns>The maximum number of bytes produced by encoding the specified number of characters.</returns>
/// <param name="charCount">The number of characters to encode.</param>
public override int GetMaxByteCount(int charCount)
{
if(charCount < 0)
throw new ArgumentOutOfRangeException(nameof(charCount));
return charCount;
}
/// <summary>
/// Calculates the maximum number of characters produced by decoding the specified number of bytes.
/// </summary>
/// <returns>The maximum number of characters produced by decoding the specified number of bytes.</returns>
/// <param name="byteCount">The number of bytes to decode.</param>
public override int GetMaxCharCount(int byteCount)
{
if(byteCount < 0)
throw new ArgumentOutOfRangeException(nameof(byteCount));
return byteCount;
}
/// <summary>
/// Returns a sequence of bytes that specifies the encoding used.
/// </summary>
/// <returns>A byte array of length zero, as a preamble is not required.</returns>
public override byte[] GetPreamble()
{
return new byte[0];
}
/// <summary>
/// Decodes all the bytes in the specified byte array into a string.
/// </summary>
/// <returns>A string that contains the results of decoding the specified sequence of bytes.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
public string GetString(byte[] bytes)
{
return GetString(bytes, 0, bytes.Length);
}
/// <summary>
/// Decodes a sequence of bytes from the specified byte array into a string.
/// </summary>
/// <returns>A string that contains the results of decoding the specified sequence of bytes.</returns>
/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
/// <param name="index">The index of the first byte to decode.</param>
/// <param name="count">The number of bytes to decode.</param>
public override string GetString(byte[] bytes, int index, int count)
{
return new string(GetChars(bytes, index, count));
}
/// <summary>
/// The Lisa to Unicode character map.
/// MacRoman is a superset of ATASCII.
/// </summary>
static readonly char[] ATASCIITable = {
// 0x00
'\u2665','\u251C','\uFFFD','\u2518','\u2524','\u2510','\u2571','\u2572',
// 0x08
'\u25E2','\u2597','\u25E3','\u259D','\u2598','\uFFFD','\u2582','\u2596',
// 0x10
'\u2663','\u250C','\u2500','\u253C','\u25CF','\u2584','\u258E','\u252C',
// 0x18
'\u2534','\u258C','\u2514','\u241B','\u2191','\u2193','\u2190','\u2192',
// 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
'\u2666','\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','\u2660','\u007C','\u21B0','\u25C0','\u25B6',
// 0x80
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0x88
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0x90
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0x98
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xA0
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xA8
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xB0
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xB8
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xC0
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xC8
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xD0
'\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000','\u0000',
// 0xD8
'\u0000','\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'
};
/// <summary>
/// Converts a ATASCII character to an Unicode character
/// </summary>
/// <returns>Unicode character.</returns>
/// <param name="character">ATASCII character.</param>
static char GetChar(byte character)
{
return ATASCIITable[character];
}
/// <summary>
/// Converts a Unicode character to an ATASCII character
/// </summary>
/// <returns>ATASCII character.</returns>
/// <param name="character">Unicode character.</param>
static byte GetByte(char character)
{
switch(character) {
case '\u2665':
return 0x00;
case '\u251C':
return 0x01;
case '\u2518':
return 0x03;
case '\u2524':
return 0x04;
case '\u2510':
return 0x05;
case '\u2571':
return 0x06;
case '\u2572':
return 0x07;
case '\u25E2':
return 0x08;
case '\u2597':
return 0x09;
case '\u25E3':
return 0x0A;
case '\u259D':
return 0x0B;
case '\u2598':
return 0x0C;
case '\u2582':
return 0x0E;
case '\u2596':
return 0x0F;
case '\u2663':
return 0x10;
case '\u250C':
return 0x11;
case '\u2500':
return 0x12;
case '\u253C':
return 0x13;
case '\u25CF':
return 0x14;
case '\u2584':
return 0x15;
case '\u258E':
return 0x16;
case '\u252C':
return 0x17;
case '\u2534':
return 0x18;
case '\u258C':
return 0x19;
case '\u2514':
return 0x1A;
case '\u241B':
return 0x1B;
case '\u2191':
return 0x1C;
case '\u2193':
return 0x1D;
case '\u2190':
return 0x1E;
case '\u2192':
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 '\u2666':
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 '\u2660':
return 0x7B;
case '\u007C':
return 0x7C;
case '\u21B0':
return 0x7D;
case '\u25C0':
return 0x7E;
case '\u25B6':
return 0x7F;
default:
// Fallback to '?'
return 0x3F;
}
} }
} }
} }

7
Claunia.Encoding/ChangeLog
View File

@@ -1,3 +1,10 @@
2016-08-19 Natalia Portillo <claunia@claunia.com>
* ATASCII.cs: Added ATASCII.
* Encoding.cs:
* Claunia.Encoding.csproj: A
2016-08-18 Natalia Portillo <claunia@claunia.com> 2016-08-18 Natalia Portillo <claunia@claunia.com>
* LisaRoman.cs: Added missing XML documentation and emptied * LisaRoman.cs: Added missing XML documentation and emptied

1
Claunia.Encoding/Claunia.Encoding.csproj
View File

@@ -36,6 +36,7 @@
<Compile Include="LisaRoman.cs" /> <Compile Include="LisaRoman.cs" />
<Compile Include="Encoding.cs" /> <Compile Include="Encoding.cs" />
<Compile Include="Pangrams.cs" /> <Compile Include="Pangrams.cs" />
<Compile Include="ATASCII.cs" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<EmbeddedResource Include="..\LICENSE.MIT"> <EmbeddedResource Include="..\LICENSE.MIT">

1
Claunia.Encoding/Encoding.cs
View File

@@ -29,6 +29,7 @@ namespace Claunia.Encoding
public static class Encoding public static class Encoding
{ {
public static System.Text.Encoding LisaEncoding = new LisaRoman(); public static System.Text.Encoding LisaEncoding = new LisaRoman();
public static System.Text.Encoding AtariEncoding = new ATASCII();
} }
} }

3
README.md
View File

@@ -7,4 +7,5 @@ Copyright © 2016 Natalia Portillo <claunia@claunia.com>
Supported encodings Supported encodings
============================== ==============================
* Apple Lisa * Apple Lisa
* Atari Standard Code for Information Interchange (ATASCII)