From 7edec7af9ea506ca0f138f21f6f8a16cb5b9e7a8 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Thu, 2 Oct 2014 19:14:17 +0300 Subject: [PATCH] codegen: remove dead module branchify. --- src/codegen/branchify.rs | 151 --------------------------------------- src/codegen/main.rs | 1 - 2 files changed, 152 deletions(-) delete mode 100644 src/codegen/branchify.rs diff --git a/src/codegen/branchify.rs b/src/codegen/branchify.rs deleted file mode 100644 index 0aa002e9..00000000 --- a/src/codegen/branchify.rs +++ /dev/null @@ -1,151 +0,0 @@ -#![macro_escape] - -use std::io::BufferedWriter; -use std::io::{File, Writer}; -use std::str::Chars; -use std::vec::Vec; - -pub struct ParseBranch { - matches: Vec, - result: Option, - children: Vec, -} - -impl ParseBranch { - fn new() -> ParseBranch { - ParseBranch { - matches: Vec::new(), - result: None, - children: Vec::new(), - } - } -} - -#[allow(visible_private_types)] -pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> Vec { - let mut root = ParseBranch::new(); - - fn go_down_moses(branch: &mut ParseBranch, mut chariter: Chars, result: &str, case_sensitive: bool) { - match chariter.next() { - Some(c) => { - let first_case = if case_sensitive { c as u8 } else { c.to_ascii().to_uppercase().to_byte() }; - for next_branch in branch.children.mut_iter() { - if next_branch.matches.as_slice()[0] == first_case { - go_down_moses(next_branch, chariter, result, case_sensitive); - return; - } - } - let mut subbranch = ParseBranch::new(); - subbranch.matches.push(first_case); - if !case_sensitive { - let second_case = c.to_ascii().to_lowercase().to_byte(); - if first_case != second_case { - subbranch.matches.push(second_case); - } - } - branch.children.push(subbranch); - let index = branch.children.len() -1; - go_down_moses(&mut branch.children.as_mut_slice()[index], chariter, result, case_sensitive); - }, - None => { - assert!(branch.result.is_none()); - branch.result = Some(result.to_string()); - }, - } - }; - - for &(key, result) in options.iter() { - go_down_moses(&mut root, key.chars(), result, case_sensitive); - } - - root.children -} - -macro_rules! branchify( - (case sensitive, $($key:expr => $value:ident),*) => ( - ::branchify::branchify([$(($key, stringify!($value))),*], true) - ); - (case insensitive, $($key:expr => $value:ident),*) => ( - branchify([$(($key, stringify!($value))),*], false) - ); -) - -/// Prints the contents to stdout. -/// -/// :param branches: the branches to search through -/// :param indent: the level of indentation (each level representing four leading spaces) -/// :param read_call: the function call to read a byte -/// :param end: the byte which marks the end of the sequence -/// :param max_len: the maximum length a value may be before giving up and returning ``None`` -/// :param valid: the function call to if a byte ``b`` is valid -/// :param unknown: the expression to call for an unknown value; in this string, ``{}`` will be -/// replaced with an expression (literal or non-literal) evaluating to a ``~str`` (it is -/// ``{}`` only, not arbitrary format strings) -#[allow(visible_private_types)] -pub fn generate_branchified_method( - writer: &mut BufferedWriter, - branches: &[ParseBranch], - indent: uint, - read_call: &str, - end: &str, - max_len: &str, - valid: &str, - unknown: &str) { - - // Write Formatted - let mut wf = |s: String| { - let indentstr = " ".repeat(indent * 4); - let result = writer.write(indentstr.as_bytes()) - .and(writer.write(s.as_bytes())) - .and(writer.write(b"\n")); - - match result { - Ok(_) => {}, - Err(e) => fail!("write error: {:s}", e.desc), - } - }; - - fn r(branch: &ParseBranch, prefix: &str, read_call: &str, - valid: &str, unknown: &str, write_fmt: &mut |String|) { - - for &c in branch.matches.iter() { - let next_prefix = format!("{}{}", prefix, c as char); - (*write_fmt)(format!("Some(b) if b == '{}' as u8 => match {} {{", c as char, read_call)); - for b in branch.children.iter() { - r(b, next_prefix.as_slice(), read_call, valid, unknown, write_fmt); - } - match branch.result { - Some(ref result) => (*write_fmt)(format!(" Some(b) if b == SP => return Some({}),", *result)), - None => (*write_fmt)(format!(" Some(b) if b == SP => return Some({}),", - unknown.replace("{}", format!("~\"{}\"", next_prefix.as_slice()).as_slice()))), - } - (*write_fmt)(format!(" Some(b) if {} => (\"{}\", b),", valid, next_prefix.as_slice())); - (*write_fmt)(format!(" _ => return None,")); - (*write_fmt)(format!("}},")); - } - } - - wf(format!("let (s, next_byte) = match {} {{", read_call)); - for b in branches.iter() { - r(b, "", read_call, valid, unknown, &mut wf); - } - wf(format!(" Some(b) if {} => (\"\", b),", valid)); - wf(format!(" _ => return None,")); - wf(format!("}};")); - wf(format!("// OK, that didn't pan out. Let's read the rest and see what we get.")); - wf(format!("let mut s = s.to_string();")); - wf(format!("s.push_char(next_byte as char);")); - wf(format!("loop {{")); - wf(format!(" match {} {{", read_call)); - wf(format!(" Some(b) if b == {} => return Some({}),", end, unknown.replace("{}", "s"))); - wf(format!(" Some(b) if {} => {{", valid)); - wf(format!(" if s.len() == {} {{", max_len)); - wf(format!(" // Too long; bad request")); - wf(format!(" return None;")); - wf(format!(" }}")); - wf(format!(" s.push_char(b as char);")); - wf(format!(" }},")); - wf(format!(" _ => return None,")); - wf(format!(" }}")); - wf(format!("}}")); -} diff --git a/src/codegen/main.rs b/src/codegen/main.rs index 2e2383aa..34958fcf 100644 --- a/src/codegen/main.rs +++ b/src/codegen/main.rs @@ -9,7 +9,6 @@ use std::io::UserDir; use std::io::stdio::println; use std::io::fs::mkdir_recursive; use std::path::GenericPath; -pub mod branchify; pub mod keycode; pub mod scancode;