auto merge of #6826 : cmr/rust/terminfo, r=thestinger

This will let *everyone* (non-windows, at least) who can see colors see the glorious colors rustc produces.

src/libextra/std.rc

@@ -118,6 +118,8 @@ pub mod flate;
 #[cfg(unicode)]
 mod unicode;
 
+#[path="terminfo/terminfo.rs"]
+pub mod terminfo;
 
 // Compiler support modules
 

src/libextra/term.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -15,9 +15,13 @@
 use core::prelude::*;
 
 use core::io;
-use core::option;
 use core::os;
 
+use terminfo::*;
+use terminfo::searcher::open;
+use terminfo::parser::compiled::parse;
+use terminfo::parm::{expand, Number};
+
 // FIXME (#2807): Windows support.
 
 pub static color_black: u8 = 0u8;
@@ -39,43 +43,90 @@ pub static color_bright_magenta: u8 = 13u8;
 pub static color_bright_cyan: u8 = 14u8;
 pub static color_bright_white: u8 = 15u8;
 
-pub fn esc(writer: @io::Writer) { writer.write([0x1bu8, '[' as u8]); }
-
-/// Reset the foreground and background colors to default
-pub fn reset(writer: @io::Writer) {
-    esc(writer);
-    writer.write(['0' as u8, 'm' as u8]);
+#[cfg(not(target_os = "win32"))]
+pub struct Terminal {
+    color_supported: bool,
+    priv out: @io::Writer,
+    priv ti: ~TermInfo
 }
 
-/// Returns true if the terminal supports color
-pub fn color_supported() -> bool {
-    let supported_terms = ~[~"xterm-color", ~"xterm",
-                           ~"screen-bce", ~"xterm-256color"];
-    return match os::getenv("TERM") {
-          option::Some(ref env) => {
-            for supported_terms.each |term| {
-                if *term == *env { return true; }
+#[cfg(target_os = "win32")]
+pub struct Terminal {
+    color_supported: bool,
+    priv out: @io::Writer,
+}
+
+#[cfg(not(target_os = "win32"))]
+pub impl Terminal {
+    pub fn new(out: @io::Writer) -> Result<Terminal, ~str> {
+        let term = os::getenv("TERM");
+        if term.is_none() {
+            return Err(~"TERM environment variable undefined");
+        }
+
+        let entry = open(term.unwrap());
+        if entry.is_err() {
+            return Err(entry.get_err());
+        }
+
+        let ti = parse(entry.get(), false);
+        if ti.is_err() {
+            return Err(entry.get_err());
+        }
+
+        let mut inf = ti.get();
+        let cs = *inf.numbers.find_or_insert(~"colors", 0) >= 16
+            && inf.strings.find(&~"setaf").is_some()
+            && inf.strings.find_equiv(&("setab")).is_some();
+
+        return Ok(Terminal {out: out, ti: inf, color_supported: cs});
+    }
+    fn fg(&self, color: u8) {
+        if self.color_supported {
+            let s = expand(*self.ti.strings.find_equiv(&("setaf")).unwrap(),
+                           [Number(color as int)], [], []);
+            if s.is_ok() {
+                self.out.write(s.get());
+            } else {
+                warn!(s.get_err());
             }
-            false
-          }
-          option::None => false
-        };
+        }
+    }
+    fn bg(&self, color: u8) {
+        if self.color_supported {
+            let s = expand(*self.ti.strings.find_equiv(&("setab")).unwrap(),
+                           [Number(color as int)], [], []);
+            if s.is_ok() {
+                self.out.write(s.get());
+            } else {
+                warn!(s.get_err());
+            }
+        }
+    }
+    fn reset(&self) {
+        if self.color_supported {
+            let s = expand(*self.ti.strings.find_equiv(&("op")).unwrap(), [], [], []);
+            if s.is_ok() {
+                self.out.write(s.get());
+            } else {
+                warn!(s.get_err());
+            }
+        }
+    }
 }
 
-pub fn set_color(writer: @io::Writer, first_char: u8, color: u8) {
-    assert!((color < 16u8));
-    esc(writer);
-    let mut color = color;
-    if color >= 8u8 { writer.write(['1' as u8, ';' as u8]); color -= 8u8; }
-    writer.write([first_char, ('0' as u8) + color, 'm' as u8]);
-}
+#[cfg(target_os = "win32")]
+pub impl Terminal {
+    pub fn new(out: @io::Writer) -> Result<Terminal, ~str> {
+        return Ok(Terminal {out: out, color_supported: false});
+    }
 
-/// Set the foreground color
-pub fn fg(writer: @io::Writer, color: u8) {
-    return set_color(writer, '3' as u8, color);
-}
+    fn fg(&self, color: u8) {
+    }
 
-/// Set the background color
-pub fn bg(writer: @io::Writer, color: u8) {
-    return set_color(writer, '4' as u8, color);
+    fn bg(&self, color: u8) {
+    }
+
+    fn reset(&self) {
+    }
 }

src/libextra/terminfo/parm.rs

@@ -0,0 +1,209 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Parameterized string expansion
+
+use core::prelude::*;
+use core::{char, int, vec};
+
+#[deriving(Eq)]
+enum States {
+    Nothing,
+    Percent,
+    SetVar,
+    GetVar,
+    PushParam,
+    CharConstant,
+    CharClose,
+    IntConstant,
+    IfCond,
+    IfBody
+}
+
+/// Types of parameters a capability can use
+pub enum Param {
+    String(~str),
+    Char(char),
+    Number(int)
+}
+
+/**
+  Expand a parameterized capability
+
+  # Arguments
+  * `cap`    - string to expand
+  * `params` - vector of params for %p1 etc
+  * `sta`    - vector of params corresponding to static variables
+  * `dyn`    - vector of params corresponding to stativ variables
+
+  To be compatible with ncurses, `sta` and `dyn` should be the same between calls to `expand` for
+  multiple capabilities for the same terminal.
+  */
+pub fn expand(cap: &[u8], params: &mut [Param], sta: &mut [Param], dyn: &mut [Param])
+    -> Result<~[u8], ~str> {
+    assert!(cap.len() != 0, "expanding an empty capability makes no sense");
+    assert!(params.len() <= 9, "only 9 parameters are supported by capability strings");
+
+    assert!(sta.len() <= 26, "only 26 static vars are able to be used by capability strings");
+    assert!(dyn.len() <= 26, "only 26 dynamic vars are able to be used by capability strings");
+
+    let mut state = Nothing;
+    let mut i = 0;
+
+    // expanded cap will only rarely be smaller than the cap itself
+    let mut output = vec::with_capacity(cap.len());
+
+    let mut cur;
+
+    let mut stack: ~[Param] = ~[];
+
+    let mut intstate = ~[];
+
+    while i < cap.len() {
+        cur = cap[i] as char;
+        let mut old_state = state;
+        match state {
+            Nothing => {
+                if cur == '%' {
+                    state = Percent;
+                } else {
+                    output.push(cap[i]);
+                }
+            },
+            Percent => {
+                match cur {
+                    '%' => { output.push(cap[i]); state = Nothing },
+                    'c' => match stack.pop() {
+                        Char(c) => output.push(c as u8),
+                        _       => return Err(~"a non-char was used with %c")
+                    },
+                    's' => match stack.pop() {
+                        String(s) => output.push_all(s.to_bytes()),
+                        _         => return Err(~"a non-str was used with %s")
+                    },
+                    'd' => match stack.pop() {
+                        Number(x) => output.push_all(x.to_str().to_bytes()),
+                        _         => return Err(~"a non-number was used with %d")
+                    },
+                    'p' => state = PushParam,
+                    'P' => state = SetVar,
+                    'g' => state = GetVar,
+                    '\'' => state = CharConstant,
+                    '{' => state = IntConstant,
+                    'l' => match stack.pop() {
+                        String(s) => stack.push(Number(s.len() as int)),
+                        _         => return Err(~"a non-str was used with %l")
+                    },
+                    '+' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x + y)),
+                        (_, _) => return Err(~"non-numbers on stack with +")
+                    },
+                    '-' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x - y)),
+                        (_, _) => return Err(~"non-numbers on stack with -")
+                    },
+                    '*' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x * y)),
+                        (_, _) => return Err(~"non-numbers on stack with *")
+                    },
+                    '/' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x / y)),
+                        (_, _) => return Err(~"non-numbers on stack with /")
+                    },
+                    'm' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x % y)),
+                        (_, _) => return Err(~"non-numbers on stack with %")
+                    },
+                    '&' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x & y)),
+                        (_, _) => return Err(~"non-numbers on stack with &")
+                    },
+                    '|' => match (stack.pop(), stack.pop()) {
+                        (Number(x), Number(y)) => stack.push(Number(x | y)),
+                        (_, _) => return Err(~"non-numbers on stack with |")
+                    },
+                    'A' => return Err(~"logical operations unimplemented"),
+                    'O' => return Err(~"logical operations unimplemented"),
+                    '!' => return Err(~"logical operations unimplemented"),
+                    '~' => match stack.pop() {
+                        Number(x) => stack.push(Number(!x)),
+                        _         => return Err(~"non-number on stack with %~")
+                    },
+                    'i' => match (copy params[0], copy params[1]) {
+                        (Number(x), Number(y)) => {
+                            params[0] = Number(x + 1);
+                            params[1] = Number(y + 1);
+                        },
+                        (_, _) => return Err(~"first two params not numbers with %i")
+                    },
+                    '?' => state = return Err(fmt!("if expressions unimplemented (%?)", cap)),
+                    _ => return Err(fmt!("unrecognized format option %c", cur))
+                }
+            },
+            PushParam => {
+                // params are 1-indexed
+                stack.push(copy params[char::to_digit(cur, 10).expect("bad param number") - 1]);
+            },
+            SetVar => {
+                if cur >= 'A' && cur <= 'Z' {
+                    let idx = (cur as u8) - ('A' as u8);
+                    sta[idx] = stack.pop();
+                } else if cur >= 'a' && cur <= 'z' {
+                    let idx = (cur as u8) - ('a' as u8);
+                    dyn[idx] = stack.pop();
+                } else {
+                    return Err(~"bad variable name in %P");
+                }
+            },
+            GetVar => {
+                if cur >= 'A' && cur <= 'Z' {
+                    let idx = (cur as u8) - ('A' as u8);
+                    stack.push(copy sta[idx]);
+                } else if cur >= 'a' && cur <= 'z' {
+                    let idx = (cur as u8) - ('a' as u8);
+                    stack.push(copy dyn[idx]);
+                } else {
+                    return Err(~"bad variable name in %g");
+                }
+            },
+            CharConstant => {
+                stack.push(Char(cur));
+                state = CharClose;
+            },
+            CharClose => {
+                assert!(cur == '\'', "malformed character constant");
+            },
+            IntConstant => {
+                if cur == '}' {
+                    stack.push(Number(int::parse_bytes(intstate, 10).expect("bad int constant")));
+                    state = Nothing;
+                }
+                intstate.push(cur as u8);
+                old_state = Nothing;
+            }
+            _ => return Err(~"unimplemented state")
+        }
+        if state == old_state {
+            state = Nothing;
+        }
+        i += 1;
+    }
+    Ok(output)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_basic_setabf() {
+        let s = bytes!("\\E[48;5;%p1%dm");
+        assert_eq!(expand(s, [Number(1)], [], []).unwrap(), bytes!("\\E[48;5;1m").to_owned());
+    }
+}

src/libextra/terminfo/parser/compiled.rs

@@ -0,0 +1,332 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// ncurses-compatible compiled terminfo format parsing (term(5))
+
+use core::prelude::*;
+
+use core::{vec, int, str};
+use core::io::Reader;
+use core::hashmap::HashMap;
+use super::super::TermInfo;
+
+// These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
+
+pub static boolfnames: &'static[&'static str] = &'static["auto_left_margin", "auto_right_margin",
+    "no_esc_ctlc", "ceol_standout_glitch", "eat_newline_glitch", "erase_overstrike", "generic_type",
+    "hard_copy", "has_meta_key", "has_status_line", "insert_null_glitch", "memory_above",
+    "memory_below", "move_insert_mode", "move_standout_mode", "over_strike", "status_line_esc_ok",
+    "dest_tabs_magic_smso", "tilde_glitch", "transparent_underline", "xon_xoff", "needs_xon_xoff",
+    "prtr_silent", "hard_cursor", "non_rev_rmcup", "no_pad_char", "non_dest_scroll_region",
+    "can_change", "back_color_erase", "hue_lightness_saturation", "col_addr_glitch",
+    "cr_cancels_micro_mode", "has_print_wheel", "row_addr_glitch", "semi_auto_right_margin",
+    "cpi_changes_res", "lpi_changes_res", "backspaces_with_bs", "crt_no_scrolling",
+    "no_correctly_working_cr", "gnu_has_meta_key", "linefeed_is_newline", "has_hardware_tabs",
+    "return_does_clr_eol"];
+
+pub static boolnames: &'static[&'static str] = &'static["bw", "am", "xsb", "xhp", "xenl", "eo",
+    "gn", "hc", "km", "hs", "in", "db", "da", "mir", "msgr", "os", "eslok", "xt", "hz", "ul", "xon",
+    "nxon", "mc5i", "chts", "nrrmc", "npc", "ndscr", "ccc", "bce", "hls", "xhpa", "crxm", "daisy",
+    "xvpa", "sam", "cpix", "lpix", "OTbs", "OTns", "OTnc", "OTMT", "OTNL", "OTpt", "OTxr"];
+
+pub static numfnames: &'static[&'static str] = &'static[ "columns", "init_tabs", "lines",
+    "lines_of_memory", "magic_cookie_glitch", "padding_baud_rate", "virtual_terminal",
+    "width_status_line", "num_labels", "label_height", "label_width", "max_attributes",
+    "maximum_windows", "max_colors", "max_pairs", "no_color_video", "buffer_capacity",
+    "dot_vert_spacing", "dot_horz_spacing", "max_micro_address", "max_micro_jump", "micro_col_size",
+    "micro_line_size", "number_of_pins", "output_res_char", "output_res_line",
+    "output_res_horz_inch", "output_res_vert_inch", "print_rate", "wide_char_size", "buttons",
+    "bit_image_entwining", "bit_image_type", "magic_cookie_glitch_ul", "carriage_return_delay",
+    "new_line_delay", "backspace_delay", "horizontal_tab_delay", "number_of_function_keys"];
+
+pub static numnames: &'static[&'static str] = &'static[ "cols", "it", "lines", "lm", "xmc", "pb",
+    "vt", "wsl", "nlab", "lh", "lw", "ma", "wnum", "colors", "pairs", "ncv", "bufsz", "spinv",
+    "spinh", "maddr", "mjump", "mcs", "mls", "npins", "orc", "orl", "orhi", "orvi", "cps", "widcs",
+    "btns", "bitwin", "bitype", "UTug", "OTdC", "OTdN", "OTdB", "OTdT", "OTkn"];
+
+pub static stringfnames: &'static[&'static str] = &'static[ "back_tab", "bell", "carriage_return",
+    "change_scroll_region", "clear_all_tabs", "clear_screen", "clr_eol", "clr_eos",
+    "column_address", "command_character", "cursor_address", "cursor_down", "cursor_home",
+    "cursor_invisible", "cursor_left", "cursor_mem_address", "cursor_normal", "cursor_right",
+    "cursor_to_ll", "cursor_up", "cursor_visible", "delete_character", "delete_line",
+    "dis_status_line", "down_half_line", "enter_alt_charset_mode", "enter_blink_mode",
+    "enter_bold_mode", "enter_ca_mode", "enter_delete_mode", "enter_dim_mode", "enter_insert_mode",
+    "enter_secure_mode", "enter_protected_mode", "enter_reverse_mode", "enter_standout_mode",
+    "enter_underline_mode", "erase_chars", "exit_alt_charset_mode", "exit_attribute_mode",
+    "exit_ca_mode", "exit_delete_mode", "exit_insert_mode", "exit_standout_mode",
+    "exit_underline_mode", "flash_screen", "form_feed", "from_status_line", "init_1string",
+    "init_2string", "init_3string", "init_file", "insert_character", "insert_line",
+    "insert_padding", "key_backspace", "key_catab", "key_clear", "key_ctab", "key_dc", "key_dl",
+    "key_down", "key_eic", "key_eol", "key_eos", "key_f0", "key_f1", "key_f10", "key_f2", "key_f3",
+    "key_f4", "key_f5", "key_f6", "key_f7", "key_f8", "key_f9", "key_home", "key_ic", "key_il",
+    "key_left", "key_ll", "key_npage", "key_ppage", "key_right", "key_sf", "key_sr", "key_stab",
+    "key_up", "keypad_local", "keypad_xmit", "lab_f0", "lab_f1", "lab_f10", "lab_f2", "lab_f3",
+    "lab_f4", "lab_f5", "lab_f6", "lab_f7", "lab_f8", "lab_f9", "meta_off", "meta_on", "newline",
+    "pad_char", "parm_dch", "parm_delete_line", "parm_down_cursor", "parm_ich", "parm_index",
+    "parm_insert_line", "parm_left_cursor", "parm_right_cursor", "parm_rindex", "parm_up_cursor",
+    "pkey_key", "pkey_local", "pkey_xmit", "print_screen", "prtr_off", "prtr_on", "repeat_char",
+    "reset_1string", "reset_2string", "reset_3string", "reset_file", "restore_cursor",
+    "row_address", "save_cursor", "scroll_forward", "scroll_reverse", "set_attributes", "set_tab",
+    "set_window", "tab", "to_status_line", "underline_char", "up_half_line", "init_prog", "key_a1",
+    "key_a3", "key_b2", "key_c1", "key_c3", "prtr_non", "char_padding", "acs_chars", "plab_norm",
+    "key_btab", "enter_xon_mode", "exit_xon_mode", "enter_am_mode", "exit_am_mode", "xon_character",
+    "xoff_character", "ena_acs", "label_on", "label_off", "key_beg", "key_cancel", "key_close",
+    "key_command", "key_copy", "key_create", "key_end", "key_enter", "key_exit", "key_find",
+    "key_help", "key_mark", "key_message", "key_move", "key_next", "key_open", "key_options",
+    "key_previous", "key_print", "key_redo", "key_reference", "key_refresh", "key_replace",
+    "key_restart", "key_resume", "key_save", "key_suspend", "key_undo", "key_sbeg", "key_scancel",
+    "key_scommand", "key_scopy", "key_screate", "key_sdc", "key_sdl", "key_select", "key_send",
+    "key_seol", "key_sexit", "key_sfind", "key_shelp", "key_shome", "key_sic", "key_sleft",
+    "key_smessage", "key_smove", "key_snext", "key_soptions", "key_sprevious", "key_sprint",
+    "key_sredo", "key_sreplace", "key_sright", "key_srsume", "key_ssave", "key_ssuspend",
+    "key_sundo", "req_for_input", "key_f11", "key_f12", "key_f13", "key_f14", "key_f15", "key_f16",
+    "key_f17", "key_f18", "key_f19", "key_f20", "key_f21", "key_f22", "key_f23", "key_f24",
+    "key_f25", "key_f26", "key_f27", "key_f28", "key_f29", "key_f30", "key_f31", "key_f32",
+    "key_f33", "key_f34", "key_f35", "key_f36", "key_f37", "key_f38", "key_f39", "key_f40",
+    "key_f41", "key_f42", "key_f43", "key_f44", "key_f45", "key_f46", "key_f47", "key_f48",
+    "key_f49", "key_f50", "key_f51", "key_f52", "key_f53", "key_f54", "key_f55", "key_f56",
+    "key_f57", "key_f58", "key_f59", "key_f60", "key_f61", "key_f62", "key_f63", "clr_bol",
+    "clear_margins", "set_left_margin", "set_right_margin", "label_format", "set_clock",
+    "display_clock", "remove_clock", "create_window", "goto_window", "hangup", "dial_phone",
+    "quick_dial", "tone", "pulse", "flash_hook", "fixed_pause", "wait_tone", "user0", "user1",
+    "user2", "user3", "user4", "user5", "user6", "user7", "user8", "user9", "orig_pair",
+    "orig_colors", "initialize_color", "initialize_pair", "set_color_pair", "set_foreground",
+    "set_background", "change_char_pitch", "change_line_pitch", "change_res_horz",
+    "change_res_vert", "define_char", "enter_doublewide_mode", "enter_draft_quality",
+    "enter_italics_mode", "enter_leftward_mode", "enter_micro_mode", "enter_near_letter_quality",
+    "enter_normal_quality", "enter_shadow_mode", "enter_subscript_mode", "enter_superscript_mode",
+    "enter_upward_mode", "exit_doublewide_mode", "exit_italics_mode", "exit_leftward_mode",
+    "exit_micro_mode", "exit_shadow_mode", "exit_subscript_mode", "exit_superscript_mode",
+    "exit_upward_mode", "micro_column_address", "micro_down", "micro_left", "micro_right",
+    "micro_row_address", "micro_up", "order_of_pins", "parm_down_micro", "parm_left_micro",
+    "parm_right_micro", "parm_up_micro", "select_char_set", "set_bottom_margin",
+    "set_bottom_margin_parm", "set_left_margin_parm", "set_right_margin_parm", "set_top_margin",
+    "set_top_margin_parm", "start_bit_image", "start_char_set_def", "stop_bit_image",
+    "stop_char_set_def", "subscript_characters", "superscript_characters", "these_cause_cr",
+    "zero_motion", "char_set_names", "key_mouse", "mouse_info", "req_mouse_pos", "get_mouse",
+    "set_a_foreground", "set_a_background", "pkey_plab", "device_type", "code_set_init",
+    "set0_des_seq", "set1_des_seq", "set2_des_seq", "set3_des_seq", "set_lr_margin",
+    "set_tb_margin", "bit_image_repeat", "bit_image_newline", "bit_image_carriage_return",
+    "color_names", "define_bit_image_region", "end_bit_image_region", "set_color_band",
+    "set_page_length", "display_pc_char", "enter_pc_charset_mode", "exit_pc_charset_mode",
+    "enter_scancode_mode", "exit_scancode_mode", "pc_term_options", "scancode_escape",
+    "alt_scancode_esc", "enter_horizontal_hl_mode", "enter_left_hl_mode", "enter_low_hl_mode",
+    "enter_right_hl_mode", "enter_top_hl_mode", "enter_vertical_hl_mode", "set_a_attributes",
+    "set_pglen_inch", "termcap_init2", "termcap_reset", "linefeed_if_not_lf", "backspace_if_not_bs",
+    "other_non_function_keys", "arrow_key_map", "acs_ulcorner", "acs_llcorner", "acs_urcorner",
+    "acs_lrcorner", "acs_ltee", "acs_rtee", "acs_btee", "acs_ttee", "acs_hline", "acs_vline",
+    "acs_plus", "memory_lock", "memory_unlock", "box_chars_1"];
+
+pub static stringnames: &'static[&'static str] = &'static[ "cbt", "_", "cr", "csr", "tbc", "clear",
+    "_", "_", "hpa", "cmdch", "cup", "cud1", "home", "civis", "cub1", "mrcup", "cnorm", "cuf1",
+    "ll", "cuu1", "cvvis", "dch1", "dl1", "dsl", "hd", "smacs", "blink", "bold", "smcup", "smdc",
+    "dim", "smir", "invis", "prot", "rev", "smso", "smul", "ech", "rmacs", "sgr0", "rmcup", "rmdc",
+    "rmir", "rmso", "rmul", "flash", "ff", "fsl", "is1", "is2", "is3", "if", "ich1", "il1", "ip",
+    "kbs", "ktbc", "kclr", "kctab", "_", "_", "kcud1", "_", "_", "_", "_", "_", "_", "_", "_", "_",
+    "_", "_", "_", "_", "_", "khome", "_", "_", "kcub1", "_", "knp", "kpp", "kcuf1", "_", "_",
+    "khts", "_", "rmkx", "smkx", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "rmm", "_",
+    "_", "pad", "dch", "dl", "cud", "ich", "indn", "il", "cub", "cuf", "rin", "cuu", "pfkey",
+    "pfloc", "pfx", "mc0", "mc4", "_", "rep", "rs1", "rs2", "rs3", "rf", "rc", "vpa", "sc", "ind",
+    "ri", "sgr", "_", "wind", "_", "tsl", "uc", "hu", "iprog", "_", "_", "_", "_", "_", "mc5p",
+    "rmp", "acsc", "pln", "kcbt", "smxon", "rmxon", "smam", "rmam", "xonc", "xoffc", "_", "smln",
+    "rmln", "_", "kcan", "kclo", "kcmd", "kcpy", "kcrt", "_", "kent", "kext", "kfnd", "khlp",
+    "kmrk", "kmsg", "kmov", "knxt", "kopn", "kopt", "kprv", "kprt", "krdo", "kref", "krfr", "krpl",
+    "krst", "kres", "ksav", "kspd", "kund", "kBEG", "kCAN", "kCMD", "kCPY", "kCRT", "_", "_",
+    "kslt", "kEND", "kEOL", "kEXT", "kFND", "kHLP", "kHOM", "_", "kLFT", "kMSG", "kMOV", "kNXT",
+    "kOPT", "kPRV", "kPRT", "kRDO", "kRPL", "kRIT", "kRES", "kSAV", "kSPD", "kUND", "rfi", "_", "_",
+    "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
+    "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
+    "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
+    "dclk", "rmclk", "cwin", "wingo", "_", "dial", "qdial", "_", "_", "hook", "pause", "wait", "_",
+    "_", "_", "_", "_", "_", "_", "_", "_", "_", "op", "oc", "initc", "initp", "scp", "setf",
+    "setb", "cpi", "lpi", "chr", "cvr", "defc", "swidm", "sdrfq", "sitm", "slm", "smicm", "snlq",
+    "snrmq", "sshm", "ssubm", "ssupm", "sum", "rwidm", "ritm", "rlm", "rmicm", "rshm", "rsubm",
+    "rsupm", "rum", "mhpa", "mcud1", "mcub1", "mcuf1", "mvpa", "mcuu1", "porder", "mcud", "mcub",
+    "mcuf", "mcuu", "scs", "smgb", "smgbp", "smglp", "smgrp", "smgt", "smgtp", "sbim", "scsd",
+    "rbim", "rcsd", "subcs", "supcs", "docr", "zerom", "csnm", "kmous", "minfo", "reqmp", "getm",
+    "setaf", "setab", "pfxl", "devt", "csin", "s0ds", "s1ds", "s2ds", "s3ds", "smglr", "smgtb",
+    "birep", "binel", "bicr", "colornm", "defbi", "endbi", "setcolor", "slines", "dispc", "smpch",
+    "rmpch", "smsc", "rmsc", "pctrm", "scesc", "scesa", "ehhlm", "elhlm", "elohlm", "erhlm",
+    "ethlm", "evhlm", "sgr1", "slength", "OTi2", "OTrs", "OTnl", "OTbs", "OTko", "OTma", "OTG2",
+    "OTG3", "OTG1", "OTG4", "OTGR", "OTGL", "OTGU", "OTGD", "OTGH", "OTGV", "OTGC", "meml", "memu",
+    "box1"];
+
+/// Parse a compiled terminfo entry, using long capability names if `longnames` is true
+pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
+    let bnames, snames, nnames;
+
+    if longnames {
+        bnames = boolfnames;
+        snames = stringfnames;
+        nnames = numfnames;
+    } else {
+        bnames = boolnames;
+        snames = stringnames;
+        nnames = numnames;
+    }
+
+    // Check magic number
+    let magic = file.read_le_u16();
+    if (magic != 0x011A) {
+        return Err(fmt!("invalid magic number: expected %x but found %x", 0x011A, magic as uint));
+    }
+
+    let names_bytes          = file.read_le_i16() as int;
+    let bools_bytes          = file.read_le_i16() as int;
+    let numbers_count        = file.read_le_i16() as int;
+    let string_offsets_count = file.read_le_i16() as int;
+    let string_table_bytes   = file.read_le_i16() as int;
+
+    assert!(names_bytes          > 0);
+
+    debug!("names_bytes = %?", names_bytes);
+    debug!("bools_bytes = %?", bools_bytes);
+    debug!("numbers_count = %?", numbers_count);
+    debug!("string_offsets_count = %?", string_offsets_count);
+    debug!("string_table_bytes = %?", string_table_bytes);
+
+    if (bools_bytes as uint) > boolnames.len() {
+        error!("expected bools_bytes to be less than %? but found %?", boolnames.len(),
+               bools_bytes);
+        return Err(~"incompatible file: more booleans than expected");
+    }
+
+    if (numbers_count as uint) > numnames.len() {
+        error!("expected numbers_count to be less than %? but found %?", numnames.len(),
+               numbers_count);
+        return Err(~"incompatible file: more numbers than expected");
+    }
+
+    if (string_offsets_count as uint) > stringnames.len() {
+        error!("expected string_offsets_count to be less than %? but found %?", stringnames.len(),
+               string_offsets_count);
+        return Err(~"incompatible file: more string offsets than expected");
+    }
+
+    let mut term_names: ~[~str] = vec::with_capacity(2);
+    let names_str = str::from_bytes(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
+    for names_str.each_split_char('|') |s| {
+        term_names.push(s.to_owned());
+    }
+
+    file.read_byte(); // consume NUL
+
+    debug!("term names: %?", term_names);
+
+    let mut bools_map = HashMap::new();
+    if bools_bytes != 0 {
+        for int::range(0, bools_bytes) |i| {
+            let b = file.read_byte();
+            if b < 0 {
+                error!("EOF reading bools after %? entries", i);
+                return Err(~"error: expected more bools but hit EOF");
+            } else if b == 1 {
+                debug!("%s set", bnames[i]);
+                bools_map.insert(bnames[i].to_owned(), true);
+            }
+        }
+    }
+
+    debug!("bools: %?", bools_map);
+
+    if (bools_bytes + names_bytes) % 2 == 1 {
+        debug!("adjusting for padding between bools and numbers");
+        file.read_byte(); // compensate for padding
+    }
+
+    let mut numbers_map = HashMap::new();
+    if numbers_count != 0 {
+        for int::range(0, numbers_count) |i| {
+            let n = file.read_le_u16();
+            if n != 0xFFFF {
+                debug!("%s#%?", nnames[i], n);
+                numbers_map.insert(nnames[i].to_owned(), n);
+            }
+        }
+    }
+
+    debug!("numbers: %?", numbers_map);
+
+    let mut string_map = HashMap::new();
+
+    if string_offsets_count != 0 {
+        let mut string_offsets = vec::with_capacity(10);
+        for int::range(0, string_offsets_count) |_i| {
+            string_offsets.push(file.read_le_u16());
+        }
+
+        debug!("offsets: %?", string_offsets);
+
+        let string_table = file.read_bytes(string_table_bytes as uint);
+
+        if string_table.len() != string_table_bytes as uint {
+            error!("EOF reading string table after %? bytes, wanted %?", string_table.len(),
+                   string_table_bytes);
+            return Err(~"error: hit EOF before end of string table");
+        }
+
+        for string_offsets.eachi |i, v| {
+            let offset = *v;
+            if offset == 0xFFFF { // non-entry
+                loop;
+            }
+
+            let name = if snames[i] == "_" {
+                stringfnames[i]
+            } else {
+                snames[i]
+            };
+
+            if offset == 0xFFFE {
+                // undocumented: FFFE indicates cap@, which means the capability is not present
+                // unsure if the handling for this is correct
+                string_map.insert(name.to_owned(), ~[]);
+                loop;
+            }
+
+
+            // Find the offset of the NUL we want to go to
+            let nulpos = vec::position_between(string_table, offset as uint,
+                                               string_table_bytes as uint, |&b| b == 0);
+            match nulpos {
+                Some(x) => {
+                    string_map.insert(name.to_owned(),
+                                      string_table.slice(offset as uint, x).to_owned())
+                },
+                None => {
+                    return Err(~"invalid file: missing NUL in string_table");
+                }
+            };
+        }
+    }
+
+    // And that's all there is to it
+    Ok(~TermInfo {names: term_names, bools: bools_map, numbers: numbers_map, strings: string_map })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use p = core::path::Path;
+
+    #[test]
+    fn test_veclens() {
+        assert_eq!(boolfnames.len(), boolnames.len());
+        assert_eq!(numfnames.len(), numnames.len());
+        assert_eq!(stringfnames.len(), stringnames.len());
+    }
+
+    #[test]
+    #[ignore(reason = "no ncurses on buildbots, needs a bundled terminfo file to test against")]
+    fn test_parse() {
+        // FIXME #6870: Distribute a compiled file in src/tests and test there
+        // parse(io::file_reader(&p("/usr/share/terminfo/r/rxvt-256color")).unwrap(), false);
+    }
+}

src/libextra/terminfo/searcher.rs

@@ -0,0 +1,89 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// Implement ncurses-compatible database discovery
+/// Does not support hashed database, only filesystem!
+
+use core::prelude::*;
+use core::{os, str};
+use core::os::getenv;
+use core::io::{file_reader, Reader};
+use path = core::path::Path;
+
+/// Return path to database entry for `term`
+pub fn get_dbpath_for_term(term: &str) -> Option<~path> {
+    if term.len() == 0 {
+        return None;
+    }
+
+    let homedir = os::homedir();
+
+    let mut dirs_to_search = ~[];
+    let first_char = term.substr(0, 1);
+
+    // Find search directory
+    match getenv("TERMINFO") {
+        Some(dir) => dirs_to_search.push(path(dir)),
+        None => {
+            if homedir.is_some() {
+                dirs_to_search.push(homedir.unwrap().push(".terminfo")); // ncurses compatability
+            }
+            match getenv("TERMINFO_DIRS") {
+                Some(dirs) => for str::each_split_char(dirs, ':') |i| {
+                    if i == "" {
+                        dirs_to_search.push(path("/usr/share/terminfo"));
+                    } else {
+                        dirs_to_search.push(path(i.to_owned()));
+                    }
+                },
+                // Found nothing, use the default path
+                None => dirs_to_search.push(path("/usr/share/terminfo"))
+            }
+        }
+    };
+
+    // Look for the terminal in all of the search directories
+    for dirs_to_search.each |p| {
+        let newp = ~p.push_many(&[first_char.to_owned(), term.to_owned()]);
+        if os::path_exists(p) && os::path_exists(newp) {
+            return Some(newp);
+        }
+    }
+    None
+}
+
+/// Return open file for `term`
+pub fn open(term: &str) -> Result<@Reader, ~str> {
+    match get_dbpath_for_term(term) {
+        Some(x) => file_reader(x),
+        None => Err(fmt!("could not find terminfo entry for %s", term))
+    }
+}
+
+#[test]
+#[ignore(reason = "buildbots don't have ncurses installed and I can't mock everything I need")]
+fn test_get_dbpath_for_term() {
+    // woefully inadequate test coverage
+    use std::os::{setenv, unsetenv};
+    fn x(t: &str) -> ~str { get_dbpath_for_term(t).expect("no terminfo entry found").to_str() };
+    assert!(x("screen") == ~"/usr/share/terminfo/s/screen");
+    assert!(get_dbpath_for_term("") == None);
+    setenv("TERMINFO_DIRS", ":");
+    assert!(x("screen") == ~"/usr/share/terminfo/s/screen");
+    unsetenv("TERMINFO_DIRS");
+}
+
+#[test]
+#[ignore(reason = "see test_get_dbpath_for_term")]
+fn test_open() {
+    open("screen");
+    let t = open("nonexistent terminal that hopefully does not exist");
+    assert!(t.is_err());
+}

src/libextra/terminfo/terminfo.rs

@@ -0,0 +1,29 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::hashmap::HashMap;
+
+/// A parsed terminfo entry.
+pub struct TermInfo {
+    /// Names for the terminal
+    names: ~[~str],
+    /// Map of capability name to boolean value
+    bools: HashMap<~str, bool>,
+    /// Map of capability name to numeric value
+    numbers: HashMap<~str, u16>,
+    /// Map of capability name to raw (unexpanded) string
+    strings: HashMap<~str, ~[u8]>
+}
+
+pub mod searcher;
+pub mod parser {
+    pub mod compiled;
+}
+pub mod parm;

src/libextra/test.rs

@@ -210,7 +210,6 @@ struct ConsoleTestState {
 // A simple console test runner
 pub fn run_tests_console(opts: &TestOpts,
                          tests: ~[TestDescAndFn]) -> bool {
-
     fn callback(event: &TestEvent, st: &mut ConsoleTestState) {
         debug!("callback(event=%?)", event);
         match copy *event {
@@ -347,12 +346,18 @@ pub fn run_tests_console(opts: &TestOpts,
                     word: &str,
                     color: u8,
                     use_color: bool) {
-        if use_color && term::color_supported() {
-            term::fg(out, color);
-        }
-        out.write_str(word);
-        if use_color && term::color_supported() {
-            term::reset(out);
+        let t = term::Terminal::new(out);
+        match t {
+            Ok(term)  => {
+                if use_color && term.color_supported {
+                    term.fg(color);
+                }
+                out.write_str(word);
+                if use_color && term.color_supported {
+                    term.reset();
+                }
+            },
+            Err(_) => out.write_str(word)
         }
     }
 }

src/librustpkg/util.rs

@@ -162,43 +162,31 @@ pub fn need_dir(s: &Path) {
     }
 }
 
-pub fn note(msg: ~str) {
-    let out = io::stdout();
-
-    if term::color_supported() {
-        term::fg(out, term::color_green);
-        out.write_str("note: ");
-        term::reset(out);
-        out.write_line(msg);
-    } else {
-        out.write_line(~"note: " + msg);
+fn pretty_message<'a>(msg: &'a str, prefix: &'a str, color: u8, out: @io::Writer) {
+    let term = term::Terminal::new(out);
+    match term {
+        Ok(ref t) => {
+            t.fg(color);
+            out.write_str(prefix);
+            t.reset();
+        },
+        _ => {
+            out.write_str(prefix);
+        }
     }
+    out.write_line(msg);
 }
 
-pub fn warn(msg: ~str) {
-    let out = io::stdout();
-
-    if term::color_supported() {
-        term::fg(out, term::color_yellow);
-        out.write_str("warning: ");
-        term::reset(out);
-        out.write_line(msg);
-    } else {
-        out.write_line(~"warning: " + msg);
-    }
+pub fn note(msg: &str) {
+    pretty_message(msg, "note: ", term::color_green, io::stdout())
 }
 
-pub fn error(msg: ~str) {
-    let out = io::stdout();
+pub fn warn(msg: &str) {
+    pretty_message(msg, "warning: ", term::color_yellow, io::stdout())
+}
 
-    if term::color_supported() {
-        term::fg(out, term::color_red);
-        out.write_str("error: ");
-        term::reset(out);
-        out.write_line(msg);
-    } else {
-        out.write_line(~"error: " + msg);
-    }
+pub fn error(msg: &str) {
+    pretty_message(msg, "error: ", term::color_red, io::stdout())
 }
 
 // FIXME (#4432): Use workcache to only compile when needed

src/libsyntax/diagnostic.rs

@@ -191,19 +191,27 @@ fn diagnosticcolor(lvl: level) -> u8 {
 }
 
 fn print_diagnostic(topic: &str, lvl: level, msg: &str) {
-    let use_color = term::color_supported() &&
-        io::stderr().get_type() == io::Screen;
+    let t = term::Terminal::new(io::stderr());
+
+    let stderr = io::stderr();
+
     if !topic.is_empty() {
-        io::stderr().write_str(fmt!("%s ", topic));
+        stderr.write_str(fmt!("%s ", topic));
     }
-    if use_color {
-        term::fg(io::stderr(), diagnosticcolor(lvl));
+
+    match t {
+        Ok(term) => {
+            if stderr.get_type() == io::Screen {
+                term.fg(diagnosticcolor(lvl));
+                stderr.write_str(fmt!("%s: ", diagnosticstr(lvl)));
+                term.reset();
+                stderr.write_str(fmt!("%s\n", msg));
+            } else {
+                stderr.write_str(fmt!("%s: %s\n", diagnosticstr(lvl), msg));
+            }
+        },
+        _ => stderr.write_str(fmt!("%s: %s\n", diagnosticstr(lvl), msg))
     }
-    io::stderr().write_str(fmt!("%s:", diagnosticstr(lvl)));
-    if use_color {
-        term::reset(io::stderr());
-    }
-    io::stderr().write_str(fmt!(" %s\n", msg));
 }
 
 pub fn collect(messages: @mut ~[~str])