rustpython-vm 0.1.0

use crate::function::PyFuncArgs;
use crate::obj::objbytes;
use crate::obj::objint;
use crate::pyobject::{PyObjectRef, PyResult};
use crate::vm::VirtualMachine;
use crc::{crc32, Hasher32};
use num_traits::ToPrimitive;

fn hex_nibble(n: u8) -> u8 {
    match n {
        0..=9 => b'0' + n,
        10..=15 => b'a' + n,
        _ => unreachable!(),
    }
}

fn binascii_hexlify(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
    arg_check!(vm, args, required = [(data, Some(vm.ctx.bytes_type()))]);

    let bytes = objbytes::get_value(data);
    let mut hex = Vec::<u8>::with_capacity(bytes.len() * 2);
    for b in bytes.iter() {
        hex.push(hex_nibble(b >> 4));
        hex.push(hex_nibble(b & 0xf));
    }

    Ok(vm.ctx.new_bytes(hex))
}

fn unhex_nibble(c: u8) -> Option<u8> {
    match c {
        b'0'..=b'9' => Some(c - b'0'),
        b'a'..=b'f' => Some(c - b'a' + 10),
        b'A'..=b'F' => Some(c - b'A' + 10),
        _ => None,
    }
}

fn binascii_unhexlify(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
    // TODO: allow 'str' hexstrings as well
    arg_check!(vm, args, required = [(hexstr, Some(vm.ctx.bytes_type()))]);

    let hex_bytes = &objbytes::get_value(hexstr);
    if hex_bytes.len() % 2 != 0 {
        return Err(vm.new_value_error("Odd-length string".to_string()));
    }

    let mut unhex = Vec::<u8>::with_capacity(hex_bytes.len() / 2);
    for i in (0..hex_bytes.len()).step_by(2) {
        let n1 = unhex_nibble(hex_bytes[i]);
        let n2 = unhex_nibble(hex_bytes[i + 1]);
        if n1.is_some() && n2.is_some() {
            unhex.push(n1.unwrap() << 4 | n2.unwrap());
        } else {
            return Err(vm.new_value_error("Non-hexadecimal digit found".to_string()));
        }
    }

    Ok(vm.ctx.new_bytes(unhex))
}

fn binascii_crc32(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
    arg_check!(
        vm,
        args,
        required = [(data, Some(vm.ctx.bytes_type()))],
        optional = [(value, None)]
    );

    let bytes = objbytes::get_value(data);
    let crc = match value {
        None => 0u32,
        Some(value) => objint::get_value(&value).to_u32().unwrap(),
    };

    let mut digest = crc32::Digest::new_with_initial(crc32::IEEE, crc);
    digest.write(&bytes);

    Ok(vm.ctx.new_int(digest.sum32()))
}

pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
    let ctx = &vm.ctx;

    py_module!(vm, "binascii", {
        "hexlify" => ctx.new_rustfunc(binascii_hexlify),
        "b2a_hex" => ctx.new_rustfunc(binascii_hexlify),
        "unhexlify" => ctx.new_rustfunc(binascii_unhexlify),
        "a2b_hex" => ctx.new_rustfunc(binascii_unhexlify),
        "crc32" => ctx.new_rustfunc(binascii_crc32),
    })
}