Internationalization C#

//-----------------------------------------------------------------------
// 
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// 
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
namespace CBM_Commander.Common.Encoding
{
    public class Petscii : System.Text.Encoding
    {
        public static PetsciiEncoder GetPetsciiEncoder()
        {
            return new PetsciiEncoder();
        }
        public static PetsciiDecoder GetPetsciiDecoder()
        {
            return new PetsciiDecoder();
        }
        public override int GetByteCount(
            char[] chars,
            int index,
            int count)
        {
            return GetPetsciiEncoder().GetByteCount(
                chars, index, count, false);
        }
        public override int GetBytes(
            char[] chars,
            int charIndex,
            int charCount,
            byte[] bytes,
            int byteIndex)
        {
            return GetPetsciiEncoder().GetBytes(
                chars, charIndex, charCount,
                bytes, byteIndex, false);
        }
        public override int GetCharCount(
            byte[] bytes,
            int index,
            int count)
        {
            return GetPetsciiDecoder().GetCharCount(
                bytes, index, count);
        }
        public override int GetChars(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            char[] chars,
            int charIndex)
        {
            return GetPetsciiDecoder().GetChars(
                bytes, byteIndex, byteCount,
                chars, charIndex);
        }
        public override int GetMaxByteCount(int charCount)
        {
            return charCount;
        }
        public override int GetMaxCharCount(int byteCount)
        {
            return byteCount;
        }
    }
}
//-----------------------------------------------------------------------
// 
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// 
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
namespace CBM_Commander.Common.Encoding
{
    public sealed class PetsciiDecoder : Decoder
    {
        private byte[] _newLine = null;
        private byte[] _space = null;
        internal PetsciiDecoder()
        {
            _newLine = ASCIIEncoding.ASCII.GetBytes("\n");
            _space = ASCIIEncoding.ASCII.GetBytes(" ");
        }
        public override int GetCharCount(
            byte[] bytes,
            int index,
            int count)
        {
            DecodeBytes(
                bytes, index,
                count, index);
            return count;
        }
        public override int GetChars(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            char[] chars,
            int charIndex)
        {
            char[] decodedChars =
                DecodeBytes(
                    bytes, byteIndex,
                    byteCount, charIndex);
            for (int i = byteIndex;
                i < (byteIndex + byteCount);
                i++)
            {
                chars[charIndex + (i - byteIndex)] =
                    decodedChars[i];
            }
            return byteCount;
        }
        private char[] DecodeBytes(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            int charIndex)
        {
            char[] results = null;
            List output = new List();
            byte[] translated = null;
            foreach (byte b in bytes)
            {
                output.AddRange(TranslateByte(b));
            }
            translated = output.ToArray();
            results =
                ASCIIEncoding.ASCII.GetChars(translated);
            return results;
        }
        /// 
        /// 
        /// 

        /// 
        /// 
        private byte[] TranslateByte(byte SourceByte)
        {
            switch (SourceByte & 0xff)
            {
                case 0x0a:
                case 0x0d:
                    return _newLine;
                case 0x40:
                case 0x60:
                    return new byte[] { SourceByte };
                case 0xa0:
                case 0xe0:
                    return _space;
                default:
                    switch (SourceByte & 0xe0)
                    {
                        case 0x40:
                        case 0x60:
                            return new byte[] { (byte)(SourceByte ^ (byte)0x20) };
                        case 0xc0:
                            return new byte[] { (byte)(SourceByte ^ (byte)0x80) };
                    }
                    return new byte[] { SourceByte };
            }
        }
    }
}
Petscii Encoder
//-----------------------------------------------------------------------
// 
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// 
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
namespace CBM_Commander.Common.Encoding
{
    public sealed class PetsciiEncoder : Encoder
    {
        private byte[] _newLine = null;
        private byte[] _space = null;
        private Dictionary
            _ascii = new Dictionary();
        internal PetsciiEncoder()
        {
            _newLine = ASCIIEncoding.ASCII.GetBytes("\n");
            _space = ASCIIEncoding.ASCII.GetBytes(" ");
            for (byte i = 0x00; i < 0xFF; i++)
            {
                char c = (char)i;
                _ascii.Add(c,
                    ASCIIEncoding.ASCII.GetBytes(
                        new char[] { c })[0]);
            }
        }
        public override int GetByteCount(
            char[] chars,
            int index,
            int count,
            bool flush)
        {
            List targetBytes = new List();
            byte[] sourceBytes =
                ASCIIEncoding.ASCII.GetBytes(chars);
            for (int i = index; i < (index + count); i++)
            {
                targetBytes.Add(
                    TranslateCharacter(sourceBytes[i]));
            }
            return targetBytes.Count;
        }
        public override int GetBytes(
            char[] chars,
            int charIndex,
            int charCount,
            byte[] bytes,
            int byteIndex,
            bool flush)
        {
            List targetBytes = new List();
            byte[] sourceBytes =
                ASCIIEncoding.ASCII.GetBytes(chars);
            foreach (byte b in sourceBytes)
            {
                targetBytes.Add(TranslateCharacter(b));
            }
            for (
                int i = charIndex;
                i < (charIndex + charCount);
                i++)
            {
                bytes[byteIndex + (i - charIndex)] =
                    targetBytes[i];
            }
            return charCount;
        }
        private byte TranslateCharacter(byte Character)
        {
            if (
                Character >= 0x5B &&
                Character <= 0x7E)
            {
                return (byte)(Character ^ 0x20);
            }
            else if (
                Character >= _ascii['A'] &&
                Character <= _ascii['Z'])
            {
                return (byte)(Character | 0x80);
            }
            else if (Character == _newLine[0])
            {
                return 0x0D;
            }
            return Character;
        }
    }
}