From 984f04f14239a1aa61b4eb118761519b5f88969f Mon Sep 17 00:00:00 2001 From: Josh Leeb-du Toit Date: Wed, 3 Oct 2018 23:53:59 +1000 Subject: [PATCH] Add print_error macros to replace functions This patch replaces the `print_error` and `print_error_and_exit` functions with equivalent macros. --- src/exec/command.rs | 4 ++-- src/exec/job.rs | 3 +-- src/internal.rs | 15 +++++++-------- src/main.rs | 37 ++++++++++++++++++++----------------- src/walk.rs | 25 +++++++++++++++---------- 5 files changed, 45 insertions(+), 39 deletions(-) diff --git a/src/exec/command.rs b/src/exec/command.rs index 960fa49..effc770 100644 --- a/src/exec/command.rs +++ b/src/exec/command.rs @@ -30,10 +30,10 @@ pub fn execute_command(mut cmd: Command, out_perm: Arc>) { let _ = stderr.lock().write_all(&output.stderr); } Err(ref why) if why.kind() == io::ErrorKind::NotFound => { - eprintln!("fd: execution error: command not found"); + print_error!("fd: execution error: command not found"); } Err(why) => { - eprintln!("fd: execution error: {}", why); + print_error!("fd: execution error: {}", why); } } } diff --git a/src/exec/job.rs b/src/exec/job.rs index cb33ab8..069e141 100644 --- a/src/exec/job.rs +++ b/src/exec/job.rs @@ -7,7 +7,6 @@ // according to those terms. use super::CommandTemplate; -use internal::print_error; use std::path::PathBuf; use std::sync::mpsc::Receiver; use std::sync::{Arc, Mutex}; @@ -30,7 +29,7 @@ pub fn job( let value: PathBuf = match lock.recv() { Ok(WorkerResult::Entry(val)) => val, Ok(WorkerResult::Error(err)) => { - print_error(&format!("{}", err)); + print_error!("{}", err); continue; } Err(_) => break, diff --git a/src/internal.rs b/src/internal.rs index 98c2d20..0a2f3bb 100644 --- a/src/internal.rs +++ b/src/internal.rs @@ -8,7 +8,6 @@ use std::ffi::OsString; use std::path::PathBuf; -use std::process; use std::time::{self, SystemTime}; use exec::CommandTemplate; @@ -199,15 +198,15 @@ pub struct FdOptions { pub time_constraints: Vec, } -/// Print error message to stderr. -pub fn print_error(message: &str) { - eprintln!("{}", message); +macro_rules! print_error { + ($($arg:tt)*) => (eprintln!($($arg)*)) } -/// Print error message to stderr and exit with status `1`. -pub fn print_error_and_exit(message: &str) -> ! { - print_error(message); - process::exit(1); +macro_rules! print_error_and_exit { + ($($arg:tt)*) => { + print_error!($($arg)*); + ::std::process::exit(1); + }; } /// Determine if a regex pattern contains a literal uppercase character. diff --git a/src/main.rs b/src/main.rs index 0d013a8..0ef6c5e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -20,11 +20,13 @@ extern crate num_cpus; extern crate regex; extern crate regex_syntax; +#[macro_use] +mod internal; + mod app; mod exec; mod exit_codes; pub mod fshelper; -mod internal; pub mod lscolors; mod output; mod walk; @@ -40,8 +42,8 @@ use regex::{RegexBuilder, RegexSetBuilder}; use exec::CommandTemplate; use internal::{ - pattern_has_uppercase_char, print_error_and_exit, transform_args_with_exec, FdOptions, - FileTypes, SizeFilter, TimeFilter, + pattern_has_uppercase_char, transform_args_with_exec, FdOptions, FileTypes, SizeFilter, + TimeFilter, }; use lscolors::LsColors; @@ -55,7 +57,7 @@ fn main() { // Get the current working directory let current_dir = Path::new("."); if !fshelper::is_dir(current_dir) { - print_error_and_exit("Error: could not get current directory."); + print_error_and_exit!("Error: could not get current directory."); } // Get one or more root directories to search. @@ -64,10 +66,10 @@ fn main() { .map(|path| { let path_buffer = PathBuf::from(path); if !fshelper::is_dir(&path_buffer) { - print_error_and_exit(&format!( + print_error_and_exit!( "Error: '{}' is not a directory.", path_buffer.to_string_lossy() - )); + ); } path_buffer }) @@ -92,7 +94,7 @@ fn main() { && pattern.contains(std::path::MAIN_SEPARATOR) && fshelper::is_dir(Path::new(pattern)) { - print_error_and_exit(&format!( + print_error_and_exit!( "Error: The search pattern '{pattern}' contains a path-separation character ('{sep}') \ and will not lead to any search results.\n\n\ If you want to search for all files inside the '{pattern}' directory, use a match-all pattern:\n\n \ @@ -101,7 +103,7 @@ fn main() { fd --full-path '{pattern}'", pattern = pattern, sep = std::path::MAIN_SEPARATOR, - )); + ); } // Treat pattern as literal string if '--fixed-strings' is used @@ -145,7 +147,7 @@ fn main() { if let Some(f) = SizeFilter::from_string(sf) { return f; } - print_error_and_exit(&format!("Error: {} is not a valid size constraint.", sf)); + print_error_and_exit!("Error: {} is not a valid size constraint.", sf); }) .collect() }) @@ -157,14 +159,14 @@ fn main() { if let Some(f) = TimeFilter::after(&now, t) { time_constraints.push(f); } else { - print_error_and_exit(&format!("Error: {} is not a valid time.", t)); + print_error_and_exit!("Error: {} is not a valid time.", t); } } if let Some(t) = matches.value_of("changed-before") { if let Some(f) = TimeFilter::before(&now, t) { time_constraints.push(f); } else { - print_error_and_exit(&format!("Error: {} is not a valid time.", t)); + print_error_and_exit!("Error: {} is not a valid time.", t); } } @@ -231,7 +233,9 @@ fn main() { .build() { Ok(re) => re, - Err(err) => print_error_and_exit(err.description()), + Err(err) => { + print_error_and_exit!("{}", err.description()); + } } }), command, @@ -253,13 +257,12 @@ fn main() { .build() { Ok(re) => walk::scan(&dir_vec, Arc::new(re), Arc::new(config)), - Err(err) => print_error_and_exit( - format!( + Err(err) => { + print_error_and_exit!( "{}\nHint: You can use the '--fixed-strings' option to search for a \ literal string instead of a regular expression", err.description() - ) - .as_str(), - ), + ); + } } } diff --git a/src/walk.rs b/src/walk.rs index 09f7845..50fec5b 100644 --- a/src/walk.rs +++ b/src/walk.rs @@ -11,7 +11,7 @@ extern crate ctrlc; use exec; use exit_codes::ExitCode; use fshelper; -use internal::{print_error, print_error_and_exit, FdOptions, MAX_BUFFER_LENGTH}; +use internal::{FdOptions, MAX_BUFFER_LENGTH}; use output; use std::error::Error; @@ -61,11 +61,11 @@ pub fn scan(path_vec: &[PathBuf], pattern: Arc, config: Arc) { for pattern in &config.exclude_patterns { let res = override_builder.add(pattern); if res.is_err() { - print_error_and_exit(&format!("Error: malformed exclude pattern '{}'", pattern)); + print_error_and_exit!("Error: malformed exclude pattern '{}'", pattern); } } let overrides = override_builder.build().unwrap_or_else(|_| { - print_error_and_exit("Mismatch in exclude patterns"); + print_error_and_exit!("Mismatch in exclude patterns"); }); let mut walker = WalkBuilder::new(first_path_buf.as_path()); @@ -90,11 +90,14 @@ pub fn scan(path_vec: &[PathBuf], pattern: Arc, config: Arc) { match err { ignore::Error::Partial(_) => (), _ => { - print_error(&format!( - "Error while parsing custom ignore file '{}': {}.", - ignore_file.to_string_lossy(), - err.description() - )); + print_error!( + "{}", + format!( + "Error while parsing custom ignore file '{}': {}.", + ignore_file.to_string_lossy(), + err.description() + ) + ); } } } @@ -190,7 +193,7 @@ pub fn scan(path_vec: &[PathBuf], pattern: Arc, config: Arc) { } } WorkerResult::Error(err) => { - print_error(&format!("{}", err)); + print_error!("{}", err); } } } @@ -310,7 +313,9 @@ pub fn scan(path_vec: &[PathBuf], pattern: Arc, config: Arc) { let search_str_o = if config.search_full_path { match fshelper::path_absolute_form(entry_path) { Ok(path_abs_buf) => Some(path_abs_buf.to_string_lossy().into_owned().into()), - Err(_) => print_error_and_exit("Error: unable to get full path."), + Err(_) => { + print_error_and_exit!("Error: unable to get full path."); + } } } else { entry_path.file_name().map(|f| f.to_string_lossy())