From 13285e356377c5c8cd6f0f0d2305ff9e40d17d78 Mon Sep 17 00:00:00 2001 From: iximeow Date: Thu, 6 May 2021 23:30:11 -0700 Subject: swap termion dep for crossterm, simplify Colorization interfaces --- CHANGELOG | 4 + Cargo.toml | 6 +- src/color.rs | 309 ++++++++++++++++++++++++++++++--------------------------- src/display.rs | 2 +- src/lib.rs | 4 +- 5 files changed, 175 insertions(+), 150 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 741cf88..d5cdbe9 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,7 @@ +## 0.0.5 + +swap the `termion` dependency for `crossterm`. this is motivated by improved cross-platform support (notably Windows) as well as removing a type parameter from `Colored` and `YaxColors`. + ## 0.0.4 add `AddressDiff`. `LengthedInstruction::len` now return `AddressDiff`. the length of an instruction is the difference between two addresses, not itself an address. diff --git a/Cargo.toml b/Cargo.toml index f72f8ad..cb49e90 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,11 +7,11 @@ keywords = ["disassembly", "disassembler"] license = "0BSD" name = "yaxpeax-arch" repository = "https://git.iximeow.net/yaxpeax-arch/" -version = "0.0.4" +version = "0.0.5" [dependencies] "num-traits" = { version = "0.2", default-features = false } -"termion" = { version = "1.4.0", optional = true } +"crossterm" = { version = "0.19.0", optional = true } "serde" = { version = "1.0", optional = true } "serde_derive" = { version = "1.0", optional = true } @@ -25,6 +25,6 @@ default = ["use-serde", "colors", "address-parse"] # Arch and Arch::Address use-serde = ["serde", "serde_derive"] -colors = ["termion"] +colors = ["crossterm"] address-parse = [] diff --git a/src/color.rs b/src/color.rs index b756df7..c35f482 100644 --- a/src/color.rs +++ b/src/color.rs @@ -1,15 +1,19 @@ use core::fmt::{self, Display, Formatter}; +#[cfg(feature="colors")] +use crossterm::style; -pub enum Colored { - Color(T, Colorer, Colorer), +#[cfg(feature="colors")] +pub enum Colored { + Color(T, style::Color), Just(T) } -impl Display for Colored { +#[cfg(feature="colors")] +impl Display for Colored { fn fmt(&self, fmt: &mut Formatter) -> fmt::Result { match self { - Colored::Color(t, before, after) => { - write!(fmt, "{}{}{}", before, t, after) + Colored::Color(t, before) => { + write!(fmt, "{}", style::style(t).with(*before)) }, Colored::Just(t) => { write!(fmt, "{}", t) @@ -18,92 +22,108 @@ impl Display for Colored { } } -pub trait YaxColors { - fn arithmetic_op(&self, t: T) -> Colored; - fn stack_op(&self, t: T) -> Colored; - fn nop_op(&self, t: T) -> Colored; - fn stop_op(&self, t: T) -> Colored; - fn control_flow_op(&self, t: T) -> Colored; - fn data_op(&self, t: T) -> Colored; - fn comparison_op(&self, t: T) -> Colored; - fn invalid_op(&self, t: T) -> Colored; - fn platform_op(&self, t: T) -> Colored; - fn misc_op(&self, t: T) -> Colored; +#[cfg(not(feature="colors"))] +pub enum Colored { + Just(T) +} + +#[cfg(not(feature="colors"))] +impl Display for Colored { + fn fmt(&self, fmt: &mut Formatter) -> fmt::Result { + match self { + Colored::Just(t) => { + write!(fmt, "{}", t) + } + } + } +} + +pub trait YaxColors { + fn arithmetic_op(&self, t: T) -> Colored; + fn stack_op(&self, t: T) -> Colored; + fn nop_op(&self, t: T) -> Colored; + fn stop_op(&self, t: T) -> Colored; + fn control_flow_op(&self, t: T) -> Colored; + fn data_op(&self, t: T) -> Colored; + fn comparison_op(&self, t: T) -> Colored; + fn invalid_op(&self, t: T) -> Colored; + fn platform_op(&self, t: T) -> Colored; + fn misc_op(&self, t: T) -> Colored; - fn register(&self, t: T) -> Colored; - fn program_counter(&self, t: T) -> Colored; - fn number(&self, t: T) -> Colored; - fn zero(&self, t: T) -> Colored; - fn one(&self, t: T) -> Colored; - fn minus_one(&self, t: T) -> Colored; - fn address(&self, t: T) -> Colored; - fn symbol(&self, t: T) -> Colored; - fn function(&self, t: T) -> Colored; + fn register(&self, t: T) -> Colored; + fn program_counter(&self, t: T) -> Colored; + fn number(&self, t: T) -> Colored; + fn zero(&self, t: T) -> Colored; + fn one(&self, t: T) -> Colored; + fn minus_one(&self, t: T) -> Colored; + fn address(&self, t: T) -> Colored; + fn symbol(&self, t: T) -> Colored; + fn function(&self, t: T) -> Colored; } pub struct NoColors; -impl YaxColors<&'static str> for NoColors { - fn arithmetic_op(&self, t: T) -> Colored { +impl YaxColors for NoColors { + fn arithmetic_op(&self, t: T) -> Colored { Colored::Just(t) } - fn stack_op(&self, t: T) -> Colored { + fn stack_op(&self, t: T) -> Colored { Colored::Just(t) } - fn nop_op(&self, t: T) -> Colored { + fn nop_op(&self, t: T) -> Colored { Colored::Just(t) } - fn stop_op(&self, t: T) -> Colored { + fn stop_op(&self, t: T) -> Colored { Colored::Just(t) } - fn control_flow_op(&self, t: T) -> Colored { + fn control_flow_op(&self, t: T) -> Colored { Colored::Just(t) } - fn data_op(&self, t: T) -> Colored { + fn data_op(&self, t: T) -> Colored { Colored::Just(t) } - fn comparison_op(&self, t: T) -> Colored { + fn comparison_op(&self, t: T) -> Colored { Colored::Just(t) } - fn invalid_op(&self, t: T) -> Colored { + fn invalid_op(&self, t: T) -> Colored { Colored::Just(t) } - fn platform_op(&self, t: T) -> Colored { + fn platform_op(&self, t: T) -> Colored { Colored::Just(t) } - fn misc_op(&self, t: T) -> Colored { + fn misc_op(&self, t: T) -> Colored { Colored::Just(t) } - fn register(&self, t: T) -> Colored { + fn register(&self, t: T) -> Colored { Colored::Just(t) } - fn program_counter(&self, t: T) -> Colored { + fn program_counter(&self, t: T) -> Colored { Colored::Just(t) } - fn number(&self, t: T) -> Colored { + fn number(&self, t: T) -> Colored { Colored::Just(t) } - fn zero(&self, t: T) -> Colored { + fn zero(&self, t: T) -> Colored { Colored::Just(t) } - fn one(&self, t: T) -> Colored { + fn one(&self, t: T) -> Colored { Colored::Just(t) } - fn minus_one(&self, t: T) -> Colored { + fn minus_one(&self, t: T) -> Colored { Colored::Just(t) } - fn address(&self, t: T) -> Colored { + fn address(&self, t: T) -> Colored { Colored::Just(t) } - fn symbol(&self, t: T) -> Colored { + fn symbol(&self, t: T) -> Colored { Colored::Just(t) } - fn function(&self, t: T) -> Colored { + fn function(&self, t: T) -> Colored { Colored::Just(t) } } -pub trait Colorize + ?Sized> { +pub trait Colorize { fn colorize(&self, colors: &Y, out: &mut T) -> fmt::Result; } @@ -114,7 +134,8 @@ pub use termion_color::ColorSettings; mod termion_color { use core::fmt::Display; - use termion::color; + use crossterm::style; + use serde::Serialize; use crate::color::{Colored, YaxColors}; @@ -129,231 +150,231 @@ mod termion_color { } pub struct ColorSettings { - arithmetic: color::Fg<&'static dyn color::Color>, - stack: color::Fg<&'static dyn color::Color>, - nop: color::Fg<&'static dyn color::Color>, - stop: color::Fg<&'static dyn color::Color>, - control: color::Fg<&'static dyn color::Color>, - data: color::Fg<&'static dyn color::Color>, - comparison: color::Fg<&'static dyn color::Color>, - invalid: color::Fg<&'static dyn color::Color>, - platform: color::Fg<&'static dyn color::Color>, - misc: color::Fg<&'static dyn color::Color>, + arithmetic: style::Color, + stack: style::Color, + nop: style::Color, + stop: style::Color, + control: style::Color, + data: style::Color, + comparison: style::Color, + invalid: style::Color, + platform: style::Color, + misc: style::Color, - register: color::Fg<&'static dyn color::Color>, - program_counter: color::Fg<&'static dyn color::Color>, + register: style::Color, + program_counter: style::Color, - number: color::Fg<&'static dyn color::Color>, - zero: color::Fg<&'static dyn color::Color>, - one: color::Fg<&'static dyn color::Color>, - minus_one: color::Fg<&'static dyn color::Color>, + number: style::Color, + zero: style::Color, + one: style::Color, + minus_one: style::Color, - function: color::Fg<&'static dyn color::Color>, - symbol: color::Fg<&'static dyn color::Color>, - address: color::Fg<&'static dyn color::Color>, + function: style::Color, + symbol: style::Color, + address: style::Color, } impl Default for ColorSettings { fn default() -> ColorSettings { ColorSettings { - arithmetic: color::Fg(&color::LightYellow), - stack: color::Fg(&color::Magenta), - nop: color::Fg(&color::Blue), - stop: color::Fg(&color::LightRed), - control: color::Fg(&color::Green), - data: color::Fg(&color::LightMagenta), - comparison: color::Fg(&color::Yellow), - invalid: color::Fg(&color::Red), - platform: color::Fg(&color::Cyan), - misc: color::Fg(&color::LightCyan), + arithmetic: style::Color::Yellow, + stack: style::Color::DarkMagenta, + nop: style::Color::DarkBlue, + stop: style::Color::Red, + control: style::Color::DarkGreen, + data: style::Color::Magenta, + comparison: style::Color::DarkYellow, + invalid: style::Color::DarkRed, + platform: style::Color::DarkCyan, + misc: style::Color::Cyan, - register: color::Fg(&color::Cyan), - program_counter: color::Fg(&color::Red), + register: style::Color::DarkCyan, + program_counter: style::Color::DarkRed, - number: color::Fg(&color::White), - zero: color::Fg(&color::White), - one: color::Fg(&color::White), - minus_one: color::Fg(&color::White), + number: style::Color::White, + zero: style::Color::White, + one: style::Color::White, + minus_one: style::Color::White, - function: color::Fg(&color::LightGreen), - symbol: color::Fg(&color::LightGreen), - address: color::Fg(&color::Green), + function: style::Color::Green, + symbol: style::Color::Green, + address: style::Color::DarkGreen, } } } - impl YaxColors> for ColorSettings { - fn arithmetic_op(&self, t: T) -> Colored> { - Colored::Color(t, self.arithmetic, color::Fg(&color::Reset)) + impl YaxColors for ColorSettings { + fn arithmetic_op(&self, t: T) -> Colored { + Colored::Color(t, self.arithmetic) } - fn stack_op(&self, t: T) -> Colored> { - Colored::Color(t, self.stack, color::Fg(&color::Reset)) + fn stack_op(&self, t: T) -> Colored { + Colored::Color(t, self.stack) } - fn nop_op(&self, t: T) -> Colored> { - Colored::Color(t, self.nop, color::Fg(&color::Reset)) + fn nop_op(&self, t: T) -> Colored { + Colored::Color(t, self.nop) } - fn stop_op(&self, t: T) -> Colored> { - Colored::Color(t, self.stop, color::Fg(&color::Reset)) + fn stop_op(&self, t: T) -> Colored { + Colored::Color(t, self.stop) } - fn control_flow_op(&self, t: T) -> Colored> { - Colored::Color(t, self.control, color::Fg(&color::Reset)) + fn control_flow_op(&self, t: T) -> Colored { + Colored::Color(t, self.control) } - fn data_op(&self, t: T) -> Colored> { - Colored::Color(t, self.data, color::Fg(&color::Reset)) + fn data_op(&self, t: T) -> Colored { + Colored::Color(t, self.data) } - fn comparison_op(&self, t: T) -> Colored> { - Colored::Color(t, self.comparison, color::Fg(&color::Reset)) + fn comparison_op(&self, t: T) -> Colored { + Colored::Color(t, self.comparison) } - fn invalid_op(&self, t: T) -> Colored> { - Colored::Color(t, self.invalid, color::Fg(&color::Reset)) + fn invalid_op(&self, t: T) -> Colored { + Colored::Color(t, self.invalid) } - fn misc_op(&self, t: T) -> Colored> { - Colored::Color(t, self.misc, color::Fg(&color::Reset)) + fn misc_op(&self, t: T) -> Colored { + Colored::Color(t, self.misc) } - fn platform_op(&self, t: T) -> Colored> { - Colored::Color(t, self.platform, color::Fg(&color::Reset)) + fn platform_op(&self, t: T) -> Colored { + Colored::Color(t, self.platform) } - fn register(&self, t: T) -> Colored> { - Colored::Color(t, self.register, color::Fg(&color::Reset)) + fn register(&self, t: T) -> Colored { + Colored::Color(t, self.register) } - fn program_counter(&self, t: T) -> Colored> { - Colored::Color(t, self.program_counter, color::Fg(&color::Reset)) + fn program_counter(&self, t: T) -> Colored { + Colored::Color(t, self.program_counter) } - fn number(&self, t: T) -> Colored> { - Colored::Color(t, self.number, color::Fg(&color::Reset)) + fn number(&self, t: T) -> Colored { + Colored::Color(t, self.number) } - fn zero(&self, t: T) -> Colored> { - Colored::Color(t, self.zero, color::Fg(&color::Reset)) + fn zero(&self, t: T) -> Colored { + Colored::Color(t, self.zero) } - fn one(&self, t: T) -> Colored> { - Colored::Color(t, self.one, color::Fg(&color::Reset)) + fn one(&self, t: T) -> Colored { + Colored::Color(t, self.one) } - fn minus_one(&self, t: T) -> Colored> { - Colored::Color(t, self.minus_one, color::Fg(&color::Reset)) + fn minus_one(&self, t: T) -> Colored { + Colored::Color(t, self.minus_one) } - fn address(&self, t: T) -> Colored> { - Colored::Color(t, self.address, color::Fg(&color::Reset)) + fn address(&self, t: T) -> Colored { + Colored::Color(t, self.address) } - fn symbol(&self, t: T) -> Colored> { - Colored::Color(t, self.symbol, color::Fg(&color::Reset)) + fn symbol(&self, t: T) -> Colored { + Colored::Color(t, self.symbol) } - fn function(&self, t: T) -> Colored> { - Colored::Color(t, self.function, color::Fg(&color::Reset)) + fn function(&self, t: T) -> Colored { + Colored::Color(t, self.function) } } - impl <'a> YaxColors>for Option<&'a ColorSettings> { - fn arithmetic_op(&self, t: T) -> Colored> { + impl <'a> YaxColors for Option<&'a ColorSettings> { + fn arithmetic_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.arithmetic_op(t) } None => { Colored::Just(t) } } } - fn stack_op(&self, t: T) -> Colored> { + fn stack_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.stack_op(t) } None => { Colored::Just(t) } } } - fn nop_op(&self, t: T) -> Colored> { + fn nop_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.nop_op(t) } None => { Colored::Just(t) } } } - fn stop_op(&self, t: T) -> Colored> { + fn stop_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.stop_op(t) } None => { Colored::Just(t) } } } - fn control_flow_op(&self, t: T) -> Colored> { + fn control_flow_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.control_flow_op(t) } None => { Colored::Just(t) } } } - fn data_op(&self, t: T) -> Colored> { + fn data_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.data_op(t) } None => { Colored::Just(t) } } } - fn comparison_op(&self, t: T) -> Colored> { + fn comparison_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.comparison_op(t) } None => { Colored::Just(t) } } } - fn invalid_op(&self, t: T) -> Colored> { + fn invalid_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.invalid_op(t) } None => { Colored::Just(t) } } } - fn misc_op(&self, t: T) -> Colored> { + fn misc_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.misc_op(t) } None => { Colored::Just(t) } } } - fn platform_op(&self, t: T) -> Colored> { + fn platform_op(&self, t: T) -> Colored { match self { Some(colors) => { colors.platform_op(t) } None => { Colored::Just(t) } } } - fn register(&self, t: T) -> Colored> { + fn register(&self, t: T) -> Colored { match self { Some(colors) => { colors.register(t) } None => { Colored::Just(t) } } } - fn program_counter(&self, t: T) -> Colored> { + fn program_counter(&self, t: T) -> Colored { match self { Some(colors) => { colors.program_counter(t) } None => { Colored::Just(t) } } } - fn number(&self, t: T) -> Colored> { + fn number(&self, t: T) -> Colored { match self { Some(colors) => { colors.number(t) } None => { Colored::Just(t) } } } - fn zero(&self, t: T) -> Colored> { + fn zero(&self, t: T) -> Colored { match self { Some(colors) => { colors.zero(t) } None => { Colored::Just(t) } } } - fn one(&self, t: T) -> Colored> { + fn one(&self, t: T) -> Colored { match self { Some(colors) => { colors.one(t) } None => { Colored::Just(t) } } } - fn minus_one(&self, t: T) -> Colored> { + fn minus_one(&self, t: T) -> Colored { match self { Some(colors) => { colors.minus_one(t) } None => { Colored::Just(t) } } } - fn address(&self, t: T) -> Colored> { + fn address(&self, t: T) -> Colored { match self { Some(colors) => { colors.address(t) } None => { Colored::Just(t) } } } - fn symbol(&self, t: T) -> Colored> { + fn symbol(&self, t: T) -> Colored { match self { Some(colors) => { colors.symbol(t) } None => { Colored::Just(t) } } } - fn function(&self, t: T) -> Colored> { + fn function(&self, t: T) -> Colored { match self { Some(colors) => { colors.function(t) } None => { Colored::Just(t) } diff --git a/src/display.rs b/src/display.rs index 50d63d5..789919e 100644 --- a/src/display.rs +++ b/src/display.rs @@ -17,7 +17,7 @@ pub enum NumberStyleHint { HexUnsignedWithSign } -pub fn format_number_i32>(colors: &Y, f: &mut W, i: i32, hint: NumberStyleHint) -> fmt::Result { +pub fn format_number_i32(colors: &Y, f: &mut W, i: i32, hint: NumberStyleHint) -> fmt::Result { match hint { NumberStyleHint::Signed => { write!(f, "{}", colors.number(i)) diff --git a/src/lib.rs b/src/lib.rs index 76de58c..e95513d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,7 +13,7 @@ extern crate serde; #[cfg(feature="use-serde")] #[macro_use] extern crate serde_derive; #[cfg(feature="colors")] -extern crate termion; +extern crate crossterm; #[cfg(feature="use-serde")] use serde::{Serialize, Deserialize}; @@ -77,7 +77,7 @@ pub trait Instruction { fn well_defined(&self) -> bool; } -pub trait ShowContextual> { +pub trait ShowContextual { fn contextualize(&self, colors: &Y, address: Addr, context: Option<&Ctx>, out: &mut T) -> fmt::Result; } -- cgit v1.1