#![feature(
    iter_advance_by,
    box_into_inner,
    bigint_helper_methods,
    map_try_insert,
    iter_intersperse,
    iter_array_chunks,
    int_roundings,
    if_let_guard,
    debug_closure_helpers,
    box_vec_non_null,
    macro_metavar_expr
)]
#![allow(unused_macros, unsafe_op_in_unsafe_fn)]

pub mod asm;
pub mod ast;
pub mod common;
pub mod comptime;
pub mod error;
//pub mod intern_pool;
pub mod ast2;
pub mod lexer;
pub mod mir;
pub mod parser;
pub mod string_table;
pub mod symbol_table;
pub mod tokens;
pub mod triples;

pub mod utils;
use utils::unit;

pub fn tokenize<'a>(
    bytes: &'a [u8],
) -> Result<lexer::Tokenizer<'a>, (lexer::Tokenizer<'a>, Vec<lexer::TokenizeError>)> {
    lexer::Tokenizer::new_with_errors(bytes)
}

trait BitSize {
    fn bits(&self) -> u32;
}

macro_rules! impl_bitsize_int {
    ($($ty:ty)*) => {

        $(
impl BitSize for $ty {
    fn bits(&self) -> u32 {
        Self::BITS as u32 - self.trailing_zeros() as u32
    }
})*
    };
}

impl_bitsize_int!(u8 u16 u32 u64 u128);

impl BitSize for &[u8] {
    fn bits(&self) -> u32 {
        let bytes = self.as_ref();
        let mut bits = bytes.len() * u8::BITS as usize;

        for &d in bytes.iter().rev() {
            if d == 0 {
                bits -= u8::BITS as usize;
            } else {
                bits -= d.leading_zeros() as usize;
                break;
            }
        }

        bits as u32
    }
}