make_tables.rs

use std::collections::{HashMap, HashSet};
use std::iter::Iterator;

fn main() {
    println!("pub const INVALID_VALUE: u8 = 255;");

    // A-Z
    let standard_alphabet: Vec<u8> = (0x41..0x5B)
        // a-z
        .chain(0x61..0x7B)
        // 0-9
        .chain(0x30..0x3A)
        // +
        .chain(0x2B..0x2C)
        // /
        .chain(0x2F..0x30)
        .collect();
    print_encode_table(&standard_alphabet, "STANDARD_ENCODE", 0);
    print_decode_table(&standard_alphabet, "STANDARD_DECODE", 0);

    // A-Z
    let url_alphabet: Vec<u8> = (0x41..0x5B)
        // a-z
        .chain(0x61..0x7B)
        // 0-9
        .chain(0x30..0x3A)
        // -
        .chain(0x2D..0x2E)
        // _
        .chain(0x5F..0x60)
        .collect();
    print_encode_table(&url_alphabet, "URL_SAFE_ENCODE", 0);
    print_decode_table(&url_alphabet, "URL_SAFE_DECODE", 0);

    // ./0123456789
    let crypt_alphabet: Vec<u8> = (b'.'..(b'9' + 1))
        // A-Z
        .chain(b'A'..(b'Z' + 1))
        // a-z
        .chain(b'a'..(b'z' + 1))
        .collect();
    print_encode_table(&crypt_alphabet, "CRYPT_ENCODE", 0);
    print_decode_table(&crypt_alphabet, "CRYPT_DECODE", 0);

    // ./
    let bcrypt_alphabet: Vec<u8> = (b'.'..(b'/' + 1))
        // A-Z
        .chain(b'A'..(b'Z' + 1))
        // a-z
        .chain(b'a'..(b'z' + 1))
        // 0-9
        .chain(b'0'..(b'9' + 1))
        .collect();
    print_encode_table(&bcrypt_alphabet, "BCRYPT_ENCODE", 0);
    print_decode_table(&bcrypt_alphabet, "BCRYPT_DECODE", 0);

    // A-Z
    let imap_alphabet: Vec<u8> = (0x41..0x5B)
        // a-z
        .chain(0x61..0x7B)
        // 0-9
        .chain(0x30..0x3A)
        // +
        .chain(0x2B..0x2C)
        // ,
        .chain(0x2C..0x2D)
        .collect();
    print_encode_table(&imap_alphabet, "IMAP_MUTF7_ENCODE", 0);
    print_decode_table(&imap_alphabet, "IMAP_MUTF7_DECODE", 0);

    // '!' - '-'
    let binhex_alphabet: Vec<u8> = (0x21..0x2E)
        // 0-9
        .chain(0x30..0x3A)
        // @-N
        .chain(0x40..0x4F)
        // P-V
        .chain(0x50..0x57)
        // X-[
        .chain(0x58..0x5C)
        // `-f
        .chain(0x60..0x66)
        // h-m
        .chain(0x68..0x6E)
        // p-r
        .chain(0x70..0x73)
        .collect();
    print_encode_table(&binhex_alphabet, "BINHEX_ENCODE", 0);
    print_decode_table(&binhex_alphabet, "BINHEX_DECODE", 0);
}

fn print_encode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
    check_alphabet(alphabet);
    println!("#[rustfmt::skip]");
    println!(
        "{:width$}pub const {}: &[u8; 64] = &[",
        "",
        const_name,
        width = indent_depth
    );

    for (i, b) in alphabet.iter().enumerate() {
        println!(
            "{:width$}{}, // input {} (0x{:X}) => '{}' (0x{:X})",
            "",
            b,
            i,
            i,
            String::from_utf8(vec![*b as u8]).unwrap(),
            b,
            width = indent_depth + 4
        );
    }

    println!("{:width$}];", "", width = indent_depth);
}

fn print_decode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
    check_alphabet(alphabet);
    // map of alphabet bytes to 6-bit morsels
    let mut input_to_morsel = HashMap::<u8, u8>::new();

    // standard base64 alphabet bytes, in order
    for (morsel, ascii_byte) in alphabet.iter().enumerate() {
        // truncation cast is fine here
        let _ = input_to_morsel.insert(*ascii_byte, morsel as u8);
    }

    println!("#[rustfmt::skip]");
    println!(
        "{:width$}pub const {}: &[u8; 256] = &[",
        "",
        const_name,
        width = indent_depth
    );
    for ascii_byte in 0..256 {
        let (value, comment) = match input_to_morsel.get(&(ascii_byte as u8)) {
            None => (
                "INVALID_VALUE".to_string(),
                format!("input {} (0x{:X})", ascii_byte, ascii_byte),
            ),
            Some(v) => (
                format!("{}", *v),
                format!(
                    "input {} (0x{:X} char '{}') => {} (0x{:X})",
                    ascii_byte,
                    ascii_byte,
                    String::from_utf8(vec![ascii_byte as u8]).unwrap(),
                    *v,
                    *v
                ),
            ),
        };

        println!(
            "{:width$}{}, // {}",
            "",
            value,
            comment,
            width = indent_depth + 4
        );
    }
    println!("{:width$}];", "", width = indent_depth);
}

fn check_alphabet(alphabet: &[u8]) {
    // ensure all characters are distinct
    assert_eq!(64, alphabet.len());
    let mut set: HashSet<u8> = HashSet::new();
    set.extend(alphabet);
    assert_eq!(64, set.len());

    // must be ASCII to be valid as single UTF-8 bytes
    for &b in alphabet {
        assert!(b <= 0x7F_u8);
        // = is assumed to be padding, so cannot be used as a symbol
        assert_ne!(b'=', b);
    }
}