encoding8 0.3.2

/// `to_ascii` makes a copy of a byte encoded as EBCDIC as it's ASCII equivalent.
/// use `make_ascii` if you want to convert in-place
#[inline]
pub fn to_ascii(b: u8) -> u8 {
    match b {
        0x0 => 0x0,
        0x1 => 0x1,
        0x2 => 0x2,
        0x3 => 0x3,
        0x4 => 0x85,
        0x5 => 0x9,
        0x6 => 0x86,
        0x7 => 0x7f,
        0x8 => 0x87,
        0x9 => 0x8d,
        0xa => 0x8e,
        0xb => 0xb,
        0xc => 0xc,
        0xd => 0xd,
        0xe => 0xe,
        0xf => 0xf,
        0x10 => 0x10,
        0x11 => 0x11,
        0x12 => 0x12,
        0x13 => 0x13,
        0x14 => 0x8f,
        0x15 => 0xa,
        0x16 => 0x8,
        0x17 => 0x97,
        0x18 => 0x18,
        0x19 => 0x19,
        0x1a => 0x9c,
        0x1b => 0x9d,
        0x1c => 0x1c,
        0x1d => 0x1d,
        0x1e => 0x1e,
        0x1f => 0x1f,
        0x20 => 0x80,
        0x21 => 0x81,
        0x22 => 0x82,
        0x23 => 0x83,
        0x24 => 0x84,
        0x25 => 0x92,
        0x26 => 0x17,
        0x27 => 0x1b,
        0x28 => 0x88,
        0x29 => 0x89,
        0x2a => 0x8a,
        0x2b => 0x8b,
        0x2c => 0x8c,
        0x2d => 0x5,
        0x2e => 0x6,
        0x2f => 0x7,
        0x30 => 0x90,
        0x31 => 0x91,
        0x32 => 0x16,
        0x33 => 0x93,
        0x34 => 0x94,
        0x35 => 0x95,
        0x36 => 0x96,
        0x37 => 0x4,
        0x38 => 0x98,
        0x39 => 0x99,
        0x3a => 0x9a,
        0x3b => 0x9b,
        0x3c => 0x14,
        0x3d => 0x15,
        0x3e => 0x9e,
        0x3f => 0x1a,
        0x40 => 0x20,
        0x41 => 0xa0,
        0x42 => 0xe2,
        0x43 => 0xe4,
        0x44 => 0xe0,
        0x45 => 0xe1,
        0x46 => 0xe3,
        0x47 => 0xe5,
        0x48 => 0xe7,
        0x49 => 0xf1,
        0x4a => 0xa2,
        0x4b => 0x2e,
        0x4c => 0x3c,
        0x4d => 0x28,
        0x4e => 0x2b,
        0x4f => 0x7c,
        0x50 => 0x26,
        0x51 => 0xe9,
        0x52 => 0xea,
        0x53 => 0xeb,
        0x54 => 0xe8,
        0x55 => 0xed,
        0x56 => 0xee,
        0x57 => 0xef,
        0x58 => 0xec,
        0x59 => 0xdf,
        0x5a => 0x21,
        0x5b => 0x24,
        0x5c => 0x2a,
        0x5d => 0x29,
        0x5e => 0x3b,
        0x5f => 0x5e,
        0x60 => 0x2d,
        0x61 => 0x2f,
        0x62 => 0xc2,
        0x63 => 0xc4,
        0x64 => 0xc0,
        0x65 => 0xc1,
        0x66 => 0xc3,
        0x67 => 0xc5,
        0x68 => 0xc7,
        0x69 => 0xd1,
        0x6a => 0xa6,
        0x6b => 0x2c,
        0x6c => 0x25,
        0x6d => 0x5f,
        0x6e => 0x3e,
        0x6f => 0x3f,
        0x70 => 0xf8,
        0x71 => 0xc9,
        0x72 => 0xca,
        0x73 => 0xcb,
        0x74 => 0xc8,
        0x75 => 0xcd,
        0x76 => 0xce,
        0x77 => 0xcf,
        0x78 => 0xcc,
        0x79 => 0x60,
        0x7a => 0x3a,
        0x7b => 0x23,
        0x7c => 0x40,
        0x7d => 0x27,
        0x7e => 0x3d,
        0x7f => 0x22,
        0x80 => 0xd8,
        0x81 => 0x61,
        0x82 => 0x62,
        0x83 => 0x63,
        0x84 => 0x64,
        0x85 => 0x65,
        0x86 => 0x66,
        0x87 => 0x67,
        0x88 => 0x68,
        0x89 => 0x69,
        0x8a => 0xab,
        0x8b => 0xbb,
        0x8c => 0xf0,
        0x8d => 0xfd,
        0x8e => 0xfe,
        0x8f => 0xb1,
        0x90 => 0xb0,
        0x91 => 0x6a,
        0x92 => 0x6b,
        0x93 => 0x6c,
        0x94 => 0x6d,
        0x95 => 0x6e,
        0x96 => 0x6f,
        0x97 => 0x70,
        0x98 => 0x71,
        0x99 => 0x72,
        0x9a => 0xaa,
        0x9b => 0xba,
        0x9c => 0xe6,
        0x9d => 0xb8,
        0x9e => 0xc6,
        0x9f => 0xa4,
        0xa0 => 0xb5,
        0xa1 => 0x7e,
        0xa2 => 0x73,
        0xa3 => 0x74,
        0xa4 => 0x75,
        0xa5 => 0x76,
        0xa6 => 0x77,
        0xa7 => 0x78,
        0xa8 => 0x79,
        0xa9 => 0x7a,
        0xaa => 0xa1,
        0xab => 0xbf,
        0xac => 0xd0,
        0xad => 0x5b,
        0xae => 0xde,
        0xaf => 0xae,
        0xb0 => 0xac,
        0xb1 => 0xa3,
        0xb2 => 0xa5,
        0xb3 => 0xb7,
        0xb4 => 0xa9,
        0xb5 => 0xa7,
        0xb6 => 0xb6,
        0xb7 => 0xbc,
        0xb8 => 0xbd,
        0xb9 => 0xbe,
        0xba => 0xdd,
        0xbb => 0xa8,
        0xbc => 0xaf,
        0xbd => 0x5d,
        0xbe => 0xb4,
        0xbf => 0xd7,
        0xc0 => 0x7b,
        0xc1 => 0x41,
        0xc2 => 0x42,
        0xc3 => 0x43,
        0xc4 => 0x44,
        0xc5 => 0x45,
        0xc6 => 0x46,
        0xc7 => 0x47,
        0xc8 => 0x48,
        0xc9 => 0x49,
        0xca => 0xad,
        0xcb => 0xf4,
        0xcc => 0xf6,
        0xcd => 0xf2,
        0xce => 0xf3,
        0xcf => 0xf5,
        0xd0 => 0x7d,
        0xd1 => 0x4a,
        0xd2 => 0x4b,
        0xd3 => 0x4c,
        0xd4 => 0x4d,
        0xd5 => 0x4e,
        0xd6 => 0x4f,
        0xd7 => 0x50,
        0xd8 => 0x51,
        0xd9 => 0x52,
        0xda => 0xb9,
        0xdb => 0xfb,
        0xdc => 0xfc,
        0xdd => 0xf9,
        0xde => 0xfa,
        0xdf => 0xff,
        0xe0 => 0x5c,
        0xe1 => 0xf7,
        0xe2 => 0x53,
        0xe3 => 0x54,
        0xe4 => 0x55,
        0xe5 => 0x56,
        0xe6 => 0x57,
        0xe7 => 0x58,
        0xe8 => 0x59,
        0xe9 => 0x5a,
        0xea => 0xb2,
        0xeb => 0xd4,
        0xec => 0xd6,
        0xed => 0xd2,
        0xee => 0xd3,
        0xef => 0xd5,
        0xf0 => 0x30,
        0xf1 => 0x31,
        0xf2 => 0x32,
        0xf3 => 0x33,
        0xf4 => 0x34,
        0xf5 => 0x35,
        0xf6 => 0x36,
        0xf7 => 0x37,
        0xf8 => 0x38,
        0xf9 => 0x39,
        0xfa => 0xb3,
        0xfb => 0xdb,
        0xfc => 0xdc,
        0xfd => 0xd9,
        0xfe => 0xda,
        0xff => 0x9f,
        _ => unreachable!(),
    }
}


/// `make_ascii` converts a byte encoded as ASCII to it's EBDIC equivalent, in-place.
/// use `to_ascii` if you want to make a copy
pub fn make_ascii(bp: &mut u8) {
    *bp = to_ascii(*bp);
}

use super::ascii;

#[inline]
pub fn to_uppercase(b: u8) -> u8 {
    ascii::to_ebcdic(ascii::to_uppercase(to_ascii(b)))
}

#[inline]
pub fn to_lowercase(b: u8) -> u8 {
    ascii::to_ebcdic(ascii::to_lowercase(to_ascii(b)))
}