use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io;
use std::io::BufReader;
use std::path::Path;
use Attr;
use color;
use Terminal;
use Result;
use self::searcher::get_dbpath_for_term;
use self::parser::compiled::{parse, msys_terminfo};
use self::parm::{expand, Variables, Param};
use self::Error::*;
#[derive(Debug)]
pub struct TermInfo {
pub names: Vec<String>,
pub bools: HashMap<String, bool>,
pub numbers: HashMap<String, u16>,
pub strings: HashMap<String, Vec<u8>>,
}
impl TermInfo {
pub fn from_env() -> Result<TermInfo> {
let term = match env::var("TERM") {
Ok(name) => TermInfo::from_name(&name),
Err(..) => return Err(::Error::TermUnset),
};
if term.is_err() && env::var("MSYSCON").ok().map_or(false, |s| "mintty.exe" == s) {
Ok(msys_terminfo())
} else {
term
}
}
pub fn from_name(name: &str) -> Result<TermInfo> {
get_dbpath_for_term(name)
.ok_or_else(|| ::Error::TerminfoEntryNotFound)
.and_then(|p| TermInfo::from_path(&p))
}
pub fn from_path<P: AsRef<Path>>(path: P) -> Result<TermInfo> {
Self::_from_path(path.as_ref())
}
fn _from_path(path: &Path) -> Result<TermInfo> {
let file = try!(File::open(path).map_err(|e| ::Error::Io(e)));
let mut reader = BufReader::new(file);
parse(&mut reader, false)
}
}
#[derive(Debug, Eq, PartialEq)]
pub enum Error {
BadMagic(u16),
NotUtf8(::std::str::Utf8Error),
ShortNames,
TooManyBools,
TooManyNumbers,
TooManyStrings,
InvalidLength,
NamesMissingNull,
StringsMissingNull,
}
impl ::std::fmt::Display for Error {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
use std::error::Error;
match self {
&NotUtf8(e) => write!(f, "{}", e),
&BadMagic(v) => write!(f, "bad magic number {:x} in terminfo header", v),
_ => f.write_str(self.description()),
}
}
}
impl ::std::convert::From<::std::string::FromUtf8Error> for Error {
fn from(v: ::std::string::FromUtf8Error) -> Self {
NotUtf8(v.utf8_error())
}
}
impl ::std::error::Error for Error {
fn description(&self) -> &str {
match self {
&BadMagic(..) => "incorrect magic number at start of file",
&ShortNames => "no names exposed, need at least one",
&TooManyBools => "more boolean properties than libterm knows about",
&TooManyNumbers => "more number properties than libterm knows about",
&TooManyStrings => "more string properties than libterm knows about",
&InvalidLength => "invalid length field value, must be >= -1",
&NotUtf8(ref e) => e.description(),
&NamesMissingNull => "names table missing NUL terminator",
&StringsMissingNull => "string table missing NUL terminator",
}
}
fn cause(&self) -> Option<&::std::error::Error> {
match self {
&NotUtf8(ref e) => Some(e),
_ => None,
}
}
}
pub mod searcher;
pub mod parser {
pub mod compiled;
mod names;
}
pub mod parm;
fn cap_for_attr(attr: Attr) -> &'static str {
match attr {
Attr::Bold => "bold",
Attr::Dim => "dim",
Attr::Italic(true) => "sitm",
Attr::Italic(false) => "ritm",
Attr::Underline(true) => "smul",
Attr::Underline(false) => "rmul",
Attr::Blink => "blink",
Attr::Standout(true) => "smso",
Attr::Standout(false) => "rmso",
Attr::Reverse => "rev",
Attr::Secure => "invis",
Attr::ForegroundColor(_) => "setaf",
Attr::BackgroundColor(_) => "setab",
}
}
pub struct TerminfoTerminal<T> {
num_colors: u16,
out: T,
ti: TermInfo,
}
impl<T: Write + Send> Terminal for TerminfoTerminal<T> {
type Output = T;
fn fg(&mut self, color: color::Color) -> Result<()> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
return self.apply_cap("setaf", &[Param::Number(color as i32)]);
}
Err(::Error::ColorOutOfRange)
}
fn bg(&mut self, color: color::Color) -> Result<()> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
return self.apply_cap("setab", &[Param::Number(color as i32)]);
}
Err(::Error::ColorOutOfRange)
}
fn attr(&mut self, attr: Attr) -> Result<()> {
match attr {
Attr::ForegroundColor(c) => self.fg(c),
Attr::BackgroundColor(c) => self.bg(c),
_ => self.apply_cap(cap_for_attr(attr), &[]),
}
}
fn supports_attr(&self, attr: Attr) -> bool {
match attr {
Attr::ForegroundColor(_) | Attr::BackgroundColor(_) => self.num_colors > 0,
_ => {
let cap = cap_for_attr(attr);
self.ti.strings.get(cap).is_some()
}
}
}
fn reset(&mut self) -> Result<()> {
let cmd = match [("sgr0", &[] as &[Param]),
("sgr", &[Param::Number(0)]),
("op", &[])]
.iter()
.filter_map(|&(cap, params)| self.ti.strings.get(cap).map(|c| (c, params)))
.next() {
Some((op, params)) => {
match expand(op, params, &mut Variables::new()) {
Ok(cmd) => cmd,
Err(e) => return Err(e.into()),
}
}
None => return Err(::Error::NotSupported),
};
try!(self.out.write_all(&cmd));
Ok(())
}
fn cursor_up(&mut self) -> Result<()> {
self.apply_cap("cuu1", &[])
}
fn delete_line(&mut self) -> Result<()> {
self.apply_cap("dl", &[])
}
fn carriage_return(&mut self) -> Result<()> {
self.apply_cap("cr", &[])
}
fn get_ref<'a>(&'a self) -> &'a T {
&self.out
}
fn get_mut<'a>(&'a mut self) -> &'a mut T {
&mut self.out
}
fn into_inner(self) -> T
where Self: Sized
{
self.out
}
}
impl<T: Write + Send> TerminfoTerminal<T> {
pub fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
let nc = if terminfo.strings.contains_key("setaf") &&
terminfo.strings.contains_key("setab") {
terminfo.numbers.get("colors").map_or(0, |&n| n)
} else {
0
};
TerminfoTerminal {
out: out,
ti: terminfo,
num_colors: nc,
}
}
pub fn new(out: T) -> Option<TerminfoTerminal<T>> {
TermInfo::from_env().map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti)).ok()
}
fn dim_if_necessary(&self, color: color::Color) -> color::Color {
if color >= self.num_colors && color >= 8 && color < 16 {
color - 8
} else {
color
}
}
fn apply_cap(&mut self, cmd: &str, params: &[Param]) -> Result<()> {
match self.ti.strings.get(cmd) {
Some(cmd) => {
match expand(&cmd, params, &mut Variables::new()) {
Ok(s) => {
try!(self.out.write_all(&s));
Ok(())
}
Err(e) => Err(e.into()),
}
}
None => Err(::Error::NotSupported),
}
}
}
impl<T: Write> Write for TerminfoTerminal<T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.out.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.out.flush()
}
}