Remove table generation

This completely removes the `codegen` project, which relied on outdated
libraries to parse DSLs to build the utf8 and vte state tables, to make
the library easier to maintain.

The utf8 table could be completely removed in favor of a `match`
statement, which also lead to a performance improvement with the utf8
parser.

The vte table did not benefit from `match` statements at all and instead
had significantly worse performance with it. To replace the old
codegeneration for vte, the `generate_state_changes` crate has been
created instead, which uses the language's proc_macro feature to create
a `const fn` which will generate the table at compile time.

6 files changed, 0 insertions, 803 deletions

diff --git a/codegen/Cargo.toml b/codegen/Cargo.toml
deleted file mode 100644
index ec5a741..0000000
--- a/codegen/Cargo.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[package]
-name = "codegen"
-version = "0.1.0"
-authors = ["Joe Wilm <joe@jwilm.com>"]
-edition = "2018"
-
-[dependencies]
-syntex = "0.43.0"
-syntex_syntax = "0.43.0"
diff --git a/codegen/README.md b/codegen/README.md
deleted file mode 100644
index d13aa5d..0000000
--- a/codegen/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-codegen
-=======
-
-Depends on libsyntex and generates table.rs from table.rs.in. This code is
-separate from the main vtparse crate since compiling libsyntex takes ~1
-eternity.
-
-## Usage
-
-`cargo run` in the codegen folder will process `table.rs.in` and output
-`table.rs`. The latter file should be committed back into the repo.
diff --git a/codegen/src/ext/mod.rs b/codegen/src/ext/mod.rs
deleted file mode 100644
index c28d9f7..0000000
--- a/codegen/src/ext/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod utf8;
-pub mod vt;
diff --git a/codegen/src/ext/utf8.rs b/codegen/src/ext/utf8.rs
deleted file mode 100644
index 898722b..0000000
--- a/codegen/src/ext/utf8.rs
+++ /dev/null
@@ -1,365 +0,0 @@
-//! Macro expansion for the utf8 parser state table
-use std::fmt;
-
-use syntex::Registry;
-
-use syntex_syntax::ast::{self, Arm, Expr, ExprKind, LitKind, Pat, PatKind};
-use syntex_syntax::codemap::Span;
-use syntex_syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
-use syntex_syntax::ext::build::AstBuilder;
-use syntex_syntax::parse::parser::Parser;
-use syntex_syntax::parse::token::{DelimToken, Token};
-use syntex_syntax::parse::PResult;
-use syntex_syntax::ptr::P;
-use syntex_syntax::tokenstream::TokenTree;
-
-#[path = "../../../utf8parse/src/types.rs"]
-mod types;
-
-use self::types::{pack, Action, State};
-
-pub fn register(registry: &mut Registry) {
-    registry.add_macro("utf8_state_table", expand_state_table);
-}
-
-fn state_from_str<S>(s: &S) -> Result<State, ()>
-where
-    S: AsRef<str>,
-{
-    Ok(match s.as_ref() {
-        "State::Ground" => State::Ground,
-        "State::Tail3" => State::Tail3,
-        "State::Tail2" => State::Tail2,
-        "State::Tail1" => State::Tail1,
-        "State::U3_2_e0" => State::U3_2_e0,
-        "State::U3_2_ed" => State::U3_2_ed,
-        "State::Utf8_4_3_f0" => State::Utf8_4_3_f0,
-        "State::Utf8_4_3_f4" => State::Utf8_4_3_f4,
-        _ => return Err(()),
-    })
-}
-
-fn action_from_str<S>(s: &S) -> Result<Action, ()>
-where
-    S: AsRef<str>,
-{
-    Ok(match s.as_ref() {
-        "Action::InvalidSequence" => Action::InvalidSequence,
-        "Action::EmitByte" => Action::EmitByte,
-        "Action::SetByte1" => Action::SetByte1,
-        "Action::SetByte2" => Action::SetByte2,
-        "Action::SetByte2Top" => Action::SetByte2Top,
-        "Action::SetByte3" => Action::SetByte3,
-        "Action::SetByte3Top" => Action::SetByte3Top,
-        "Action::SetByte4" => Action::SetByte4,
-        _ => return Err(()),
-    })
-}
-
-fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec<Arm>> {
-    // Must start on open brace
-    parser.expect(&Token::OpenDelim(DelimToken::Brace))?;
-
-    let mut arms: Vec<Arm> = Vec::new();
-    while parser.token != Token::CloseDelim(DelimToken::Brace) {
-        match parser.parse_arm() {
-            Ok(arm) => arms.push(arm),
-            Err(e) => {
-                // Recover by skipping to the end of the block.
-                return Err(e);
-            },
-        }
-    }
-
-    // Consume the closing brace
-    parser.bump();
-    Ok(arms)
-}
-
-/// Expressions describing state transitions and actions
-#[derive(Debug)]
-struct TableDefinitionExprs {
-    state_expr: P<Expr>,
-    mapping_arms: Vec<Arm>,
-}
-
-fn state_from_expr(expr: P<Expr>, cx: &mut ExtCtxt) -> Result<State, ()> {
-    let s = match expr.node {
-        ExprKind::Path(ref _qself, ref path) => path.to_string(),
-        _ => {
-            cx.span_err(expr.span, "expected State");
-            return Err(());
-        },
-    };
-
-    state_from_str(&s).map_err(|_| {
-        cx.span_err(expr.span, "expected State");
-    })
-}
-
-fn u8_lit_from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result<u8, ()> {
-    static MSG: &str = "expected u8 int literal";
-
-    match expr.node {
-        ExprKind::Lit(ref lit) => match lit.node {
-            LitKind::Int(val, _) => Ok(val as u8),
-            _ => {
-                cx.span_err(lit.span, MSG);
-                Err(())
-            },
-        },
-        _ => {
-            cx.span_err(expr.span, MSG);
-            Err(())
-        },
-    }
-}
-
-fn input_mapping_from_arm(arm: Arm, cx: &mut ExtCtxt) -> Result<InputMapping, ()> {
-    let Arm { pats, body, .. } = arm;
-
-    let input = InputDefinition::from_pat(&pats[0], cx)?;
-    let transition = Transition::from_expr(&body, cx)?;
-
-    Ok(InputMapping { input, transition })
-}
-
-/// What happens when certain input is received
-#[derive(Copy, Clone)]
-enum Transition {
-    State(State),
-    Action(Action),
-    StateAction(State, Action),
-}
-
-impl fmt::Debug for Transition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Transition::State(state) => write!(f, "State({:?})", state)?,
-            Transition::Action(action) => write!(f, "Action({:?})", action)?,
-            Transition::StateAction(state, action) => {
-                write!(f, "StateAction({:?}, {:?})", state, action)?;
-            },
-        }
-
-        write!(f, " -> {:?}", self.pack_u8())
-    }
-}
-
-impl Transition {
-    // State is stored in the top 4 bits
-    fn pack_u8(self) -> u8 {
-        match self {
-            Transition::State(state) => pack(state, Action::InvalidSequence),
-            Transition::Action(action) => pack(State::Ground, action),
-            Transition::StateAction(state, action) => pack(state, action),
-        }
-    }
-}
-
-impl Transition {
-    fn from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result<Transition, ()> {
-        match expr.node {
-            ExprKind::Tup(ref tup_exprs) => {
-                let mut action = None;
-                let mut state = None;
-
-                for tup_expr in tup_exprs {
-                    if let ExprKind::Path(_, ref path) = tup_expr.node {
-                        let path_str = path.to_string();
-                        if path_str.starts_with('A') {
-                            action = Some(action_from_str(&path_str).map_err(|_| {
-                                cx.span_err(expr.span, "invalid action");
-                            })?);
-                        } else {
-                            state = Some(state_from_str(&path_str).map_err(|_| {
-                                cx.span_err(expr.span, "invalid state");
-                            })?);
-                        }
-                    }
-                }
-
-                match (action, state) {
-                    (Some(action), Some(state)) => Ok(Transition::StateAction(state, action)),
-                    (None, Some(state)) => Ok(Transition::State(state)),
-                    (Some(action), None) => Ok(Transition::Action(action)),
-                    _ => {
-                        cx.span_err(expr.span, "expected Action and/or State");
-                        Err(())
-                    },
-                }
-            },
-            ExprKind::Path(_, ref path) => {
-                // Path can be Action or State
-                let path_str = path.to_string();
-
-                if path_str.starts_with('A') {
-                    let action = action_from_str(&path_str).map_err(|_| {
-                        cx.span_err(expr.span, "invalid action");
-                    })?;
-                    Ok(Transition::Action(action))
-                } else {
-                    let state = state_from_str(&path_str).map_err(|_| {
-                        cx.span_err(expr.span, "invalid state");
-                    })?;
-
-                    Ok(Transition::State(state))
-                }
-            },
-            _ => {
-                cx.span_err(expr.span, "expected Action and/or State");
-                Err(())
-            },
-        }
-    }
-}
-
-#[derive(Debug)]
-enum InputDefinition {
-    Specific(u8),
-    Range { start: u8, end: u8 },
-}
-
-impl InputDefinition {
-    fn from_pat(pat: &Pat, cx: &mut ExtCtxt) -> Result<InputDefinition, ()> {
-        Ok(match pat.node {
-            PatKind::Lit(ref lit_expr) => {
-                InputDefinition::Specific(u8_lit_from_expr(&lit_expr, cx)?)
-            },
-            PatKind::Range(ref start_expr, ref end_expr) => InputDefinition::Range {
-                start: u8_lit_from_expr(start_expr, cx)?,
-                end: u8_lit_from_expr(end_expr, cx)?,
-            },
-            _ => {
-                cx.span_err(pat.span, "expected literal or range expression");
-                return Err(());
-            },
-        })
-    }
-}
-
-#[derive(Debug)]
-struct InputMapping {
-    input: InputDefinition,
-    transition: Transition,
-}
-
-#[derive(Debug)]
-struct TableDefinition {
-    state: State,
-    mappings: Vec<InputMapping>,
-}
-
-fn parse_raw_definitions(
-    definitions: Vec<TableDefinitionExprs>,
-    cx: &mut ExtCtxt,
-) -> Result<Vec<TableDefinition>, ()> {
-    let mut out = Vec::new();
-
-    for raw in definitions {
-        let TableDefinitionExprs { state_expr, mapping_arms } = raw;
-        let state = state_from_expr(state_expr, cx)?;
-
-        let mut mappings = Vec::new();
-        for arm in mapping_arms {
-            mappings.push(input_mapping_from_arm(arm, cx)?);
-        }
-
-        out.push(TableDefinition { state, mappings })
-    }
-
-    Ok(out)
-}
-
-fn parse_table_definition<'a>(parser: &mut Parser<'a>) -> PResult<'a, TableDefinitionExprs> {
-    let state_expr = parser.parse_expr()?;
-    parser.expect(&Token::FatArrow)?;
-    let mappings = parse_table_input_mappings(parser)?;
-
-    Ok(TableDefinitionExprs { state_expr, mapping_arms: mappings })
-}
-
-fn parse_table_definition_list<'a>(
-    parser: &mut Parser<'a>,
-) -> PResult<'a, Vec<TableDefinitionExprs>> {
-    let mut definitions = Vec::new();
-    while parser.token != Token::Eof {
-        definitions.push(parse_table_definition(parser)?);
-        parser.eat(&Token::Comma);
-    }
-
-    Ok(definitions)
-}
-
-fn build_state_tables<T>(defs: T) -> [[u8; 256]; 8]
-where
-    T: AsRef<[TableDefinition]>,
-{
-    let mut result = [[0u8; 256]; 8];
-
-    for def in defs.as_ref() {
-        let state = def.state;
-        let state = state as u8;
-        let transitions = &mut result[state as usize];
-
-        for mapping in &def.mappings {
-            let trans = mapping.transition.pack_u8();
-            match mapping.input {
-                InputDefinition::Specific(idx) => {
-                    transitions[idx as usize] = trans;
-                },
-                InputDefinition::Range { start, end } => {
-                    for idx in start..end {
-                        transitions[idx as usize] = trans;
-                    }
-                    transitions[end as usize] = trans;
-                },
-            }
-        }
-    }
-
-    result
-}
-
-fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 8]) -> P<ast::Expr> {
-    let table = table
-        .iter()
-        .map(|list| {
-            let exprs = list.iter().map(|num| cx.expr_u8(sp, *num)).collect();
-            cx.expr_vec(sp, exprs)
-        })
-        .collect();
-
-    cx.expr_vec(sp, table)
-}
-
-fn expand_state_table<'cx>(
-    cx: &'cx mut ExtCtxt,
-    sp: Span,
-    args: &[TokenTree],
-) -> Box<dyn MacResult + 'cx> {
-    macro_rules! ptry {
-        ($pres:expr) => {
-            match $pres {
-                Ok(val) => val,
-                Err(mut err) => {
-                    err.emit();
-                    return DummyResult::any(sp);
-                },
-            }
-        };
-    }
-
-    // Parse the lookup spec
-    let mut parser: Parser = cx.new_parser_from_tts(args);
-    let definitions = ptry!(parse_table_definition_list(&mut parser));
-    let definitions = match parse_raw_definitions(definitions, cx) {
-        Ok(definitions) => definitions,
-        Err(_) => return DummyResult::any(sp),
-    };
-
-    let table = build_state_tables(&definitions);
-    let ast = build_table_ast(cx, sp, table);
-
-    MacEager::expr(ast)
-}
diff --git a/codegen/src/ext/vt.rs b/codegen/src/ext/vt.rs
deleted file mode 100644
index aff7d68..0000000
--- a/codegen/src/ext/vt.rs
+++ /dev/null
@@ -1,393 +0,0 @@
-//! Macro expansion for the virtual terminal parser state table
-use std::fmt;
-
-use syntex::Registry;
-
-use syntex_syntax::ast::{self, Arm, Expr, ExprKind, LitKind, Pat, PatKind};
-use syntex_syntax::codemap::Span;
-use syntex_syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
-use syntex_syntax::ext::build::AstBuilder;
-use syntex_syntax::parse::parser::Parser;
-use syntex_syntax::parse::token::{DelimToken, Token};
-use syntex_syntax::parse::PResult;
-use syntex_syntax::ptr::P;
-use syntex_syntax::tokenstream::TokenTree;
-
-#[path = "../../../src/definitions.rs"]
-mod definitions;
-
-use self::definitions::{Action, State};
-
-pub fn register(registry: &mut Registry) {
-    registry.add_macro("vt_state_table", expand_state_table);
-}
-
-fn state_from_str<S>(s: &S) -> Result<State, ()>
-where
-    S: AsRef<str>,
-{
-    Ok(match s.as_ref() {
-        "State::Anywhere" => State::Anywhere,
-        "State::CsiEntry" => State::CsiEntry,
-        "State::CsiIgnore" => State::CsiIgnore,
-        "State::CsiIntermediate" => State::CsiIntermediate,
-        "State::CsiParam" => State::CsiParam,
-        "State::DcsEntry" => State::DcsEntry,
-        "State::DcsIgnore" => State::DcsIgnore,
-        "State::DcsIntermediate" => State::DcsIntermediate,
-        "State::DcsParam" => State::DcsParam,
-        "State::DcsPassthrough" => State::DcsPassthrough,
-        "State::Escape" => State::Escape,
-        "State::EscapeIntermediate" => State::EscapeIntermediate,
-        "State::Ground" => State::Ground,
-        "State::OscString" => State::OscString,
-        "State::SosPmApcString" => State::SosPmApcString,
-        "State::Utf8" => State::Utf8,
-        _ => return Err(()),
-    })
-}
-
-fn action_from_str<S>(s: &S) -> Result<Action, ()>
-where
-    S: AsRef<str>,
-{
-    Ok(match s.as_ref() {
-        "Action::None" => Action::None,
-        "Action::Clear" => Action::Clear,
-        "Action::Collect" => Action::Collect,
-        "Action::CsiDispatch" => Action::CsiDispatch,
-        "Action::EscDispatch" => Action::EscDispatch,
-        "Action::Execute" => Action::Execute,
-        "Action::Hook" => Action::Hook,
-        "Action::Ignore" => Action::Ignore,
-        "Action::OscEnd" => Action::OscEnd,
-        "Action::OscPut" => Action::OscPut,
-        "Action::OscStart" => Action::OscStart,
-        "Action::Param" => Action::Param,
-        "Action::Print" => Action::Print,
-        "Action::Put" => Action::Put,
-        "Action::Unhook" => Action::Unhook,
-        "Action::BeginUtf8" => Action::BeginUtf8,
-        _ => return Err(()),
-    })
-}
-
-fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec<Arm>> {
-    // Must start on open brace
-    parser.expect(&Token::OpenDelim(DelimToken::Brace))?;
-
-    let mut arms: Vec<Arm> = Vec::new();
-    while parser.token != Token::CloseDelim(DelimToken::Brace) {
-        match parser.parse_arm() {
-            Ok(arm) => arms.push(arm),
-            Err(e) => {
-                // Recover by skipping to the end of the block.
-                return Err(e);
-            },
-        }
-    }
-
-    // Consume the closing brace
-    parser.bump();
-    Ok(arms)
-}
-
-/// Expressions describing state transitions and actions
-#[derive(Debug)]
-struct TableDefinitionExprs {
-    state_expr: P<Expr>,
-    mapping_arms: Vec<Arm>,
-}
-
-fn state_from_expr(expr: P<Expr>, cx: &mut ExtCtxt) -> Result<State, ()> {
-    let s = match expr.node {
-        ExprKind::Path(ref _qself, ref path) => path.to_string(),
-        _ => {
-            cx.span_err(expr.span, "expected State");
-            return Err(());
-        },
-    };
-
-    state_from_str(&s).map_err(|_| {
-        cx.span_err(expr.span, "expected State");
-    })
-}
-
-fn u8_lit_from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result<u8, ()> {
-    static MSG: &str = "expected u8 int literal";
-
-    match expr.node {
-        ExprKind::Lit(ref lit) => match lit.node {
-            LitKind::Int(val, _) => Ok(val as u8),
-            _ => {
-                cx.span_err(lit.span, MSG);
-                Err(())
-            },
-        },
-        _ => {
-            cx.span_err(expr.span, MSG);
-            Err(())
-        },
-    }
-}
-
-fn input_mapping_from_arm(arm: Arm, cx: &mut ExtCtxt) -> Result<InputMapping, ()> {
-    let Arm { pats, body, .. } = arm;
-
-    let input = InputDefinition::from_pat(&pats[0], cx)?;
-    let transition = Transition::from_expr(&body, cx)?;
-
-    Ok(InputMapping { input, transition })
-}
-
-/// What happens when certain input is received
-#[derive(Copy, Clone)]
-enum Transition {
-    State(State),
-    Action(Action),
-    StateAction(State, Action),
-}
-
-impl fmt::Debug for Transition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Transition::State(state) => write!(f, "State({:?})", state)?,
-            Transition::Action(action) => write!(f, "Action({:?})", action)?,
-            Transition::StateAction(state, action) => {
-                write!(f, "StateAction({:?}, {:?})", state, action)?;
-            },
-        }
-
-        write!(f, " -> {:?}", self.pack_u8())
-    }
-}
-
-impl Transition {
-    // State is stored in the top 4 bits
-    fn pack_u8(self) -> u8 {
-        match self {
-            Transition::State(state) => state as u8,
-            Transition::Action(action) => (action as u8) << 4,
-            Transition::StateAction(state, action) => ((action as u8) << 4) | (state as u8),
-        }
-    }
-}
-
-impl Transition {
-    fn from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result<Transition, ()> {
-        match expr.node {
-            ExprKind::Tup(ref tup_exprs) => {
-                let mut action = None;
-                let mut state = None;
-
-                for tup_expr in tup_exprs {
-                    if let ExprKind::Path(_, ref path) = tup_expr.node {
-                        let path_str = path.to_string();
-                        if path_str.starts_with('A') {
-                            action = Some(action_from_str(&path_str).map_err(|_| {
-                                cx.span_err(expr.span, "invalid action");
-                            })?);
-                        } else {
-                            state = Some(state_from_str(&path_str).map_err(|_| {
-                                cx.span_err(expr.span, "invalid state");
-                            })?);
-                        }
-                    }
-                }
-
-                match (action, state) {
-                    (Some(action), Some(state)) => Ok(Transition::StateAction(state, action)),
-                    (None, Some(state)) => Ok(Transition::State(state)),
-                    (Some(action), None) => Ok(Transition::Action(action)),
-                    _ => {
-                        cx.span_err(expr.span, "expected Action and/or State");
-                        Err(())
-                    },
-                }
-            },
-            ExprKind::Path(_, ref path) => {
-                // Path can be Action or State
-                let path_str = path.to_string();
-
-                if path_str.starts_with('A') {
-                    let action = action_from_str(&path_str).map_err(|_| {
-                        cx.span_err(expr.span, "invalid action");
-                    })?;
-                    Ok(Transition::Action(action))
-                } else {
-                    let state = state_from_str(&path_str).map_err(|_| {
-                        cx.span_err(expr.span, "invalid state");
-                    })?;
-
-                    Ok(Transition::State(state))
-                }
-            },
-            _ => {
-                cx.span_err(expr.span, "expected Action and/or State");
-                Err(())
-            },
-        }
-    }
-}
-
-#[derive(Debug)]
-enum InputDefinition {
-    Specific(u8),
-    Range { start: u8, end: u8 },
-}
-
-impl InputDefinition {
-    fn from_pat(pat: &Pat, cx: &mut ExtCtxt) -> Result<InputDefinition, ()> {
-        Ok(match pat.node {
-            PatKind::Lit(ref lit_expr) => {
-                InputDefinition::Specific(u8_lit_from_expr(&lit_expr, cx)?)
-            },
-            PatKind::Range(ref start_expr, ref end_expr) => InputDefinition::Range {
-                start: u8_lit_from_expr(start_expr, cx)?,
-                end: u8_lit_from_expr(end_expr, cx)?,
-            },
-            _ => {
-                cx.span_err(pat.span, "expected literal or range expression");
-                return Err(());
-            },
-        })
-    }
-}
-
-#[derive(Debug)]
-struct InputMapping {
-    input: InputDefinition,
-    transition: Transition,
-}
-
-#[derive(Debug)]
-struct TableDefinition {
-    state: State,
-    mappings: Vec<InputMapping>,
-}
-
-fn parse_raw_definitions(
-    definitions: Vec<TableDefinitionExprs>,
-    cx: &mut ExtCtxt,
-) -> Result<Vec<TableDefinition>, ()> {
-    let mut out = Vec::new();
-
-    for raw in definitions {
-        let TableDefinitionExprs { state_expr, mapping_arms } = raw;
-        let state = state_from_expr(state_expr, cx)?;
-
-        let mut mappings = Vec::new();
-        for arm in mapping_arms {
-            mappings.push(input_mapping_from_arm(arm, cx)?);
-        }
-
-        out.push(TableDefinition { state, mappings })
-    }
-
-    Ok(out)
-}
-
-fn parse_table_definition<'a>(parser: &mut Parser<'a>) -> PResult<'a, TableDefinitionExprs> {
-    let state_expr = parser.parse_expr()?;
-    parser.expect(&Token::FatArrow)?;
-    let mappings = parse_table_input_mappings(parser)?;
-
-    Ok(TableDefinitionExprs { state_expr, mapping_arms: mappings })
-}
-
-fn parse_table_definition_list<'a>(
-    parser: &mut Parser<'a>,
-) -> PResult<'a, Vec<TableDefinitionExprs>> {
-    let mut definitions = Vec::new();
-    while parser.token != Token::Eof {
-        definitions.push(parse_table_definition(parser)?);
-        parser.eat(&Token::Comma);
-    }
-
-    Ok(definitions)
-}
-
-fn build_state_tables<T>(defs: T) -> [[u8; 256]; 16]
-where
-    T: AsRef<[TableDefinition]>,
-{
-    let mut result = [[0u8; 256]; 16];
-
-    for def in defs.as_ref() {
-        let state = def.state;
-        let state = state as u8;
-        let transitions = &mut result[state as usize];
-
-        for mapping in &def.mappings {
-            let trans = mapping.transition.pack_u8();
-            match mapping.input {
-                InputDefinition::Specific(idx) => {
-                    transitions[idx as usize] = trans;
-                },
-                InputDefinition::Range { start, end } => {
-                    for idx in start..end {
-                        transitions[idx as usize] = trans;
-                    }
-                    transitions[end as usize] = trans;
-                },
-            }
-        }
-    }
-
-    result
-}
-
-fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 16]) -> P<ast::Expr> {
-    let table = table
-        .iter()
-        .map(|list| {
-            let exprs = list.iter().map(|num| cx.expr_u8(sp, *num)).collect();
-            cx.expr_vec(sp, exprs)
-        })
-        .collect();
-
-    cx.expr_vec(sp, table)
-}
-
-fn expand_state_table<'cx>(
-    cx: &'cx mut ExtCtxt,
-    sp: Span,
-    args: &[TokenTree],
-) -> Box<dyn MacResult + 'cx> {
-    macro_rules! ptry {
-        ($pres:expr) => {
-            match $pres {
-                Ok(val) => val,
-                Err(mut err) => {
-                    err.emit();
-                    return DummyResult::any(sp);
-                },
-            }
-        };
-    }
-
-    // Parse the lookup spec
-    let mut parser: Parser = cx.new_parser_from_tts(args);
-    let definitions = ptry!(parse_table_definition_list(&mut parser));
-    let definitions = match parse_raw_definitions(definitions, cx) {
-        Ok(definitions) => definitions,
-        Err(_) => return DummyResult::any(sp),
-    };
-
-    let table = build_state_tables(&definitions);
-    let ast = build_table_ast(cx, sp, table);
-
-    MacEager::expr(ast)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::definitions::{Action, State};
-    use super::Transition;
-
-    #[test]
-    fn pack_u8() {
-        let transition = Transition::StateAction(State::CsiParam, Action::Collect);
-        assert_eq!(transition.pack_u8(), 0x24);
-    }
-}
diff --git a/codegen/src/main.rs b/codegen/src/main.rs
deleted file mode 100644
index 7cc6cd0..0000000
--- a/codegen/src/main.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(dead_code)]
-
-use std::path::Path;
-
-use syntex;
-
-mod ext;
-
-fn main() {
-    // Expand VT parser state table
-    let mut registry = syntex::Registry::new();
-    ext::vt::register(&mut registry);
-    let src = &Path::new("../src/table.rs.in");
-    let dst = &Path::new("../src/table.rs");
-    registry.expand("vt_state_table", src, dst).expect("expand vt_stable_table ok");
-
-    // Expand UTF8 parser state table
-    let mut registry = syntex::Registry::new();
-    ext::utf8::register(&mut registry);
-    let src = &Path::new("../utf8parse/src/table.rs.in");
-    let dst = &Path::new("../utf8parse/src/table.rs");
-    registry.expand("utf8_state_table", src, dst).expect("expand utf8_stable_table ok");
-}