summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorPhilipp Gesang <phg@phi-gamma.net>2021-11-09 23:29:15 +0100
committerPhilipp Gesang <phg@phi-gamma.net>2021-11-10 01:20:11 +0100
commit500ea902333f3952e29a22a4679dde7f63aebe34 (patch)
treede8779ca4c5216b0ae869d80647777be01219d0d /src
parent38c67cad817419c5f8f7b2c2cb90f3ac7cf5fd0b (diff)
downloadvtcol-500ea902333f3952e29a22a4679dde7f63aebe34.tar.gz
format with rustfmt
Diffstat (limited to 'src')
-rw-r--r--src/vtcol.rs623
1 files changed, 285 insertions, 338 deletions
diff --git a/src/vtcol.rs b/src/vtcol.rs
index 993653b..174b62f 100644
--- a/src/vtcol.rs
+++ b/src/vtcol.rs
@@ -1,5 +1,5 @@
-use std::sync::Mutex;
use lazy_static::lazy_static;
+use std::sync::Mutex;
type Fd = libc::c_int;
@@ -13,132 +13,129 @@ macro_rules! vrb {
)}
}
-const PALETTE_SIZE : usize = 16_usize;
-const PALETTE_BYTES : usize = PALETTE_SIZE * 3_usize; // 16 * sizeof(int)
+const PALETTE_SIZE: usize = 16_usize;
+const PALETTE_BYTES: usize = PALETTE_SIZE * 3_usize; // 16 * sizeof(int)
-const RAW_COLEXPR_SIZE : usize = 6_usize; // e. g. 0xBADF00
+const RAW_COLEXPR_SIZE: usize = 6_usize; // e. g. 0xBADF00
type RawPalette<'a> = [&'a str; PALETTE_SIZE];
-const KDGKBTYPE : libc::c_int = 0x4b33; /* kd.h */
-const PIO_CMAP : libc::c_int = 0x00004B71; /* kd.h */
-const KB_101 : libc::c_char = 0x0002; /* kd.h */
-const O_NOCTTY : libc::c_int = 0o0400; /* fcntl.h */
+const KDGKBTYPE: libc::c_int = 0x4b33; /* kd.h */
+const PIO_CMAP: libc::c_int = 0x00004B71; /* kd.h */
+const KB_101: libc::c_char = 0x0002; /* kd.h */
+const O_NOCTTY: libc::c_int = 0o0400; /* fcntl.h */
#[derive(Debug)]
-enum Color {
- Black(bool), Red(bool), Green(bool), Yellow(bool),
- Blue(bool), Magenta(bool), Cyan(bool), White(bool),
+enum Color
+{
+ Black(bool),
+ Red(bool),
+ Green(bool),
+ Yellow(bool),
+ Blue(bool),
+ Magenta(bool),
+ Cyan(bool),
+ White(bool),
}
-impl Color {
-
- fn
- of_value (val : u8)
- -> Color
+impl Color
+{
+ fn of_value(val: u8) -> Color
{
- match val
- {
- 0x00_u8 => Color::Black (false),
- 0x01_u8 => Color::Red (false),
- 0x02_u8 => Color::Green (false),
- 0x03_u8 => Color::Yellow (false),
- 0x04_u8 => Color::Blue (false),
- 0x05_u8 => Color::Magenta (false),
- 0x06_u8 => Color::Cyan (false),
- 0x07_u8 => Color::White (false),
-
- 0x08_u8 => Color::Black (true),
- 0x09_u8 => Color::Red (true),
- 0x0a_u8 => Color::Green (true),
- 0x0b_u8 => Color::Yellow (true),
- 0x0c_u8 => Color::Blue (true),
- 0x0d_u8 => Color::Magenta (true),
- 0x0e_u8 => Color::Cyan (true),
- 0x0f_u8 => Color::White (true),
-
- _ => panic!("invalid color value: {}", val)
+ match val {
+ 0x00_u8 => Color::Black(false),
+ 0x01_u8 => Color::Red(false),
+ 0x02_u8 => Color::Green(false),
+ 0x03_u8 => Color::Yellow(false),
+ 0x04_u8 => Color::Blue(false),
+ 0x05_u8 => Color::Magenta(false),
+ 0x06_u8 => Color::Cyan(false),
+ 0x07_u8 => Color::White(false),
+
+ 0x08_u8 => Color::Black(true),
+ 0x09_u8 => Color::Red(true),
+ 0x0a_u8 => Color::Green(true),
+ 0x0b_u8 => Color::Yellow(true),
+ 0x0c_u8 => Color::Blue(true),
+ 0x0d_u8 => Color::Magenta(true),
+ 0x0e_u8 => Color::Cyan(true),
+ 0x0f_u8 => Color::White(true),
+
+ _ => panic!("invalid color value: {}", val),
}
}
- fn
- format_brightness
- (b : bool,
- s : &str)
- -> String
+ fn format_brightness(b: bool, s: &str) -> String
{
- if b { "bright ".to_string() + s }
- else { s.to_string() }
+ if b {
+ "bright ".to_string() + s
+ } else {
+ s.to_string()
+ }
}
- fn
- to_string
- (&self)
- -> String
+ fn to_string(&self) -> String
{
- match *self
- {
- Color::Black (b) => { Color::format_brightness(b, "black" ) },
- Color::Red (b) => { Color::format_brightness(b, "red" ) },
- Color::Green (b) => { Color::format_brightness(b, "green" ) },
- Color::Yellow (b) => { Color::format_brightness(b, "yellow" ) },
- Color::Blue (b) => { Color::format_brightness(b, "blue" ) },
- Color::Magenta(b) => { Color::format_brightness(b, "magenta") },
- Color::Cyan (b) => { Color::format_brightness(b, "cyan" ) },
- Color::White (b) => { Color::format_brightness(b, "white" ) },
+ match *self {
+ Color::Black(b) => Color::format_brightness(b, "black"),
+ Color::Red(b) => Color::format_brightness(b, "red"),
+ Color::Green(b) => Color::format_brightness(b, "green"),
+ Color::Yellow(b) => Color::format_brightness(b, "yellow"),
+ Color::Blue(b) => Color::format_brightness(b, "blue"),
+ Color::Magenta(b) => Color::format_brightness(b, "magenta"),
+ Color::Cyan(b) => Color::format_brightness(b, "cyan"),
+ Color::White(b) => Color::format_brightness(b, "white"),
}
}
-
} /* [impl Color] */
#[derive(Debug)]
-enum Scheme {
+enum Scheme
+{
Default,
SolarizedDark,
SolarizedLight,
- Custom (Option<String>)
+ Custom(Option<String>),
}
-impl<'a> std::fmt::Display for Scheme {
-
- fn
- fmt (&self, f : &mut std::fmt::Formatter) -> std::fmt::Result
+impl<'a> std::fmt::Display for Scheme
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result
{
- let id : &str = match *self
- {
- Scheme::Default => "default",
- Scheme::SolarizedDark => "solarized_dark",
- Scheme::SolarizedLight => "solarized_light",
+ let id: &str = match *self {
+ Scheme::Default => "default",
+ Scheme::SolarizedDark => "solarized_dark",
+ Scheme::SolarizedLight => "solarized_light",
Scheme::Custom(ref kind) => {
- let tmp : &str = match *kind {
+ let tmp: &str = match *kind {
Some(ref fname) => fname.as_str(),
- None => "<read stdin>"
+ None => "<read stdin>",
};
tmp
- }
+ },
};
write!(f, "{}", id)
}
-
} /* [impl std::fmt::String for Scheme] */
-extern { fn exit (code : libc::c_int) -> !; }
+extern "C" {
+ fn exit(code: libc::c_int) -> !;
+}
/* struct Job -- Runtime parameters.
*/
#[derive(Debug)]
-struct Job {
- this : String, /* argv[0] */
- scheme : Scheme, /* The color scheme to switch to. */
+struct Job
+{
+ this: String, /* argv[0] */
+ scheme: Scheme, /* The color scheme to switch to. */
}
-impl<'a> Job {
-
- pub fn
- new ()
- -> Job
+impl<'a> Job
+{
+ pub fn new() -> Job
{
- let argv : Vec<String> = std::env::args().collect();
+ let argv: Vec<String> = std::env::args().collect();
let this = argv[0].clone();
let mut opts = getopts::Options::new();
@@ -149,10 +146,9 @@ impl<'a> Job {
opts.optflag("l", "list", "list available color schemes");
opts.optflag("h", "help", "print this message");
- let matches = match opts.parse(&argv[1..])
- {
+ let matches = match opts.parse(&argv[1..]) {
Ok(m) => m,
- Err(f) => panic!(f.to_string())
+ Err(f) => panic!(f.to_string()),
};
if matches.opt_present("h") {
@@ -169,83 +165,67 @@ impl<'a> Job {
unsafe { exit(0) };
};
- if matches.opt_present("d")
- {
+ if matches.opt_present("d") {
match matches.opt_str("d") {
- None =>
- {
+ None => {
Job::usage(&this, opts);
panic!("no color scheme given, aborting")
},
- Some (name) =>
- {
+ Some(name) => {
let scm = Job::pick_scheme(&name);
Job::dump(scm);
unsafe { exit(0) };
- }
+ },
};
}
- let scheme =
- if matches.opt_present("f")
- {
- match matches.opt_str("f")
- {
- None => {
- Job::usage(&this, opts);
- panic!("no file name specified, aborting")
+ let scheme = if matches.opt_present("f") {
+ match matches.opt_str("f") {
+ None => {
+ Job::usage(&this, opts);
+ panic!("no file name specified, aborting")
+ },
+ Some(fname) =>
+ if fname == "-" {
+ Job::scheme_from_stdin()
+ } else {
+ Scheme::Custom(Some(fname.clone()))
},
- Some (fname) =>
- if fname == "-" { Job::scheme_from_stdin() }
- else { Scheme::Custom(Some(fname.clone())) }
- }
- } else {
- match matches.opt_str("s")
- {
- None => Job::scheme_from_stdin(),
- Some (name) =>
- if name == "-" { Job::scheme_from_stdin() }
- else { Job::pick_scheme(&name) }
- }
- }; /* [let scheme] */
+ }
+ } else {
+ match matches.opt_str("s") {
+ None => Job::scheme_from_stdin(),
+ Some(name) =>
+ if name == "-" {
+ Job::scheme_from_stdin()
+ } else {
+ Job::pick_scheme(&name)
+ },
+ }
+ }; /* [let scheme] */
- Job {
- this : this,
- scheme : scheme
- }
+ Job { this, scheme }
}
- fn
- pick_scheme <'b> (name : &String)
- -> Scheme
+ fn pick_scheme<'b>(name: &String) -> Scheme
{
match name.as_str() {
- "solarized" | "solarized_dark" | "sd"
- => Scheme::SolarizedDark,
- "solarized_light" | "sl"
- => Scheme::SolarizedLight,
- "default" | "normal"
- => Scheme::Default,
- _any => Scheme::Custom (Some(name.clone()))
+ "solarized" | "solarized_dark" | "sd" => Scheme::SolarizedDark,
+ "solarized_light" | "sl" => Scheme::SolarizedLight,
+ "default" | "normal" => Scheme::Default,
+ _any => Scheme::Custom(Some(name.clone())),
}
}
- fn
- scheme_from_stdin ()
- -> Scheme
- {
- Scheme::Custom(None)
- }
+ fn scheme_from_stdin() -> Scheme { Scheme::Custom(None) }
- fn
- usage (this : &String, opts: getopts::Options)
+ fn usage(this: &String, opts: getopts::Options)
{
let brief = format!("usage: {} [options]", this);
print!("{}", opts.usage(&brief));
}
- fn
- schemes ()
+ fn schemes()
{
println!("Available color schemes:");
println!(" · solarized_dark");
@@ -253,35 +233,29 @@ impl<'a> Job {
println!(" · default");
}
- fn
- dump (scm : Scheme)
+ fn dump(scm: Scheme)
{
vrb!("Dumping color scheme {}", scm);
match scm {
- Scheme::Default => Job::dump_scheme(&DEFAULT_COLORS),
- Scheme::SolarizedDark => Job::dump_scheme(&SOLARIZED_COLORS_DARK),
+ Scheme::Default => Job::dump_scheme(&DEFAULT_COLORS),
+ Scheme::SolarizedDark => Job::dump_scheme(&SOLARIZED_COLORS_DARK),
Scheme::SolarizedLight => Job::dump_scheme(&SOLARIZED_COLORS_LIGHT),
- Scheme::Custom(kind) =>
+ Scheme::Custom(kind) =>
match kind {
- Some(fname) => Job::dump_palette(Palette::from_file(&fname)),
- None => Job::dump_palette(Palette::from_stdin())
- }
+ Some(fname) =>
+ Job::dump_palette(Palette::from_file(&fname)),
+ None => Job::dump_palette(Palette::from_stdin()),
+ },
}
}
- fn
- dump_scheme (colors : &[&str; PALETTE_SIZE])
- {
- let pal : Palette = Palette::new(colors);
- pal.dump()
- }
-
- fn
- dump_palette (pal : Palette)
+ fn dump_scheme(colors: &[&str; PALETTE_SIZE])
{
+ let pal: Palette = Palette::new(colors);
pal.dump()
}
+ fn dump_palette(pal: Palette) { pal.dump() }
} /* [impl Job] */
/* Rust appears to come with two wrappers for ``ioctl(2)``, but neither can be utilized for our
@@ -289,15 +263,15 @@ impl<'a> Job {
* ``libc`` module is defined as taking variable arguments and therefore cannot be called from
* Rust. Wrapping C is still a bit awkward, as it seems.
*/
-extern {
- pub fn
- ioctl(d : libc::c_int,
- request : libc::c_int,
- data : *mut libc::c_void)
- -> libc::c_int;
+extern "C" {
+ pub fn ioctl(
+ d: libc::c_int,
+ request: libc::c_int,
+ data: *mut libc::c_void,
+ ) -> libc::c_int;
}
-static CONSOLE_PATHS : [&'static str; 6] = [
+static CONSOLE_PATHS: [&'static str; 6] = [
"/proc/self/fd/0",
"/dev/tty",
"/dev/tty0",
@@ -306,103 +280,90 @@ static CONSOLE_PATHS : [&'static str; 6] = [
"/dev/console",
];
-static DEFAULT_COLORS : RawPalette<'static> = [
- "000000", "aa0000", "00aa00", "aa5500",
- "0000aa", "aa00aa", "00aaaa", "aaaaaa",
- "555555", "ff5555", "55ff55", "ffff55",
- "5555ff", "ff55ff", "55ffff", "ffffff"
+static DEFAULT_COLORS: RawPalette<'static> = [
+ "000000", "aa0000", "00aa00", "aa5500", "0000aa", "aa00aa", "00aaaa",
+ "aaaaaa", "555555", "ff5555", "55ff55", "ffff55", "5555ff", "ff55ff",
+ "55ffff", "ffffff",
];
-static SOLARIZED_COLORS_DARK : RawPalette<'static> = [
- "002b36", "dc322f", "859900", "b58900",
- "268bd2", "d33682", "2aa198", "eee8d5",
- "002b36", "cb4b16", "586e75", "657b83",
- "839496", "6c71c4", "93a1a1", "fdf6e3",
+static SOLARIZED_COLORS_DARK: RawPalette<'static> = [
+ "002b36", "dc322f", "859900", "b58900", "268bd2", "d33682", "2aa198",
+ "eee8d5", "002b36", "cb4b16", "586e75", "657b83", "839496", "6c71c4",
+ "93a1a1", "fdf6e3",
];
-static SOLARIZED_COLORS_LIGHT : RawPalette<'static> = [
- "eee8d5", "dc322f", "859900", "b58900",
- "268bd2", "d33682", "2aa198", "073642",
- "fdf6e3", "cb4b16", "93a1a1", "839496",
- "657b83", "6c71c4", "586e75", "002b36",
+static SOLARIZED_COLORS_LIGHT: RawPalette<'static> = [
+ "eee8d5", "dc322f", "859900", "b58900", "268bd2", "d33682", "2aa198",
+ "073642", "fdf6e3", "cb4b16", "93a1a1", "839496", "657b83", "6c71c4",
+ "586e75", "002b36",
];
-static DUMMY_COLORS : RawPalette<'static> = [
- "000000", "ffffff", "000000", "ffffff",
- "000000", "ffffff", "000000", "ffffff",
- "000000", "ffffff", "000000", "ffffff",
- "000000", "ffffff", "000000", "ffffff",
+static DUMMY_COLORS: RawPalette<'static> = [
+ "000000", "ffffff", "000000", "ffffff", "000000", "ffffff", "000000",
+ "ffffff", "000000", "ffffff", "000000", "ffffff", "000000", "ffffff",
+ "000000", "ffffff",
];
-pub struct Palette {
- colors : [u8; PALETTE_BYTES]
+pub struct Palette
+{
+ colors: [u8; PALETTE_BYTES],
}
impl Palette
{
-
- fn
- dump (&self)
+ fn dump(&self)
{
- let mut i : usize = 0_usize;
- let mut buf : [u8; 3] = [ 0u8, 0u8, 0u8 ];
- for col in self.colors.iter()
- {
- let idx : usize = i % 3;
+ let mut i: usize = 0_usize;
+ let mut buf: [u8; 3] = [0u8, 0u8, 0u8];
+ for col in self.colors.iter() {
+ let idx: usize = i % 3;
buf[idx] = *col;
if idx == 2_usize {
- println!("{:>15} => 0x{:02.X}{:02.X}{:02.X}",
- Color::of_value((i / 3) as u8).to_string(),
- buf[0_usize], buf[1_usize], buf[2_usize]);
+ println!(
+ "{:>15} => 0x{:02.X}{:02.X}{:02.X}",
+ Color::of_value((i / 3) as u8).to_string(),
+ buf[0_usize],
+ buf[1_usize],
+ buf[2_usize]
+ );
}
i = i + 1;
}
}
-
} /* [impl Palette] */
-fn
-nibble_of_char
- (chr : u8)
- -> u8
+fn nibble_of_char(chr: u8) -> u8
{
match chr as char {
- '0' ... '9' => { chr - '0' as u8 },
- 'a' ... 'f' => { chr - 'a' as u8 + 10 },
- 'A' ... 'F' => { chr - 'A' as u8 + 10 },
- _ => 0
+ '0'...'9' => chr - '0' as u8,
+ 'a'...'f' => chr - 'a' as u8 + 10,
+ 'A'...'F' => chr - 'A' as u8 + 10,
+ _ => 0,
}
}
macro_rules! byte_of_hex {
- ($ar:ident, $off:expr) => (
+ ($ar:ident, $off:expr) => {
(nibble_of_char($ar[$off])) << 4
- | nibble_of_char($ar[$off + 1_usize]) as u8
- )
+ | nibble_of_char($ar[$off + 1_usize]) as u8
+ };
}
-
-fn
-rgb_of_hex_triplet
- (def : &str)
- -> (u8, u8, u8)
+fn rgb_of_hex_triplet(def: &str) -> (u8, u8, u8)
{
let bytes = def.as_bytes();
- let r : u8 = byte_of_hex!(bytes, 0);
- let g : u8 = byte_of_hex!(bytes, 2);
- let b : u8 = byte_of_hex!(bytes, 4);
+ let r: u8 = byte_of_hex!(bytes, 0);
+ let g: u8 = byte_of_hex!(bytes, 2);
+ let b: u8 = byte_of_hex!(bytes, 4);
(r, g, b)
}
-
-impl Palette {
-
- pub fn
- new (colors : &[&str; PALETTE_SIZE])
- -> Palette
+impl Palette
+{
+ pub fn new(colors: &[&str; PALETTE_SIZE]) -> Palette
{
- let mut idx : usize = 0_usize;
- let mut pal : [u8; PALETTE_BYTES] = unsafe { std::mem::zeroed() };
+ let mut idx: usize = 0_usize;
+ let mut pal: [u8; PALETTE_BYTES] = unsafe { std::mem::zeroed() };
for def in colors.iter() {
let (r, g, b) = rgb_of_hex_triplet(*def);
@@ -413,46 +374,44 @@ impl Palette {
idx = idx + 3_usize;
}
- Palette {
- colors : pal
- }
- } /* [Palette::new] */
+ Palette { colors: pal }
+ }
- pub fn
- dummy ()
- -> Palette
- {
- Palette::new(&DUMMY_COLORS)
- } /* [Palette::dummy] */
+ /* [Palette::new] */
- pub fn
- from_buffered_reader
- (reader : &mut std::io::BufRead)
- -> Palette
+ pub fn dummy() -> Palette { Palette::new(&DUMMY_COLORS) }
+
+ /* [Palette::dummy] */
+
+ pub fn from_buffered_reader(reader: &mut std::io::BufRead) -> Palette
{
- let mut pal_idx : usize = 0_usize;
- let mut pal : [u8; PALETTE_BYTES] = unsafe { std::mem::zeroed() };
- let mut line : String = String::new();
+ let mut pal_idx: usize = 0_usize;
+ let mut pal: [u8; PALETTE_BYTES] = unsafe { std::mem::zeroed() };
+ let mut line: String = String::new();
while reader.read_line(&mut line).is_ok() {
let len = line.len();
- if len == 0_usize { break; }
- else if len >= 8_usize {
+ if len == 0_usize {
+ break;
+ } else if len >= 8_usize {
if let Some(off) = line.find('#') {
if off != 0_usize {
/* Palette index specified, number prepended */
- let str_idx = unsafe { line.slice_unchecked(0_usize, off) };
- let parse_res : Result<usize, _>
- = std::str::FromStr::from_str(str_idx);
+ let str_idx =
+ unsafe { line.slice_unchecked(0_usize, off) };
+ let parse_res: Result<usize, _> =
+ std::str::FromStr::from_str(str_idx);
match parse_res {
- Ok(new_idx) => {
- if new_idx < PALETTE_SIZE { pal_idx = new_idx * 3_usize; }
- },
- _ => ()
+ Ok(new_idx) =>
+ if new_idx < PALETTE_SIZE {
+ pal_idx = new_idx * 3_usize;
+ },
+ _ => (),
}
}
let off = off + 1_usize;
- if off > len - 6_usize { /* no room left for color definition after '#' char */
+ if off > len - 6_usize {
+ /* no room left for color definition after '#' char */
panic!("invalid color definition: {}", line);
}
let col = &line[off..(off + RAW_COLEXPR_SIZE)];
@@ -465,33 +424,32 @@ impl Palette {
}
}
line.truncate(0);
- };
+ }
- Palette { colors : pal }
- } /* [Palette::from_buffered_reader] */
+ Palette { colors: pal }
+ }
- pub fn
- from_file (fname : &String)
- -> Palette
+ /* [Palette::from_buffered_reader] */
+
+ pub fn from_file(fname: &String) -> Palette
{
/* Check if file exists
*/
let path = std::path::Path::new(fname);
- let file = match std::fs::File::open(&path)
- {
+ let file = match std::fs::File::open(&path) {
Err(e) => panic!("failed to open {} as file ({})", fname, e),
- Ok(f) => f
+ Ok(f) => f,
};
let mut reader = std::io::BufReader::new(file);
/* Parse scheme file
*/
- Palette::from_buffered_reader (&mut reader)
- } /* [Palette::from_file] */
+ Palette::from_buffered_reader(&mut reader)
+ }
- pub fn
- from_stdin ()
- -> Palette
+ /* [Palette::from_file] */
+
+ pub fn from_stdin() -> Palette
{
vrb!("Go ahead, type your color scheme …");
vrb!("vtcol>");
@@ -499,154 +457,144 @@ impl Palette {
/* Parse scheme file
*/
- Palette::from_buffered_reader (&mut reader)
+ Palette::from_buffered_reader(&mut reader)
} /* [Palette::from_stdin] */
-
} /* [impl Palette] */
-impl std::fmt::Display for Palette {
-
- fn
- fmt (&self,
- f : &mut std::fmt::Formatter)
- -> std::fmt::Result
+impl std::fmt::Display for Palette
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result
{
- let mut i : usize = 0_usize;
+ let mut i: usize = 0_usize;
while i < PALETTE_BYTES {
let _ = write!(f, "{}", if i == 0 { "(" } else { "\n " });
let r = self.colors[i + 0_usize];
let g = self.colors[i + 1_usize];
let b = self.colors[i + 2_usize];
- let _ = write!(f, "((r 0x{:02.X}) (g 0x{:02.X}) (b 0x{:02.x}))", r, g, b);
+ let _ = write!(
+ f,
+ "((r 0x{:02.X}) (g 0x{:02.X}) (b 0x{:02.x}))",
+ r, g, b
+ );
i = i + 3_usize;
}
write!(f, ")\n")
}
-
} /* [impl std::fmt::Display for Palette] */
-impl std::fmt::Debug for Palette {
-
- fn
- fmt (&self,
- f : &mut std::fmt::Formatter)
- -> std::fmt::Result
+impl std::fmt::Debug for Palette
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result
{
- let mut i : u8 = 0_u8;
+ let mut i: u8 = 0_u8;
while (i as usize) < PALETTE_BYTES {
let r = self.colors[i as usize + 0_usize];
let g = self.colors[i as usize + 1_usize];
let b = self.colors[i as usize + 2_usize];
- let _ = write!(f, "{} => 0x{:02.X}{:02.X}{:02.X}\n",
- Color::of_value(i).to_string(), r, g, b);
+ let _ = write!(
+ f,
+ "{} => 0x{:02.X}{:02.X}{:02.X}\n",
+ Color::of_value(i).to_string(),
+ r,
+ g,
+ b
+ );
i = i + 3_u8;
}
std::result::Result::Ok(())
}
-
} /* [impl std::fmt::Debug for Palette] */
-
-fn
-fd_of_path
- (path : &std::path::Path)
- -> Option<Fd>
+fn fd_of_path(path: &std::path::Path) -> Option<Fd>
{
let p = std::ffi::CString::new(path.to_str().unwrap()).unwrap();
- match unsafe { libc::open(p.as_ptr(), libc::O_RDWR | O_NOCTTY, 0) }
- {
+ match unsafe { libc::open(p.as_ptr(), libc::O_RDWR | O_NOCTTY, 0) } {
-1 => return None,
- fd =>
- {
+ fd => {
vrb!(" *> got fd");
if unsafe { libc::isatty(fd) } == 0 {
vrb!(" *> not a tty");
- return None
+ return None;
}
- let mut tty_type : libc::c_char = 0;
+ let mut tty_type: libc::c_char = 0;
- let res = unsafe { ioctl(fd,
- KDGKBTYPE as libc::c_int,
- std::mem::transmute(&mut tty_type)) };
+ let res = unsafe {
+ ioctl(
+ fd,
+ KDGKBTYPE as libc::c_int,
+ std::mem::transmute(&mut tty_type),
+ )
+ };
if res < 0 {
vrb!(" *> ioctl failed");
- return None
+ return None;
}
- if tty_type != KB_101 { return None }
+ if tty_type != KB_101 {
+ return None;
+ }
- return Some(fd)
- }
+ return Some(fd);
+ },
}
}
-fn
-get_console_fd
- (path : Option<&str>)
- -> Option<Fd>
+fn get_console_fd(path: Option<&str>) -> Option<Fd>
{
- match path
- {
- Some (path) =>
- {
+ match path {
+ Some(path) => {
let path = std::path::Path::new(path);
- match fd_of_path(&path)
- {
- Some (fd) => Some (fd),
- None => panic!("cannot open {:?} as a tty", path)
+ match fd_of_path(&path) {
+ Some(fd) => Some(fd),
+ None => panic!("cannot open {:?} as a tty", path),
}
},
- None =>
- {
+ None => {
let mut it = CONSOLE_PATHS.iter();
- while let Some (&path) = it.next()
- {
+ while let Some(&path) = it.next() {
vrb!("trying path: {:?}", path);
let path = std::path::Path::new(path);
- if let Some (fd) = fd_of_path(&path) {
+ if let Some(fd) = fd_of_path(&path) {
vrb!(" * Success!");
- return Some (fd)
+ return Some(fd);
}
}
vrb!("could not retrieve fd for any of the search paths");
None
- }
+ },
}
}
-fn
-write_to_term (fd : Fd, buf : &str)
+fn write_to_term(fd: Fd, buf: &str)
{
let len = buf.len() as libc::size_t;
let raw = std::ffi::CString::new(buf.as_bytes()).unwrap();
unsafe { libc::write(fd, raw.as_ptr() as *const libc::c_void, len) };
}
-fn
-clear_term (fd : Fd)
+fn clear_term(fd: Fd)
{
- let clear : &str = "\x1b[2J";
- let cursor : &str = "\x1b[1;1H";
+ let clear: &str = "\x1b[2J";
+ let cursor: &str = "\x1b[1;1H";
write_to_term(fd, clear);
write_to_term(fd, cursor);
}
-fn
-main ()
+fn main()
{
let job = Job::new();
vrb!("job parms: {:?}", job);
- let mut pal : Palette = {
+ let mut pal: Palette = {
match job.scheme {
- Scheme::Default => Palette::new(&DEFAULT_COLORS),
- Scheme::SolarizedDark => Palette::new(&SOLARIZED_COLORS_DARK),
- Scheme::SolarizedLight => Palette::new(&SOLARIZED_COLORS_LIGHT),
+ Scheme::Default => Palette::new(&DEFAULT_COLORS),
+ Scheme::SolarizedDark => Palette::new(&SOLARIZED_COLORS_DARK),
+ Scheme::SolarizedLight => Palette::new(&SOLARIZED_COLORS_LIGHT),
Scheme::Custom(ref kind) =>
match *kind {
Some(ref fname) => Palette::from_file(fname),
- None => Palette::from_stdin()
- }
+ None => Palette::from_stdin(),
+ },
}
};
vrb!("Using palette:");
@@ -660,4 +608,3 @@ main ()
clear_term(fd);
vrb!("terminated from job {:?}", job);
}
-