RustPython/parser/build.rs

use std::fmt::Write as _;
use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Write};
use std::path::PathBuf;
use std::process::{Command, ExitCode};
use tiny_keccak::{Hasher, Sha3};

fn main() -> ExitCode {
    if let Err(exit_code) = check_lalrpop("src/python.lalrpop", "src/python.rs") {
        return exit_code;
    }
    gen_phf();
    ExitCode::SUCCESS
}

fn check_lalrpop(source: &str, generated: &str) -> Result<(), ExitCode> {
    println!("cargo:rerun-if-changed={source}");

    let sha_prefix = "// sha3: ";
    let sha3_line = BufReader::with_capacity(128, File::open(generated).unwrap())
        .lines()
        .find_map(|line| {
            let line = line.unwrap();
            line.starts_with(sha_prefix).then_some(line)
        })
        .expect("no sha3 line?");
    let expected_sha3_str = sha3_line.strip_prefix(sha_prefix).unwrap();

    let actual_sha3 = {
        let mut hasher = Sha3::v256();
        let mut f = BufReader::new(File::open(source).unwrap());
        let mut line = String::new();
        while f.read_line(&mut line).unwrap() != 0 {
            if line.ends_with('\n') {
                line.pop();
                if line.ends_with('\r') {
                    line.pop();
                }
            }
            hasher.update(line.as_bytes());
            hasher.update(b"\n");
            line.clear();
        }
        let mut hash = [0u8; 32];
        hasher.finalize(&mut hash);
        hash
    };

    if sha_equal(expected_sha3_str, &actual_sha3) {
        return Ok(());
    }
    match Command::new("lalrpop").arg(source).status() {
        Ok(stat) if stat.success() => Ok(()),
        Ok(stat) => {
            eprintln!("failed to execute lalrpop; exited with {stat}");
            let exit_code = stat.code().map(|v| (v % 256) as u8).unwrap_or(1);
            Err(ExitCode::from(exit_code))
        }
        Err(e) if e.kind() == io::ErrorKind::NotFound => {
            eprintln!(
                "the lalrpop executable is not installed and parser/{source} has been changed"
            );
            eprintln!("please install lalrpop with `cargo install lalrpop`");
            Err(ExitCode::FAILURE)
        }
        Err(e) => panic!("io error {e:#}"),
    }
}

fn sha_equal(expected_sha3_str: &str, actual_sha3: &[u8; 32]) -> bool {
    // stupid stupid stupid hack. lalrpop outputs each byte as "{:x}" instead of "{:02x}"
    if expected_sha3_str.len() == 64 {
        let mut expected_sha3 = [0u8; 32];
        for (i, b) in expected_sha3.iter_mut().enumerate() {
            *b = u8::from_str_radix(&expected_sha3_str[i * 2..][..2], 16).unwrap();
        }
        *actual_sha3 == expected_sha3
    } else {
        let mut actual_sha3_str = String::new();
        for byte in actual_sha3 {
            write!(actual_sha3_str, "{byte:x}").unwrap();
        }
        actual_sha3_str == expected_sha3_str
    }
}

fn gen_phf() {
    let out_dir = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
    let mut kwds = phf_codegen::Map::new();
    let kwds = kwds
        // Alphabetical keywords:
        .entry("...", "Tok::Ellipsis")
        .entry("False", "Tok::False")
        .entry("None", "Tok::None")
        .entry("True", "Tok::True")
        // moreso "standard" keywords
        .entry("and", "Tok::And")
        .entry("as", "Tok::As")
        .entry("assert", "Tok::Assert")
        .entry("async", "Tok::Async")
        .entry("await", "Tok::Await")
        .entry("break", "Tok::Break")
        .entry("class", "Tok::Class")
        .entry("continue", "Tok::Continue")
        .entry("def", "Tok::Def")
        .entry("del", "Tok::Del")
        .entry("elif", "Tok::Elif")
        .entry("else", "Tok::Else")
        .entry("except", "Tok::Except")
        .entry("finally", "Tok::Finally")
        .entry("for", "Tok::For")
        .entry("from", "Tok::From")
        .entry("global", "Tok::Global")
        .entry("if", "Tok::If")
        .entry("import", "Tok::Import")
        .entry("in", "Tok::In")
        .entry("is", "Tok::Is")
        .entry("lambda", "Tok::Lambda")
        .entry("nonlocal", "Tok::Nonlocal")
        .entry("not", "Tok::Not")
        .entry("or", "Tok::Or")
        .entry("pass", "Tok::Pass")
        .entry("raise", "Tok::Raise")
        .entry("return", "Tok::Return")
        .entry("try", "Tok::Try")
        .entry("while", "Tok::While")
        .entry("with", "Tok::With")
        .entry("yield", "Tok::Yield")
        .build();
    writeln!(
        BufWriter::new(File::create(out_dir.join("keywords.rs")).unwrap()),
        "{kwds}",
    )
    .unwrap();
}