use std::collections::HashMap;
use std::io::prelude::*;
use std::io;
use terminfo::Error::*;
use terminfo::TermInfo;
use Result;
pub use terminfo::parser::names::*;
fn read_le_u16(r: &mut io::Read) -> io::Result<u16> {
let mut b = [0; 2];
let mut amt = 0;
while amt < b.len() {
match try!(r.read(&mut b[amt..])) {
0 => return Err(io::Error::new(io::ErrorKind::Other, "end of file")),
n => amt += n,
}
}
Ok((b[0] as u16) | ((b[1] as u16) << 8))
}
fn read_byte(r: &mut io::Read) -> io::Result<u8> {
match r.bytes().next() {
Some(s) => s,
None => Err(io::Error::new(io::ErrorKind::Other, "end of file")),
}
}
pub fn parse(file: &mut io::Read, longnames: bool) -> Result<TermInfo> {
let (bnames, snames, nnames) = if longnames {
(boolfnames, stringfnames, numfnames)
} else {
(boolnames, stringnames, numnames)
};
let magic = try!(read_le_u16(file));
if magic != 0x011A {
return Err(BadMagic(magic).into());
}
macro_rules! read_nonneg {
() => {{
match try!(read_le_u16(file)) as i16 {
n if n >= 0 => n as usize,
-1 => 0,
_ => return Err(InvalidLength.into()),
}
}}
}
let names_bytes = read_nonneg!();
let bools_bytes = read_nonneg!();
let numbers_count = read_nonneg!();
let string_offsets_count = read_nonneg!();
let string_table_bytes = read_nonneg!();
if names_bytes == 0 {
return Err(ShortNames.into());
}
if bools_bytes > boolnames.len() {
return Err(TooManyBools.into());
}
if numbers_count > numnames.len() {
return Err(TooManyNumbers.into());
}
if string_offsets_count > stringnames.len() {
return Err(TooManyStrings.into());
}
let mut bytes = Vec::new();
try!(file.take((names_bytes - 1) as u64).read_to_end(&mut bytes));
let names_str = match String::from_utf8(bytes) {
Ok(s) => s,
Err(e) => return Err(NotUtf8(e.utf8_error()).into()),
};
let term_names: Vec<String> = names_str.split('|')
.map(|s| s.to_string())
.collect();
if try!(read_byte(file)) != b'\0' {
return Err(NamesMissingNull.into());
}
let bools_map: HashMap<String, bool> = try! {
(0..bools_bytes).filter_map(|i| match read_byte(file) {
Err(e) => Some(Err(e)),
Ok(1) => Some(Ok((bnames[i].to_string(), true))),
Ok(_) => None
}).collect()
};
if (bools_bytes + names_bytes) % 2 == 1 {
try!(read_byte(file)); }
let numbers_map: HashMap<String, u16> = try! {
(0..numbers_count).filter_map(|i| match read_le_u16(file) {
Ok(0xFFFF) => None,
Ok(n) => Some(Ok((nnames[i].to_string(), n))),
Err(e) => Some(Err(e))
}).collect()
};
let string_map: HashMap<String, Vec<u8>> = if string_offsets_count > 0 {
let string_offsets: Vec<u16> = try!((0..string_offsets_count)
.map(|_| read_le_u16(file))
.collect());
let mut string_table = Vec::new();
try!(file.take(string_table_bytes as u64).read_to_end(&mut string_table));
try!(string_offsets.into_iter()
.enumerate()
.filter(|&(_, offset)| {
offset != 0xFFFF
})
.map(|(i, offset)| {
let offset = offset as usize;
let name = if snames[i] == "_" {
stringfnames[i]
} else {
snames[i]
};
if offset == 0xFFFE {
return Ok((name.to_string(), Vec::new()));
}
let nulpos = string_table[offset..string_table_bytes]
.iter()
.position(|&b| b == 0);
match nulpos {
Some(len) => {
Ok((name.to_string(),
string_table[offset..offset + len].to_vec()))
}
None => return Err(::Error::TerminfoParsing(StringsMissingNull)),
}
})
.collect())
} else {
HashMap::new()
};
Ok(TermInfo {
names: term_names,
bools: bools_map,
numbers: numbers_map,
strings: string_map,
})
}
pub fn msys_terminfo() -> TermInfo {
let mut strings = HashMap::new();
strings.insert("sgr0".to_string(), b"\x1B[0m".to_vec());
strings.insert("bold".to_string(), b"\x1B[1m".to_vec());
strings.insert("setaf".to_string(), b"\x1B[3%p1%dm".to_vec());
strings.insert("setab".to_string(), b"\x1B[4%p1%dm".to_vec());
let mut numbers = HashMap::new();
numbers.insert("colors".to_string(), 8u16);
TermInfo {
names: vec!["cygwin".to_string()], bools: HashMap::new(),
numbers: numbers,
strings: strings,
}
}
#[cfg(test)]
mod test {
use super::{boolnames, boolfnames, numnames, numfnames, stringnames, stringfnames};
#[test]
fn test_veclens() {
assert_eq!(boolfnames.len(), boolnames.len());
assert_eq!(numfnames.len(), numnames.len());
assert_eq!(stringfnames.len(), stringnames.len());
}
}