RGBCube/uutils-coreutils
1
Fork 0
mirror of https://github.com/RGBCube/uutils-coreutils synced 2025-07-29 03:57:44 +00:00
Code Issues Activity

Merge pull request #1284 from vks/clippy

Browse source 
Misc code clean up
This commit is contained in:
cnd 2018-09-05 10:43:51 +04:00 • committed by GitHub
commit 1f64d83d6f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
108 changed files with 519 additions and 586 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/arch/arch.rs
View file

@ -15,9 +15,9 @@ extern crate uucore;
use platform_info::*; use platform_info::*;
static SYNTAX: &'static str = ""; static SYNTAX: &str = "";
static SUMMARY: &'static str = "Determine architecture name for current machine."; static SUMMARY: &str = "Determine architecture name for current machine.";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args); new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args);

6
src/base32/base32.rs
View file

@ -16,10 +16,10 @@ use std::fs::File;
use std::io::{stdin, BufReader, Read}; use std::io::{stdin, BufReader, Read};
use std::path::Path; use std::path::Path;
static SYNTAX: &'static str = "[OPTION]... [FILE]"; static SYNTAX: &str = "[OPTION]... [FILE]";
static SUMMARY: &'static str = static SUMMARY: &str =
"Base32 encode or decode FILE, or standard input, to standard output."; "Base32 encode or decode FILE, or standard input, to standard output.";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
With no FILE, or when FILE is -, read standard input. With no FILE, or when FILE is -, read standard input.
The data are encoded as described for the base32 alphabet in RFC The data are encoded as described for the base32 alphabet in RFC

6
src/base64/base64.rs
View file

@ -17,10 +17,10 @@ use std::fs::File;
use std::io::{stdin, BufReader, Read}; use std::io::{stdin, BufReader, Read};
use std::path::Path; use std::path::Path;
static SYNTAX: &'static str = "[OPTION]... [FILE]"; static SYNTAX: &str = "[OPTION]... [FILE]";
static SUMMARY: &'static str = static SUMMARY: &str =
"Base64 encode or decode FILE, or standard input, to standard output."; "Base64 encode or decode FILE, or standard input, to standard output.";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
With no FILE, or when FILE is -, read standard input. With no FILE, or when FILE is -, read standard input.
The data are encoded as described for the base64 alphabet in RFC The data are encoded as described for the base64 alphabet in RFC

10
src/basename/basename.rs
View file

@ -14,11 +14,11 @@ extern crate uucore;
use std::path::{is_separator, PathBuf}; use std::path::{is_separator, PathBuf};
static NAME: &'static str = "basename"; static NAME: &str = "basename";
static SYNTAX: &'static str = "NAME [SUFFIX]"; static SYNTAX: &str = "NAME [SUFFIX]";
static SUMMARY: &'static str = "Print NAME with any leading directory components removed static SUMMARY: &str = "Print NAME with any leading directory components removed
If specified, also remove a trailing SUFFIX"; If specified, also remove a trailing SUFFIX";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
// //
@ -44,7 +44,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
.parse(args); .parse(args);
// too few arguments // too few arguments
if matches.free.len() < 1 { if matches.free.is_empty() {
crash!( crash!(
1, 1,
"{0}: {1}\nTry '{0} --help' for more information.", "{0}: {1}\nTry '{0} --help' for more information.",

53
src/cat/cat.rs
View file

@ -31,10 +31,10 @@ use std::os::unix::fs::FileTypeExt;
#[cfg(unix)] #[cfg(unix)]
use unix_socket::UnixStream; use unix_socket::UnixStream;
static SYNTAX: &'static str = "[OPTION]... [FILE]..."; static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Concatenate FILE(s), or standard input, to standard output static SUMMARY: &str = "Concatenate FILE(s), or standard input, to standard output
With no FILE, or when FILE is -, read standard input."; With no FILE, or when FILE is -, read standard input.";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
#[derive(PartialEq)] #[derive(PartialEq)]
enum NumberingMode { enum NumberingMode {
@ -174,32 +174,23 @@ pub fn uumain(args: Vec<String>) -> i32 {
let success = if can_write_fast { let success = if can_write_fast {
write_fast(files).is_ok() write_fast(files).is_ok()
} else { } else {
let tab = match show_tabs { let tab = if show_tabs { "^I" } else { "\t" }.to_owned();
true => "^I",
false => "\t",
}.to_owned();
let end_of_line = match show_ends { let end_of_line = if show_ends { "$\n" } else { "\n" }.to_owned();
true => "$\n",
false => "\n",
}.to_owned();
let options = OutputOptions { let options = OutputOptions {
end_of_line: end_of_line, end_of_line,
number: number_mode, number: number_mode,
show_nonprint: show_nonprint, show_nonprint,
show_tabs: show_tabs, show_tabs,
squeeze_blank: squeeze_blank, squeeze_blank,
tab: tab, tab,
}; };
write_lines(files, &options).is_ok() write_lines(files, &options).is_ok()
}; };
match success { if success { 0 } else { 1 }
true => 0,
false => 1,
}
} }
/// Classifies the `InputType` of file at `path` if possible /// Classifies the `InputType` of file at `path` if possible
@ -363,7 +354,7 @@ fn write_file_lines(file: &str, options: &OutputOptions, state: &mut OutputState
let mut pos = 0; let mut pos = 0;
while pos < n { while pos < n {
// skip empty line_number enumerating them if needed // skip empty line_number enumerating them if needed
if in_buf[pos] == '\n' as u8 { if in_buf[pos] == b'\n' {
if !state.at_line_start || !options.squeeze_blank || !one_blank_kept { if !state.at_line_start || !options.squeeze_blank || !one_blank_kept {
one_blank_kept = true; one_blank_kept = true;
if state.at_line_start && options.number == NumberingMode::NumberAll { if state.at_line_start && options.number == NumberingMode::NumberAll {
@ -415,7 +406,7 @@ fn write_file_lines(file: &str, options: &OutputOptions, state: &mut OutputState
// Write all symbols till end of line or end of buffer is reached // Write all symbols till end of line or end of buffer is reached
// Return the (number of written symbols + 1) or 0 if the end of buffer is reached // Return the (number of written symbols + 1) or 0 if the end of buffer is reached
fn write_to_end<W: Write>(in_buf: &[u8], writer: &mut W) -> usize { fn write_to_end<W: Write>(in_buf: &[u8], writer: &mut W) -> usize {
match in_buf.iter().position(|c| *c == '\n' as u8) { match in_buf.iter().position(|c| *c == b'\n') {
Some(p) => { Some(p) => {
writer.write_all(&in_buf[..p]).unwrap(); writer.write_all(&in_buf[..p]).unwrap();
p + 1 p + 1
@ -431,14 +422,14 @@ fn write_tab_to_end<W: Write>(mut in_buf: &[u8], writer: &mut W) -> usize {
loop { loop {
match in_buf match in_buf
.iter() .iter()
.position(|c| *c == '\n' as u8 || *c == '\t' as u8) .position(|c| *c == b'\n' || *c == b'\t')
{ {
Some(p) => { Some(p) => {
writer.write_all(&in_buf[..p]).unwrap(); writer.write_all(&in_buf[..p]).unwrap();
if in_buf[p] == '\n' as u8 { if in_buf[p] == b'\n' {
return p + 1; return p + 1;
} else { } else {
writer.write_all("^I".as_bytes()).unwrap(); writer.write_all(b"^I").unwrap();
in_buf = &in_buf[p + 1..]; in_buf = &in_buf[p + 1..];
} }
} }
@ -454,17 +445,17 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
let mut count = 0; let mut count = 0;
for byte in in_buf.iter().map(|c| *c) { for byte in in_buf.iter().map(|c| *c) {
if byte == '\n' as u8 { if byte == b'\n' {
break; break;
} }
match byte { match byte {
9 => writer.write_all(tab), 9 => writer.write_all(tab),
0...8 | 10...31 => writer.write_all(&['^' as u8, byte + 64]), 0...8 | 10...31 => writer.write_all(&[b'^', byte + 64]),
32...126 => writer.write_all(&[byte]), 32...126 => writer.write_all(&[byte]),
127 => writer.write_all(&['^' as u8, byte - 64]), 127 => writer.write_all(&[b'^', byte - 64]),
128...159 => writer.write_all(&['M' as u8, '-' as u8, '^' as u8, byte - 64]), 128...159 => writer.write_all(&[b'M', b'-', b'^', byte - 64]),
160...254 => writer.write_all(&['M' as u8, '-' as u8, byte - 128]), 160...254 => writer.write_all(&[b'M', b'-', byte - 128]),
_ => writer.write_all(&['M' as u8, '-' as u8, '^' as u8, 63]), _ => writer.write_all(&[b'M', b'-', b'^', 63]),
}.unwrap(); }.unwrap();
count += 1; count += 1;
} }

18
src/chgrp/chgrp.rs
View file

@ -29,9 +29,9 @@ use std::path::Path;
use std::ffi::CString; use std::ffi::CString;
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
static SYNTAX: &'static str = static SYNTAX: &str =
"chgrp [OPTION]... GROUP FILE...\n or : chgrp [OPTION]... --reference=RFILE FILE..."; "chgrp [OPTION]... GROUP FILE...\n or : chgrp [OPTION]... --reference=RFILE FILE...";
static SUMMARY: &'static str = "Change the group of each FILE to GROUP."; static SUMMARY: &str = "Change the group of each FILE to GROUP.";
const FTS_COMFOLLOW: u8 = 1; const FTS_COMFOLLOW: u8 = 1;
const FTS_PHYSICAL: u8 = 1 << 1; const FTS_PHYSICAL: u8 = 1 << 1;
@ -117,7 +117,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
Verbosity::Normal Verbosity::Normal
}; };
if matches.free.len() < 1 { if matches.free.is_empty() {
disp_err!("missing operand"); disp_err!("missing operand");
return 1; return 1;
} else if matches.free.len() < 2 && !matches.opt_present("reference") { } else if matches.free.len() < 2 && !matches.opt_present("reference") {
@ -153,13 +153,13 @@ pub fn uumain(args: Vec<String>) -> i32 {
} }
let executor = Chgrper { let executor = Chgrper {
bit_flag: bit_flag, bit_flag,
dest_gid: dest_gid, dest_gid,
verbosity: verbosity, verbosity,
recursive: recursive, recursive,
dereference: derefer != 0, dereference: derefer != 0,
preserve_root: preserve_root, preserve_root,
files: files, files,
}; };
executor.exec() executor.exec()
} }

20
src/chmod/chmod.rs
View file

@ -24,10 +24,10 @@ use walker::Walker;
use uucore::mode; use uucore::mode;
use uucore::fs::display_permissions_unix; use uucore::fs::display_permissions_unix;
const NAME: &'static str = "chmod"; const NAME: &str = "chmod";
static SUMMARY: &'static str = "Change the mode of each FILE to MODE. static SUMMARY: &str = "Change the mode of each FILE to MODE.
With --reference, change the mode of each FILE to that of RFILE."; With --reference, change the mode of each FILE to that of RFILE.";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'. Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
"; ";
@ -81,13 +81,13 @@ pub fn uumain(mut args: Vec<String>) -> i32 {
None None
}; };
let chmoder = Chmoder { let chmoder = Chmoder {
changes: changes, changes,
quiet: quiet, quiet,
verbose: verbose, verbose,
preserve_root: preserve_root, preserve_root,
recursive: recursive, recursive,
fmode: fmode, fmode,
cmode: cmode, cmode,
}; };
match chmoder.chmod(matches.free) { match chmoder.chmod(matches.free) {
Ok(()) => {} Ok(()) => {}

22
src/chown/chown.rs
View file

@ -30,9 +30,9 @@ use std::convert::AsRef;
use std::ffi::CString; use std::ffi::CString;
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
static SYNTAX: &'static str = static SYNTAX: &str =
"[OPTION]... [OWNER][:[GROUP]] FILE...\n chown [OPTION]... --reference=RFILE FILE..."; "[OPTION]... [OWNER][:[GROUP]] FILE...\n chown [OPTION]... --reference=RFILE FILE...";
static SUMMARY: &'static str = "change file owner and group"; static SUMMARY: &str = "change file owner and group";
const FTS_COMFOLLOW: u8 = 1; const FTS_COMFOLLOW: u8 = 1;
const FTS_PHYSICAL: u8 = 1 << 1; const FTS_PHYSICAL: u8 = 1 << 1;
@ -136,7 +136,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
IfFrom::All IfFrom::All
}; };
if matches.free.len() < 1 { if matches.free.is_empty() {
disp_err!("missing operand"); disp_err!("missing operand");
return 1; return 1;
} else if matches.free.len() < 2 && !matches.opt_present("reference") { } else if matches.free.len() < 2 && !matches.opt_present("reference") {
@ -172,15 +172,15 @@ pub fn uumain(args: Vec<String>) -> i32 {
let mut files = matches.free; let mut files = matches.free;
files.remove(0); files.remove(0);
let executor = Chowner { let executor = Chowner {
bit_flag: bit_flag, bit_flag,
dest_uid: dest_uid, dest_uid,
dest_gid: dest_gid, dest_gid,
verbosity: verbosity, verbosity,
recursive: recursive, recursive,
dereference: derefer != 0, dereference: derefer != 0,
filter: filter, filter,
preserve_root: preserve_root, preserve_root,
files: files, files,
}; };
executor.exec() executor.exec()
} }

10
src/chroot/chroot.rs
View file

@ -23,10 +23,10 @@ use std::iter::FromIterator;
use std::path::Path; use std::path::Path;
use std::process::Command; use std::process::Command;
static NAME: &'static str = "chroot"; static NAME: &str = "chroot";
static SYNTAX: &'static str = "[OPTION]... NEWROOT [COMMAND [ARG]...]"; static SYNTAX: &str = "[OPTION]... NEWROOT [COMMAND [ARG]...]";
static SUMMARY: &'static str = "Run COMMAND with root directory set to NEWROOT."; static SUMMARY: &str = "Run COMMAND with root directory set to NEWROOT.";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
If COMMAND is not specified, it defaults to '$(SHELL) -i'. If COMMAND is not specified, it defaults to '$(SHELL) -i'.
If $(SHELL) is not set, /bin/sh is used. If $(SHELL) is not set, /bin/sh is used.
"; ";
@ -140,7 +140,7 @@ fn enter_chroot(root: &Path) {
let root_str = root.display(); let root_str = root.display();
std::env::set_current_dir(root).unwrap(); std::env::set_current_dir(root).unwrap();
let err = unsafe { let err = unsafe {
chroot(CString::new(".".as_bytes()) chroot(CString::new(".")
.unwrap() .unwrap()
.as_bytes_with_nul() .as_bytes_with_nul()
.as_ptr() as *const libc::c_char) .as_ptr() as *const libc::c_char)

2
src/cksum/build.rs
View file

@ -13,7 +13,7 @@ use std::fs::File;
use std::io::Write; use std::io::Write;
use std::path::Path; use std::path::Path;
static CRC_TABLE_LEN: usize = 256; const CRC_TABLE_LEN: usize = 256;
#[path = "../../mkmain.rs"] #[path = "../../mkmain.rs"]
mod mkmain; mod mkmain;

6
src/cksum/cksum.rs
View file

@ -20,9 +20,9 @@ use std::path::Path;
include!(concat!(env!("OUT_DIR"), "/crc_table.rs")); include!(concat!(env!("OUT_DIR"), "/crc_table.rs"));
static SYNTAX: &'static str = "[OPTIONS] [FILE]..."; static SYNTAX: &str = "[OPTIONS] [FILE]...";
static SUMMARY: &'static str = "Print CRC and size for each file"; static SUMMARY: &str = "Print CRC and size for each file";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
#[inline] #[inline]
fn crc_update(crc: u32, input: u8) -> u32 { fn crc_update(crc: u32, input: u8) -> u32 {

6
src/comm/comm.rs
View file

@ -19,9 +19,9 @@ use std::fs::File;
use std::io::{self, stdin, BufRead, BufReader, Stdin}; use std::io::{self, stdin, BufRead, BufReader, Stdin};
use std::path::Path; use std::path::Path;
static SYNTAX: &'static str = "[OPTIONS] FILE1 FILE2"; static SYNTAX: &str = "[OPTIONS] FILE1 FILE2";
static SUMMARY: &'static str = "Compare sorted files line by line"; static SUMMARY: &str = "Compare sorted files line by line";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
fn mkdelim(col: usize, opts: &getopts::Matches) -> String { fn mkdelim(col: usize, opts: &getopts::Matches) -> String {
let mut s = String::new(); let mut s = String::new();

4
src/cp/cp.rs
View file

@ -676,14 +676,14 @@ impl TargetType {
fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<Source>, Target)> { fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<Source>, Target)> {
let mut paths = path_args.iter().map(PathBuf::from).collect::<Vec<_>>(); let mut paths = path_args.iter().map(PathBuf::from).collect::<Vec<_>>();
if paths.len() < 1 { if paths.is_empty() {
// No files specified // No files specified
return Err("missing file operand".into()); return Err("missing file operand".into());
} }
// Return an error if the user requested to copy more than one // Return an error if the user requested to copy more than one
// file source to a file target // file source to a file target
if options.no_target_dir && !options.target_dir.is_some() && paths.len() > 2 { if options.no_target_dir && options.target_dir.is_none() && paths.len() > 2 {
return Err(format!("extra operand {:?}", paths[2]).into()); return Err(format!("extra operand {:?}", paths[2]).into());
} }

9
src/cut/buffer.rs
View file

@ -43,7 +43,7 @@ impl<R: Read> ByteReader<R> {
pub fn new(read: R, newline_char: u8) -> ByteReader<R> { pub fn new(read: R, newline_char: u8) -> ByteReader<R> {
ByteReader { ByteReader {
inner: BufReader::with_capacity(4096, read), inner: BufReader::with_capacity(4096, read),
newline_char: newline_char, newline_char,
} }
} }
} }
@ -75,7 +75,7 @@ impl<R: Read> ByteReader<R> {
// need filled_buf to go out of scope // need filled_buf to go out of scope
let filled_buf = match self.fill_buf() { let filled_buf = match self.fill_buf() {
Ok(b) => { Ok(b) => {
if b.len() == 0 { if b.is_empty() {
return bytes_consumed; return bytes_consumed;
} else { } else {
b b
@ -137,9 +137,8 @@ impl<R: Read> self::Bytes::Select for ByteReader<R> {
}, },
}; };
match out { if let Some(out) = out {
Some(out) => crash_if_err!(1, out.write_all(&buffer[0..consume_val])), crash_if_err!(1, out.write_all(&buffer[0..consume_val]));
None => (),
} }
(res, consume_val) (res, consume_val)
}; };

52
src/cut/cut.rs
View file

@ -23,11 +23,11 @@ mod buffer;
mod ranges; mod ranges;
mod searcher; mod searcher;
static SYNTAX: &'static str = static SYNTAX: &str =
"[-d] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+"; "[-d] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
static SUMMARY: &'static str = static SUMMARY: &str =
"Prints specified byte or field columns from each line of stdin or the input files"; "Prints specified byte or field columns from each line of stdin or the input files";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
Each call must specify a mode (what to use for columns), Each call must specify a mode (what to use for columns),
a sequence (which columns to print), and provide a data source a sequence (which columns to print), and provide a data source
@ -169,14 +169,11 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> i32 {
} }
} }
match opts.out_delim { if let Some(ref delim) = opts.out_delim {
Some(ref delim) => { if print_delim {
if print_delim { crash_if_err!(1, out.write_all(delim.as_bytes()));
crash_if_err!(1, out.write_all(delim.as_bytes()));
}
print_delim = true;
} }
None => (), print_delim = true;
} }
// write out from low to high // write out from low to high
@ -293,18 +290,15 @@ fn cut_fields_delimiter<R: Read>(
fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32 { fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32 {
let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' }; let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
match opts.out_delimeter { if let Some(ref o_delim) = opts.out_delimeter {
Some(ref o_delim) => { return cut_fields_delimiter(
return cut_fields_delimiter( reader,
reader, ranges,
ranges, &opts.delimiter,
&opts.delimiter, opts.only_delimited,
opts.only_delimited, newline_char,
newline_char, o_delim,
o_delim, );
)
}
None => (),
} }
let mut buf_in = BufReader::new(reader); let mut buf_in = BufReader::new(reader);
@ -348,10 +342,8 @@ fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32
}; };
} }
if print_delim { if print_delim && low_idx >= opts.delimiter.as_bytes().len() {
if low_idx >= opts.delimiter.as_bytes().len() { low_idx -= opts.delimiter.as_bytes().len();
low_idx -= opts.delimiter.as_bytes().len();
}
} }
match delim_search.nth(high - low) { match delim_search.nth(high - low) {
@ -509,8 +501,8 @@ pub fn uumain(args: Vec<String>) -> i32 {
FieldOptions { FieldOptions {
delimiter: delim, delimiter: delim,
out_delimeter: out_delim, out_delimeter: out_delim,
only_delimited: only_delimited, only_delimited,
zero_terminated: zero_terminated, zero_terminated,
}, },
)) ))
} }
@ -520,8 +512,8 @@ pub fn uumain(args: Vec<String>) -> i32 {
FieldOptions { FieldOptions {
delimiter: "\t".to_owned(), delimiter: "\t".to_owned(),
out_delimeter: out_delim, out_delimeter: out_delim,
only_delimited: only_delimited, only_delimited,
zero_terminated: zero_terminated, zero_terminated,
}, },
)), )),
} }

12
src/cut/ranges.rs
View file

@ -39,11 +39,11 @@ impl FromStr for Range {
Err(inval) Err(inval)
} }
} }
(Some(n), Some(m)) if m.len() == 0 => { (Some(n), Some(m)) if m.is_empty() => {
if let Ok(low) = n.parse::<usize>() { if let Ok(low) = n.parse::<usize>() {
if low > 0 { if low > 0 {
Ok(Range { Ok(Range {
low: low, low,
high: MAX - 1, high: MAX - 1,
}) })
} else { } else {
@ -56,7 +56,7 @@ impl FromStr for Range {
(Some(n), Some(m)) if n.len() == 0 => { (Some(n), Some(m)) if n.len() == 0 => {
if let Ok(high) = m.parse::<usize>() { if let Ok(high) = m.parse::<usize>() {
if high > 0 { if high > 0 {
Ok(Range { low: 1, high: high }) Ok(Range { low: 1, high })
} else { } else {
Err(field) Err(field)
} }
@ -68,8 +68,8 @@ impl FromStr for Range {
(Ok(low), Ok(high)) => { (Ok(low), Ok(high)) => {
if low > 0 && low <= high { if low > 0 && low <= high {
Ok(Range { Ok(Range {
low: low, low,
high: high, high,
}) })
} else if low == 0 { } else if low == 0 {
Err(field) Err(field)
@ -118,7 +118,7 @@ pub fn complement(ranges: &[Range]) -> Vec<Range> {
let mut complements = Vec::with_capacity(ranges.len() + 1); let mut complements = Vec::with_capacity(ranges.len() + 1);
if ranges.len() > 0 && ranges[0].low > 1 { if !ranges.is_empty() && ranges[0].low > 1 {
complements.push(Range { complements.push(Range {
low: 1, low: 1,
high: ranges[0].low - 1, high: ranges[0].low - 1,

4
src/cut/searcher.rs
View file

@ -17,8 +17,8 @@ pub struct Searcher<'a> {
impl<'a> Searcher<'a> { impl<'a> Searcher<'a> {
pub fn new(haystack: &'a [u8], needle: &'a [u8]) -> Searcher<'a> { pub fn new(haystack: &'a [u8], needle: &'a [u8]) -> Searcher<'a> {
Searcher { Searcher {
haystack: haystack, haystack,
needle: needle, needle,
position: 0, position: 0,
} }
} }

64
src/date/date.rs
View file

@ -21,24 +21,24 @@ use std::io::{BufRead, BufReader};
use std::path::PathBuf; use std::path::PathBuf;
// Options // Options
const DATE: &'static str = "date"; const DATE: &str = "date";
const HOURS: &'static str = "hours"; const HOURS: &str = "hours";
const MINUTES: &'static str = "minutes"; const MINUTES: &str = "minutes";
const SECONDS: &'static str = "seconds"; const SECONDS: &str = "seconds";
const NS: &'static str = "ns"; const NS: &str = "ns";
// Help strings // Help strings
static ISO_8601_HELP_STRING: &'static str = "output date/time in ISO 8601 format. static ISO_8601_HELP_STRING: &str = "output date/time in ISO 8601 format.
FMT='date' for date only (the default), FMT='date' for date only (the default),
'hours', 'minutes', 'seconds', or 'ns' 'hours', 'minutes', 'seconds', or 'ns'
for date and time to the indicated precision. for date and time to the indicated precision.
Example: 2006-08-14T02:34:56-06:00"; Example: 2006-08-14T02:34:56-06:00";
static RFC_2822_HELP_STRING: &'static str = "output date and time in RFC 2822 format. static RFC_2822_HELP_STRING: &str = "output date and time in RFC 2822 format.
Example: Mon, 14 Aug 2006 02:34:56 -0600"; Example: Mon, 14 Aug 2006 02:34:56 -0600";
static RFC_3339_HELP_STRING: &'static str = "output date/time in RFC 3339 format. static RFC_3339_HELP_STRING: &str = "output date/time in RFC 3339 format.
FMT='date', 'seconds', or 'ns' FMT='date', 'seconds', or 'ns'
for date and time to the indicated precision. for date and time to the indicated precision.
Example: 2006-08-14 02:34:56-06:00"; Example: 2006-08-14 02:34:56-06:00";
@ -119,15 +119,12 @@ pub fn uumain(args: Vec<String>) -> i32 {
let file: File; let file: File;
// Get the current time, either in the local time zone or UTC. // Get the current time, either in the local time zone or UTC.
let now: DateTime<FixedOffset> = match settings.utc { let now: DateTime<FixedOffset> = if settings.utc {
true => { let now = Utc::now();
let now = Utc::now(); now.with_timezone(&now.offset().fix())
now.with_timezone(&now.offset().fix()) } else {
} let now = Local::now();
false => { now.with_timezone(now.offset())
let now = Local::now();
now.with_timezone(now.offset())
}
}; };
/// Parse a `String` into a `DateTime`. /// Parse a `String` into a `DateTime`.
@ -198,10 +195,11 @@ fn parse_cli(args: Vec<String>) -> Settings {
possible_value[date seconds ns] possible_value[date seconds ns]
RFC_3339_HELP_STRING) RFC_3339_HELP_STRING)
(@arg custom_format: +takes_value { (@arg custom_format: +takes_value {
|s| match s.starts_with("+") { |s| if s.starts_with('+') {
true => Ok(()), Ok(())
false => Err(String::from("Date formats must start with a '+' character")) } else {
} Err(String::from("Date formats must start with a '+' character"))
}
})) }))
(@arg debug: --debug (@arg debug: --debug
@ -245,8 +243,8 @@ fn parse_cli(args: Vec<String>) -> Settings {
Settings { Settings {
utc: matches.is_present("utc"), utc: matches.is_present("utc"),
format: format, format,
date_source: date_source, date_source,
// TODO: Handle this option: // TODO: Handle this option:
set_to: None, set_to: None,
} }
@ -255,18 +253,18 @@ fn parse_cli(args: Vec<String>) -> Settings {
/// Return the appropriate format string for the given settings. /// Return the appropriate format string for the given settings.
fn make_format_string(settings: &Settings) -> &str { fn make_format_string(settings: &Settings) -> &str {
match settings.format { match settings.format {
Format::Iso8601(ref fmt) => match fmt { Format::Iso8601(ref fmt) => match *fmt {
&Iso8601Format::Date => "%F", Iso8601Format::Date => "%F",
&Iso8601Format::Hours => "%FT%H%:z", Iso8601Format::Hours => "%FT%H%:z",
&Iso8601Format::Minutes => "%FT%H:%M%:z", Iso8601Format::Minutes => "%FT%H:%M%:z",
&Iso8601Format::Seconds => "%FT%T%:z", Iso8601Format::Seconds => "%FT%T%:z",
&Iso8601Format::Ns => "%FT%T,%f%:z", Iso8601Format::Ns => "%FT%T,%f%:z",
}, },
Format::Rfc2822 => "%a, %d %h %Y %T %z", Format::Rfc2822 => "%a, %d %h %Y %T %z",
Format::Rfc3339(ref fmt) => match fmt { Format::Rfc3339(ref fmt) => match *fmt {
&Rfc3339Format::Date => "%F", Rfc3339Format::Date => "%F",
&Rfc3339Format::Seconds => "%F %T%:z", Rfc3339Format::Seconds => "%F %T%:z",
&Rfc3339Format::Ns => "%F %T.%f%:z", Rfc3339Format::Ns => "%F %T.%f%:z",
}, },
Format::Custom(ref fmt) => fmt, Format::Custom(ref fmt) => fmt,
Format::Default => "%c", Format::Default => "%c",

2
src/dircolors/colors.rs
View file

@ -1,4 +1,4 @@
pub const INTERNAL_DB: &'static str = pub const INTERNAL_DB: &str =
r#"# Configuration file for dircolors, a utility to help you set the r#"# Configuration file for dircolors, a utility to help you set the
# LS_COLORS environment variable used by GNU ls with the --color option. # LS_COLORS environment variable used by GNU ls with the --color option.
# Copyright (C) 1996-2016 Free Software Foundation, Inc. # Copyright (C) 1996-2016 Free Software Foundation, Inc.

22
src/dircolors/dircolors.rs
View file

@ -18,9 +18,9 @@ use std::io::{BufRead, BufReader};
use std::borrow::Borrow; use std::borrow::Borrow;
use std::env; use std::env;
static SYNTAX: &'static str = "[OPTION]... [FILE]"; static SYNTAX: &str = "[OPTION]... [FILE]";
static SUMMARY: &'static str = "Output commands to set the LS_COLORS environment variable."; static SUMMARY: &str = "Output commands to set the LS_COLORS environment variable.";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
If FILE is specified, read it to determine which colors to use for which If FILE is specified, read it to determine which colors to use for which
file types and extensions. Otherwise, a precompiled database is used. file types and extensions. Otherwise, a precompiled database is used.
For details on the format of these files, run 'dircolors --print-database' For details on the format of these files, run 'dircolors --print-database'
@ -252,7 +252,7 @@ where
table.insert("multihardlink", "mh"); table.insert("multihardlink", "mh");
table.insert("clrtoeol", "cl"); table.insert("clrtoeol", "cl");
let term = env::var("TERM").unwrap_or("none".to_owned()); let term = env::var("TERM").unwrap_or_else(|_| "none".to_owned());
let term = term.as_str(); let term = term.as_str();
let mut state = ParseState::Global; let mut state = ParseState::Global;
@ -286,18 +286,16 @@ where
state = ParseState::Continue; state = ParseState::Continue;
} }
if state != ParseState::Pass { if state != ParseState::Pass {
if key.starts_with(".") { if key.starts_with('.') {
result.push_str(format!("*{}={}:", key, val).as_str()); result.push_str(format!("*{}={}:", key, val).as_str());
} else if key.starts_with("*") { } else if key.starts_with('*') {
result.push_str(format!("{}={}:", key, val).as_str()); result.push_str(format!("{}={}:", key, val).as_str());
} else if lower == "options" || lower == "color" || lower == "eightbit" { } else if lower == "options" || lower == "color" || lower == "eightbit" {
// Slackware only. Ignore // Slackware only. Ignore
} else if let Some(s) = table.get(lower.as_str()) {
result.push_str(format!("{}={}:", s, val).as_str());
} else { } else {
if let Some(s) = table.get(lower.as_str()) { return Err(format!("{}:{}: unrecognized keyword {}", fp, num, key));
result.push_str(format!("{}={}:", s, val).as_str());
} else {
return Err(format!("{}:{}: unrecognized keyword {}", fp, num, key));
}
} }
} }
} }

8
src/dirname/dirname.rs
View file

@ -14,10 +14,10 @@ extern crate uucore;
use std::path::Path; use std::path::Path;
static NAME: &'static str = "dirname"; static NAME: &str = "dirname";
static SYNTAX: &'static str = "[OPTION] NAME..."; static SYNTAX: &str = "[OPTION] NAME...";
static SUMMARY: &'static str = "strip last component from file name"; static SUMMARY: &str = "strip last component from file name";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
Output each NAME with its last non-slash component and trailing slashes Output each NAME with its last non-slash component and trailing slashes
removed; if NAME contains no /'s, output '.' (meaning the current removed; if NAME contains no /'s, output '.' (meaning the current
directory). directory).

42
src/du/du.rs
View file

@ -25,9 +25,9 @@ use std::os::unix::fs::MetadataExt;
use std::path::PathBuf; use std::path::PathBuf;
use time::Timespec; use time::Timespec;
const NAME: &'static str = "du"; const NAME: &str = "du";
const SUMMARY: &'static str = "estimate file space usage"; const SUMMARY: &str = "estimate file space usage";
const LONG_HELP: &'static str = " const LONG_HELP: &str = "
Display values are in units of the first available SIZE from Display values are in units of the first available SIZE from
--block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐ --block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐
ment variables. Otherwise, units default to 1024 bytes (or 512 if ment variables. Otherwise, units default to 1024 bytes (or 512 if
@ -65,7 +65,7 @@ impl Stat {
fn new(path: PathBuf) -> Result<Stat> { fn new(path: PathBuf) -> Result<Stat> {
let metadata = fs::symlink_metadata(&path)?; let metadata = fs::symlink_metadata(&path)?;
Ok(Stat { Ok(Stat {
path: path, path,
is_dir: metadata.is_dir(), is_dir: metadata.is_dir(),
size: metadata.len(), size: metadata.len(),
blocks: metadata.blocks() as u64, blocks: metadata.blocks() as u64,
@ -110,9 +110,9 @@ fn unit_string_to_number(s: &str) -> Option<u64> {
} }
fn translate_to_pure_number(s: &Option<String>) -> Option<u64> { fn translate_to_pure_number(s: &Option<String>) -> Option<u64> {
match s { match *s {
&Some(ref s) => unit_string_to_number(s), Some(ref s) => unit_string_to_number(s),
&None => None, None => None,
} }
} }
@ -165,7 +165,7 @@ fn du(
} }
}; };
for f in read.into_iter() { for f in read {
match f { match f {
Ok(entry) => { Ok(entry) => {
match Stat::new(entry.path()) { match Stat::new(entry.path()) {
@ -319,7 +319,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
let options = Options { let options = Options {
all: matches.opt_present("all"), all: matches.opt_present("all"),
program_name: NAME.to_owned(), program_name: NAME.to_owned(),
max_depth: max_depth, max_depth,
total: matches.opt_present("total"), total: matches.opt_present("total"),
separate_dirs: matches.opt_present("S"), separate_dirs: matches.opt_present("S"),
}; };
@ -377,13 +377,13 @@ Try '{} --help' for more information.",
let line_separator = if matches.opt_present("0") { "\0" } else { "\n" }; let line_separator = if matches.opt_present("0") { "\0" } else { "\n" };
let mut grand_total = 0; let mut grand_total = 0;
for path_str in strs.into_iter() { for path_str in strs {
let path = PathBuf::from(&path_str); let path = PathBuf::from(&path_str);
match Stat::new(path) { match Stat::new(path) {
Ok(stat) => { Ok(stat) => {
let mut inodes: HashSet<u64> = HashSet::new(); let mut inodes: HashSet<u64> = HashSet::new();
let iter = du(stat, &options, 0, &mut inodes).into_iter(); let iter = du(stat, &options, 0, &mut inodes);
let (_, len) = iter.size_hint(); let (_, len) = iter.size_hint();
let len = len.unwrap(); let len = len.unwrap();
for (index, stat) in iter.enumerate() { for (index, stat) in iter.enumerate() {
@ -417,11 +417,11 @@ Try '{} --help' for more information.",
} }
None => stat.modified, None => stat.modified,
}; };
((time / 1000) as i64, (time % 1000 * 1000000) as i32) ((time / 1000) as i64, (time % 1000 * 1_000_000) as i32)
}; };
time::at(Timespec::new(secs, nsecs)) time::at(Timespec::new(secs, nsecs))
}; };
if !summarize || (summarize && index == len - 1) { if !summarize || index == len - 1 {
let time_str = tm.strftime(time_format_str).unwrap(); let time_str = tm.strftime(time_format_str).unwrap();
print!( print!(
"{}\t{}\t{}{}", "{}\t{}\t{}{}",
@ -431,15 +431,13 @@ Try '{} --help' for more information.",
line_separator line_separator
); );
} }
} else { } else if !summarize || index == len - 1 {
if !summarize || (summarize && index == len - 1) { print!(
print!( "{}\t{}{}",
"{}\t{}{}", convert_size(size),
convert_size(size), stat.path.display(),
stat.path.display(), line_separator
line_separator );
);
}
} }
if options.total && index == (len - 1) { if options.total && index == (len - 1) {
// The last element will be the total size of the the path under // The last element will be the total size of the the path under

12
src/env/env.rs vendored
View file

@ -17,10 +17,10 @@ use std::env;
use std::io::{stdout, Write}; use std::io::{stdout, Write};
use std::process::Command; use std::process::Command;
static NAME: &'static str = "env"; static NAME: &str = "env";
static SYNTAX: &'static str = "[OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]"; static SYNTAX: &str = "[OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
static SUMMARY: &'static str = "Set each NAME to VALUE in the environment and run COMMAND"; static SUMMARY: &str = "Set each NAME to VALUE in the environment and run COMMAND";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
A mere - implies -i. If no COMMAND, print the resulting environment A mere - implies -i. If no COMMAND, print the resulting environment
"; ";
@ -147,7 +147,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
} }
} else { } else {
// is it a NAME=VALUE like opt ? // is it a NAME=VALUE like opt ?
let mut sp = opt.splitn(2, "="); let mut sp = opt.splitn(2, '=');
let name = sp.next(); let name = sp.next();
let value = sp.next(); let value = sp.next();
@ -187,7 +187,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
env::set_var(name, val); env::set_var(name, val);
} }
if opts.program.len() >= 1 { if !opts.program.is_empty() {
let prog = opts.program[0].clone(); let prog = opts.program[0].clone();
let args = &opts.program[1..]; let args = &opts.program[1..];
match Command::new(prog).args(args).status() { match Command::new(prog).args(args).status() {

18
src/expand/expand.rs
View file

@ -23,10 +23,10 @@ use std::iter::repeat;
use std::str::from_utf8; use std::str::from_utf8;
use unicode_width::UnicodeWidthChar; use unicode_width::UnicodeWidthChar;
static SYNTAX: &'static str = "[OPTION]... [FILE]..."; static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Convert tabs in each FILE to spaces, writing to standard output. static SUMMARY: &str = "Convert tabs in each FILE to spaces, writing to standard output.
With no FILE, or when FILE is -, read standard input."; With no FILE, or when FILE is -, read standard input.";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
static DEFAULT_TABSTOP: usize = 8; static DEFAULT_TABSTOP: usize = 8;
@ -92,11 +92,11 @@ impl Options {
}; };
Options { Options {
files: files, files,
tabstops: tabstops, tabstops,
tspaces: tspaces, tspaces,
iflag: iflag, iflag,
uflag: uflag, uflag,
} }
} }
} }
@ -179,7 +179,7 @@ fn expand(options: Options) {
while byte < buf.len() { while byte < buf.len() {
let (ctype, cwidth, nbytes) = if options.uflag { let (ctype, cwidth, nbytes) = if options.uflag {
let nbytes = uucore::utf8::utf8_char_width(buf[byte]); let nbytes = char::from(buf[byte]).len_utf8();
if byte + nbytes > buf.len() { if byte + nbytes > buf.len() {
// don't overrun buffer because of invalid UTF-8 // don't overrun buffer because of invalid UTF-8

12
src/expr/expr.rs
View file

@ -16,8 +16,8 @@ extern crate uucore;
mod tokens; mod tokens;
mod syntax_tree; mod syntax_tree;
static NAME: &'static str = "expr"; static NAME: &str = "expr";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
// For expr utility we do not want getopts. // For expr utility we do not want getopts.
@ -35,13 +35,13 @@ pub fn uumain(args: Vec<String>) -> i32 {
} }
} }
fn process_expr(token_strings: &Vec<String>) -> Result<String, String> { fn process_expr(token_strings: &[String]) -> Result<String, String> {
let maybe_tokens = tokens::strings_to_tokens(&token_strings); let maybe_tokens = tokens::strings_to_tokens(&token_strings);
let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens); let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens);
evaluate_ast(maybe_ast) evaluate_ast(maybe_ast)
} }
fn print_expr_ok(expr_result: &String) -> i32 { fn print_expr_ok(expr_result: &str) -> i32 {
println!("{}", expr_result); println!("{}", expr_result);
if expr_result == "0" || expr_result == "" { if expr_result == "0" || expr_result == "" {
1 1
@ -50,7 +50,7 @@ fn print_expr_ok(expr_result: &String) -> i32 {
} }
} }
fn print_expr_error(expr_error: &String) -> ! { fn print_expr_error(expr_error: &str) -> ! {
crash!(2, "{}", expr_error) crash!(2, "{}", expr_error)
} }
@ -62,7 +62,7 @@ fn evaluate_ast(maybe_ast: Result<Box<syntax_tree::ASTNode>, String>) -> Result<
} }
} }
fn maybe_handle_help_or_version(args: &Vec<String>) -> bool { fn maybe_handle_help_or_version(args: &[String]) -> bool {
if args.len() == 2 { if args.len() == 2 {
if args[1] == "--help" { if args[1] == "--help" {
print_help(); print_help();

45
src/expr/syntax_tree.rs
View file

@ -66,17 +66,17 @@ impl ASTNode {
} }
} }
fn new_node(token_idx: usize, op_type: &String, operands: OperandsList) -> Box<ASTNode> { fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<ASTNode> {
Box::new(ASTNode::Node { Box::new(ASTNode::Node {
token_idx: token_idx, token_idx: token_idx,
op_type: op_type.clone(), op_type: op_type.into(),
operands: operands, operands: operands,
}) })
} }
fn new_leaf(token_idx: usize, value: &String) -> Box<ASTNode> { fn new_leaf(token_idx: usize, value: &str) -> Box<ASTNode> {
Box::new(ASTNode::Leaf { Box::new(ASTNode::Leaf {
token_idx: token_idx, token_idx,
value: value.clone(), value: value.into(),
}) })
} }
pub fn evaluate(&self) -> Result<String, String> { pub fn evaluate(&self) -> Result<String, String> {
@ -252,7 +252,7 @@ fn ast_from_rpn(rpn: &mut TokenStack) -> Result<Box<ASTNode>, String> {
} }
fn maybe_ast_node( fn maybe_ast_node(
token_idx: usize, token_idx: usize,
op_type: &String, op_type: &str,
arity: usize, arity: usize,
rpn: &mut TokenStack, rpn: &mut TokenStack,
) -> Result<Box<ASTNode>, String> { ) -> Result<Box<ASTNode>, String> {
@ -351,7 +351,10 @@ fn push_op_to_stack(
match op_stack.last() { match op_stack.last() {
None => return Ok(op_stack.push((token_idx, token.clone()))), None => return Ok(op_stack.push((token_idx, token.clone()))),
Some(&(_, Token::ParOpen)) => return Ok(op_stack.push((token_idx, token.clone()))), Some(&(_, Token::ParOpen)) => {
op_stack.push((token_idx, token.clone()));
return Ok(());
}
Some(&( Some(&(
_, _,
@ -362,11 +365,13 @@ fn push_op_to_stack(
)) => if la && prev_prec >= prec || !la && prev_prec > prec { )) => if la && prev_prec >= prec || !la && prev_prec > prec {
out_stack.push(op_stack.pop().unwrap()) out_stack.push(op_stack.pop().unwrap())
} else { } else {
return Ok(op_stack.push((token_idx, token.clone()))); op_stack.push((token_idx, token.clone()));
return Ok(());
}, },
Some(&(_, Token::PrefixOp { .. })) => { Some(&(_, Token::PrefixOp { .. })) => {
return Ok(op_stack.push((token_idx, token.clone()))) op_stack.push((token_idx, token.clone()));
return Ok(());
} }
Some(_) => panic!("Non-operator on op_stack"), Some(_) => panic!("Non-operator on op_stack"),
@ -397,13 +402,13 @@ fn checked_binop<F: Fn() -> Option<T>, T>(cb: F, op: &str) -> Result<T, String>
} }
} }
fn infix_operator_two_ints<F>(f: F, values: &Vec<String>) -> Result<String, String> fn infix_operator_two_ints<F>(f: F, values: &[String]) -> Result<String, String>
where where
F: Fn(i64, i64) -> Result<i64, String>, F: Fn(i64, i64) -> Result<i64, String>,
{ {
assert!(values.len() == 2); assert!(values.len() == 2);
if let Some(left) = values[0].parse::<i64>().ok() { if let Ok(left) = values[0].parse::<i64>() {
if let Some(right) = values[1].parse::<i64>().ok() { if let Ok(right) = values[1].parse::<i64>() {
return match f(left, right) { return match f(left, right) {
Ok(result) => Ok(result.to_string()), Ok(result) => Ok(result.to_string()),
Err(reason) => Err(reason), Err(reason) => Err(reason),
@ -416,7 +421,7 @@ where
fn infix_operator_two_ints_or_two_strings<FI, FS>( fn infix_operator_two_ints_or_two_strings<FI, FS>(
fi: FI, fi: FI,
fs: FS, fs: FS,
values: &Vec<String>, values: &[String],
) -> Result<String, String> ) -> Result<String, String>
where where
FI: Fn(i64, i64) -> Result<i64, String>, FI: Fn(i64, i64) -> Result<i64, String>,
@ -435,7 +440,7 @@ where
} }
} }
fn infix_operator_or(values: &Vec<String>) -> Result<String, String> { fn infix_operator_or(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2); assert!(values.len() == 2);
if value_as_bool(&values[0]) { if value_as_bool(&values[0]) {
Ok(values[0].clone()) Ok(values[0].clone())
@ -444,7 +449,7 @@ fn infix_operator_or(values: &Vec<String>) -> Result<String, String> {
} }
} }
fn infix_operator_and(values: &Vec<String>) -> Result<String, String> { fn infix_operator_and(values: &[String]) -> Result<String, String> {
if value_as_bool(&values[0]) && value_as_bool(&values[1]) { if value_as_bool(&values[0]) && value_as_bool(&values[1]) {
Ok(values[0].clone()) Ok(values[0].clone())
} else { } else {
@ -452,7 +457,7 @@ fn infix_operator_and(values: &Vec<String>) -> Result<String, String> {
} }
} }
fn operator_match(values: &Vec<String>) -> Result<String, String> { fn operator_match(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2); assert!(values.len() == 2);
let re = match Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep()) let re = match Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep())
{ {
@ -472,12 +477,12 @@ fn operator_match(values: &Vec<String>) -> Result<String, String> {
} }
} }
fn prefix_operator_length(values: &Vec<String>) -> Result<String, String> { fn prefix_operator_length(values: &[String]) -> Result<String, String> {
assert!(values.len() == 1); assert!(values.len() == 1);
Ok(values[0].len().to_string()) Ok(values[0].len().to_string())
} }
fn prefix_operator_index(values: &Vec<String>) -> Result<String, String> { fn prefix_operator_index(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2); assert!(values.len() == 2);
let haystack = &values[0]; let haystack = &values[0];
let needles = &values[1]; let needles = &values[1];
@ -495,7 +500,7 @@ fn prefix_operator_index(values: &Vec<String>) -> Result<String, String> {
Ok("0".to_string()) Ok("0".to_string())
} }
fn prefix_operator_substr(values: &Vec<String>) -> Result<String, String> { fn prefix_operator_substr(values: &[String]) -> Result<String, String> {
assert!(values.len() == 3); assert!(values.len() == 3);
let subj = &values[0]; let subj = &values[0];
let mut idx = match values[1].parse::<i64>() { let mut idx = match values[1].parse::<i64>() {
@ -541,7 +546,7 @@ fn bool_as_string(b: bool) -> String {
} }
} }
fn value_as_bool(s: &str) -> bool { fn value_as_bool(s: &str) -> bool {
if s.len() == 0 { if s.is_empty() {
return false; return false;
} }
match s.parse::<i64>() { match s.parse::<i64>() {

14
src/expr/tokens.rs
View file

@ -39,15 +39,15 @@ pub enum Token {
}, },
} }
impl Token { impl Token {
fn new_infix_op(v: &String, left_assoc: bool, precedence: u8) -> Self { fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
Token::InfixOp { Token::InfixOp {
left_assoc: left_assoc, left_assoc,
precedence: precedence, precedence,
value: v.clone(), value: v.into(),
} }
} }
fn new_value(v: &String) -> Self { fn new_value(v: &str) -> Self {
Token::Value { value: v.clone() } Token::Value { value: v.into() }
} }
fn is_infix_plus(&self) -> bool { fn is_infix_plus(&self) -> bool {
@ -148,7 +148,7 @@ fn push_token_if_not_escaped(
acc: &mut Vec<(usize, Token)>, acc: &mut Vec<(usize, Token)>,
tok_idx: usize, tok_idx: usize,
token: Token, token: Token,
s: &String, s: &str,
) { ) {
// Smells heuristics... :( // Smells heuristics... :(
let prev_is_plus = match acc.last() { let prev_is_plus = match acc.last() {

8
src/factor/factor.rs
View file

@ -29,10 +29,10 @@ mod numeric;
include!(concat!(env!("OUT_DIR"), "/prime_table.rs")); include!(concat!(env!("OUT_DIR"), "/prime_table.rs"));
static SYNTAX: &'static str = "[OPTION] [NUMBER]..."; static SYNTAX: &str = "[OPTION] [NUMBER]...";
static SUMMARY: &'static str = "Print the prime factors of the given number(s). static SUMMARY: &str = "Print the prime factors of the given number(s).
If none are specified, read from standard input."; If none are specified, read from standard input.";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
fn rho_pollard_pseudorandom_function(x: u64, a: u64, b: u64, num: u64) -> u64 { fn rho_pollard_pseudorandom_function(x: u64, a: u64, b: u64, num: u64) -> u64 {
if num < 1 << 63 { if num < 1 << 63 {
@ -148,7 +148,7 @@ fn print_factors(num: u64) {
for fac in &factors { for fac in &factors {
print!(" {}", fac); print!(" {}", fac);
} }
println!(""); println!();
} }
fn print_factors_str(num_str: &str) { fn print_factors_str(num_str: &str) {

89
src/fmt/fmt.rs
View file

@ -34,9 +34,9 @@ mod linebreak;
mod parasplit; mod parasplit;
// program's NAME and VERSION are used for -V and -h // program's NAME and VERSION are used for -V and -h
static SYNTAX: &'static str = "[OPTION]... [FILE]..."; static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Reformat paragraphs from input files (or stdin) to stdout."; static SUMMARY: &str = "Reformat paragraphs from input files (or stdin) to stdout.";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub type FileOrStdReader = BufReader<Box<Read + 'static>>; pub type FileOrStdReader = BufReader<Box<Read + 'static>>;
pub struct FmtOptions { pub struct FmtOptions {
@ -120,62 +120,47 @@ pub fn uumain(args: Vec<String>) -> i32 {
fmt_opts.xanti_prefix = true; fmt_opts.xanti_prefix = true;
} }
match matches.opt_str("p") { if let Some(s) = matches.opt_str("p") {
Some(s) => { fmt_opts.prefix = s;
fmt_opts.prefix = s; fmt_opts.use_prefix = true;
fmt_opts.use_prefix = true;
}
None => (),
}; };
match matches.opt_str("P") { if let Some(s) = matches.opt_str("P") {
Some(s) => { fmt_opts.anti_prefix = s;
fmt_opts.anti_prefix = s; fmt_opts.use_anti_prefix = true;
fmt_opts.use_anti_prefix = true;
}
None => (),
}; };
match matches.opt_str("w") { if let Some(s) = matches.opt_str("w") {
Some(s) => { fmt_opts.width = match s.parse::<usize>() {
fmt_opts.width = match s.parse::<usize>() { Ok(t) => t,
Ok(t) => t, Err(e) => {
Err(e) => { crash!(1, "Invalid WIDTH specification: `{}': {}", s, e);
crash!(1, "Invalid WIDTH specification: `{}': {}", s, e);
}
};
fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
}
None => (),
};
match matches.opt_str("g") {
Some(s) => {
fmt_opts.goal = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid GOAL specification: `{}': {}", s, e);
}
};
if !matches.opt_present("w") {
fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
} else if fmt_opts.goal > fmt_opts.width {
crash!(1, "GOAL cannot be greater than WIDTH.");
} }
} };
None => (), fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
}; };
match matches.opt_str("T") { if let Some(s) = matches.opt_str("g") {
Some(s) => { fmt_opts.goal = match s.parse::<usize>() {
fmt_opts.tabwidth = match s.parse::<usize>() { Ok(t) => t,
Ok(t) => t, Err(e) => {
Err(e) => { crash!(1, "Invalid GOAL specification: `{}': {}", s, e);
crash!(1, "Invalid TABWIDTH specification: `{}': {}", s, e); }
} };
}; if !matches.opt_present("w") {
fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
} else if fmt_opts.goal > fmt_opts.width {
crash!(1, "GOAL cannot be greater than WIDTH.");
} }
None => (), };
if let Some(s) = matches.opt_str("T") {
fmt_opts.tabwidth = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid TABWIDTH specification: `{}': {}", s, e);
}
};
}; };
if fmt_opts.tabwidth < 1 { if fmt_opts.tabwidth < 1 {
@ -208,7 +193,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
match para_result { match para_result {
Err(s) => { Err(s) => {
silent_unwrap!(ostream.write_all(s.as_bytes())); silent_unwrap!(ostream.write_all(s.as_bytes()));
silent_unwrap!(ostream.write_all("\n".as_bytes())); silent_unwrap!(ostream.write_all(b"\n"));
} }
Ok(para) => break_lines(&para, &fmt_opts, &mut ostream), Ok(para) => break_lines(&para, &fmt_opts, &mut ostream),
} }

22
src/fmt/linebreak.rs
View file

@ -53,7 +53,7 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
let (w, w_len) = match p_words_words.next() { let (w, w_len) = match p_words_words.next() {
Some(winfo) => (winfo.word, winfo.word_nchars), Some(winfo) => (winfo.word, winfo.word_nchars),
None => { None => {
silent_unwrap!(ostream.write_all("\n".as_bytes())); silent_unwrap!(ostream.write_all(b"\n"));
return; return;
} }
}; };
@ -77,12 +77,12 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
let uniform = para.mail_header || opts.uniform; let uniform = para.mail_header || opts.uniform;
let mut break_args = BreakArgs { let mut break_args = BreakArgs {
opts: opts, opts,
init_len: p_init_len, init_len: p_init_len,
indent_str: &p_indent[..], indent_str: &p_indent[..],
indent_len: p_indent_len, indent_len: p_indent_len,
uniform: uniform, uniform,
ostream: ostream, ostream,
}; };
if opts.quick || para.mail_header { if opts.quick || para.mail_header {
@ -98,7 +98,7 @@ fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(iter: T, args: &mut Br
iter.fold((args.init_len, false), |l, winfo| { iter.fold((args.init_len, false), |l, winfo| {
accum_words_simple(args, l, winfo) accum_words_simple(args, l, winfo)
}); });
silent_unwrap!(args.ostream.write_all("\n".as_bytes())); silent_unwrap!(args.ostream.write_all(b"\n"));
} }
fn accum_words_simple<'a>( fn accum_words_simple<'a>(
@ -199,7 +199,7 @@ fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
fresh = false; fresh = false;
write_with_spaces(word, slen, args.ostream); write_with_spaces(word, slen, args.ostream);
} }
silent_unwrap!(args.ostream.write_all("\n".as_bytes())); silent_unwrap!(args.ostream.write_all(b"\n"));
} }
struct LineBreak<'a> { struct LineBreak<'a> {
@ -381,7 +381,7 @@ fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a Wo
} }
// "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed // "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed
const BAD_INFTY: i64 = 10000000; const BAD_INFTY: i64 = 10_000_000;
const BAD_INFTY_SQ: i64 = BAD_INFTY * BAD_INFTY; const BAD_INFTY_SQ: i64 = BAD_INFTY * BAD_INFTY;
// badness = BAD_MULT * abs(r) ^ 3 // badness = BAD_MULT * abs(r) ^ 3
const BAD_MULT: f32 = 100.0; const BAD_MULT: f32 = 100.0;
@ -451,7 +451,7 @@ fn restart_active_breaks<'a>(
LineBreak { LineBreak {
prev: act_idx, prev: act_idx,
linebreak: Some(w), linebreak: Some(w),
break_before: break_before, break_before,
demerits: 0, // this is the only active break, so we can reset the demerit count demerits: 0, // this is the only active break, so we can reset the demerit count
prev_rat: if break_before { 1.0 } else { -1.0 }, prev_rat: if break_before { 1.0 } else { -1.0 },
length: line_length, length: line_length,
@ -492,16 +492,16 @@ fn slice_if_fresh(
// Write a newline and add the indent. // Write a newline and add the indent.
fn write_newline(indent: &str, ostream: &mut BufWriter<Stdout>) { fn write_newline(indent: &str, ostream: &mut BufWriter<Stdout>) {
silent_unwrap!(ostream.write_all("\n".as_bytes())); silent_unwrap!(ostream.write_all(b"\n"));
silent_unwrap!(ostream.write_all(indent.as_bytes())); silent_unwrap!(ostream.write_all(indent.as_bytes()));
} }
// Write the word, along with slen spaces. // Write the word, along with slen spaces.
fn write_with_spaces(word: &str, slen: usize, ostream: &mut BufWriter<Stdout>) { fn write_with_spaces(word: &str, slen: usize, ostream: &mut BufWriter<Stdout>) {
if slen == 2 { if slen == 2 {
silent_unwrap!(ostream.write_all(" ".as_bytes())); silent_unwrap!(ostream.write_all(b" "));
} else if slen == 1 { } else if slen == 1 {
silent_unwrap!(ostream.write_all(" ".as_bytes())); silent_unwrap!(ostream.write_all(b" "));
} }
silent_unwrap!(ostream.write_all(word.as_bytes())); silent_unwrap!(ostream.write_all(word.as_bytes()));
} }

42
src/fmt/parasplit.rs
View file

@ -73,8 +73,8 @@ pub struct FileLines<'a> {
impl<'a> FileLines<'a> { impl<'a> FileLines<'a> {
fn new<'b>(opts: &'b FmtOptions, lines: Lines<&'b mut FileOrStdReader>) -> FileLines<'b> { fn new<'b>(opts: &'b FmtOptions, lines: Lines<&'b mut FileOrStdReader>) -> FileLines<'b> {
FileLines { FileLines {
opts: opts, opts,
lines: lines, lines,
} }
} }
@ -197,10 +197,10 @@ impl<'a> Iterator for FileLines<'a> {
Some(Line::FormatLine(FileLine { Some(Line::FormatLine(FileLine {
line: n, line: n,
indent_end: indent_end, indent_end,
pfxind_end: poffset, pfxind_end: poffset,
indent_len: indent_len, indent_len,
prefix_len: prefix_len, prefix_len,
})) }))
} }
} }
@ -234,9 +234,9 @@ impl<'a> ParagraphStream<'a> {
let lines = FileLines::new(opts, reader.lines()).peekable(); let lines = FileLines::new(opts, reader.lines()).peekable();
// at the beginning of the file, we might find mail headers // at the beginning of the file, we might find mail headers
ParagraphStream { ParagraphStream {
lines: lines, lines,
next_mail: true, next_mail: true,
opts: opts, opts,
} }
} }
@ -405,12 +405,12 @@ impl<'a> Iterator for ParagraphStream<'a> {
Some(Ok(Paragraph { Some(Ok(Paragraph {
lines: p_lines, lines: p_lines,
init_str: init_str, init_str,
init_len: init_len, init_len,
init_end: init_end, init_end,
indent_str: indent_str, indent_str,
indent_len: indent_len, indent_len,
indent_end: indent_end, indent_end,
mail_header: in_mail, mail_header: in_mail,
})) }))
} }
@ -425,8 +425,8 @@ pub struct ParaWords<'a> {
impl<'a> ParaWords<'a> { impl<'a> ParaWords<'a> {
pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> { pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> {
let mut pw = ParaWords { let mut pw = ParaWords {
opts: opts, opts,
para: para, para,
words: Vec::new(), words: Vec::new(),
}; };
pw.create_words(); pw.create_words();
@ -522,7 +522,7 @@ impl<'a> WordSplit<'a> {
// wordsplits *must* start at a non-whitespace character // wordsplits *must* start at a non-whitespace character
let trim_string = string.trim_left(); let trim_string = string.trim_left();
WordSplit { WordSplit {
opts: opts, opts,
string: trim_string, string: trim_string,
length: string.len(), length: string.len(),
position: 0, position: 0,
@ -610,14 +610,14 @@ impl<'a> Iterator for WordSplit<'a> {
}; };
Some(WordInfo { Some(WordInfo {
word: word, word,
word_start: word_start_relative, word_start: word_start_relative,
word_nchars: word_nchars, word_nchars,
before_tab: before_tab, before_tab,
after_tab: after_tab, after_tab,
sentence_start: is_start_of_sentence, sentence_start: is_start_of_sentence,
ends_punct: self.prev_punct, ends_punct: self.prev_punct,
new_line: new_line, new_line,
}) })
} }
} }

12
src/fold/fold.rs
View file

@ -16,10 +16,10 @@ use std::fs::File;
use std::io::{stdin, BufRead, BufReader, Read}; use std::io::{stdin, BufRead, BufReader, Read};
use std::path::Path; use std::path::Path;
static SYNTAX: &'static str = "[OPTION]... [FILE]..."; static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Writes each file (or standard input if no files are given) static SUMMARY: &str = "Writes each file (or standard input if no files are given)
to standard output whilst breaking long lines"; to standard output whilst breaking long lines";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let (args, obs_width) = handle_obsolete(&args[..]); let (args, obs_width) = handle_obsolete(&args[..]);
@ -70,7 +70,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) { fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) {
for (i, arg) in args.iter().enumerate() { for (i, arg) in args.iter().enumerate() {
let slice = &arg; let slice = &arg;
if slice.chars().next().unwrap() == '-' && slice.len() > 1 if slice.starts_with('-') && slice.len() > 1
&& slice.chars().nth(1).unwrap().is_digit(10) && slice.chars().nth(1).unwrap().is_digit(10)
{ {
let mut v = args.to_vec(); let mut v = args.to_vec();
@ -123,10 +123,10 @@ fn fold_file<T: Read>(mut file: BufReader<T>, bytes: bool, spaces: bool, width:
} }
} else { } else {
let mut len = line.chars().count(); let mut len = line.chars().count();
let newline = line.ends_with("\n"); let newline = line.ends_with('\n');
if newline { if newline {
if len == 1 { if len == 1 {
println!(""); println!();
continue; continue;
} }
len -= 1; len -= 1;

26
src/groups/groups.rs
View file

@ -14,8 +14,8 @@
extern crate uucore; extern crate uucore;
use uucore::entries::{get_groups, Locate, Passwd, gid2grp}; use uucore::entries::{get_groups, Locate, Passwd, gid2grp};
static SYNTAX: &'static str = "[user]"; static SYNTAX: &str = "[user]";
static SUMMARY: &'static str = "display current group names"; static SUMMARY: &str = "display current group names";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let matches = new_coreopts!(SYNTAX, SUMMARY, "").parse(args); let matches = new_coreopts!(SYNTAX, SUMMARY, "").parse(args);
@ -30,19 +30,17 @@ pub fn uumain(args: Vec<String>) -> i32 {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(" ") .join(" ")
); );
} else if let Ok(p) = Passwd::locate(matches.free[0].as_str()) {
println!(
"{}",
p.belongs_to()
.iter()
.map(|&g| gid2grp(g).unwrap())
.collect::<Vec<_>>()
.join(" ")
);
} else { } else {
if let Ok(p) = Passwd::locate(matches.free[0].as_str()) { crash!(1, "unknown user {}", matches.free[0]);
println!(
"{}",
p.belongs_to()
.iter()
.map(|&g| gid2grp(g).unwrap())
.collect::<Vec<_>>()
.join(" ")
);
} else {
crash!(1, "unknown user {}", matches.free[0]);
}
} }
0 0

24
src/hashsum/hashsum.rs
View file

@ -38,8 +38,8 @@ use std::fs::File;
use std::io::{self, stdin, BufRead, BufReader, Read}; use std::io::{self, stdin, BufRead, BufReader, Read};
use std::path::Path; use std::path::Path;
static NAME: &'static str = "hashsum"; static NAME: &str = "hashsum";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
fn is_custom_binary(program: &str) -> bool { fn is_custom_binary(program: &str) -> bool {
match program { match program {
@ -493,8 +493,8 @@ fn digest_reader<'a, T: Read>(
// Digest file, do not hold too much in memory at any given moment // Digest file, do not hold too much in memory at any given moment
let windows = cfg!(windows); let windows = cfg!(windows);
let mut buffer = Vec::with_capacity(524288); let mut buffer = Vec::with_capacity(524_288);
let mut vec = Vec::with_capacity(524288); let mut vec = Vec::with_capacity(524_288);
let mut looking_for_newline = false; let mut looking_for_newline = false;
loop { loop {
match reader.read_to_end(&mut buffer) { match reader.read_to_end(&mut buffer) {
@ -504,17 +504,17 @@ fn digest_reader<'a, T: Read>(
Ok(nread) => { Ok(nread) => {
if windows && !binary { if windows && !binary {
// Windows text mode returns '\n' when reading '\r\n' // Windows text mode returns '\n' when reading '\r\n'
for i in 0..nread { for &b in buffer.iter().take(nread) {
if looking_for_newline { if looking_for_newline {
if buffer[i] != ('\n' as u8) { if b != b'\n' {
vec.push('\r' as u8); vec.push(b'\r');
} }
if buffer[i] != ('\r' as u8) { if b != b'\r' {
vec.push(buffer[i]); vec.push(b);
looking_for_newline = false; looking_for_newline = false;
} }
} else if buffer[i] != ('\r' as u8) { } else if b != b'\r' {
vec.push(buffer[i]); vec.push(b);
} else { } else {
looking_for_newline = true; looking_for_newline = true;
} }
@ -529,7 +529,7 @@ fn digest_reader<'a, T: Read>(
} }
} }
if windows && looking_for_newline { if windows && looking_for_newline {
vec.push('\r' as u8); vec.push(b'\r');
digest.input(&vec); digest.input(&vec);
} }

19
src/head/head.rs
View file

@ -19,9 +19,9 @@ use std::fs::File;
use std::path::Path; use std::path::Path;
use std::str::from_utf8; use std::str::from_utf8;
static SYNTAX: &'static str = ""; static SYNTAX: &str = "";
static SUMMARY: &'static str = ""; static SUMMARY: &str = "";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
enum FilterMode { enum FilterMode {
Bytes(usize), Bytes(usize),
@ -90,16 +90,15 @@ pub fn uumain(args: Vec<String>) -> i32 {
} }
} }
} }
None => match matches.opt_str("c") { None => if let Some(count) = matches.opt_str("c") {
Some(count) => match count.parse::<usize>() { match count.parse::<usize>() {
Ok(m) => settings.mode = FilterMode::Bytes(m), Ok(m) => settings.mode = FilterMode::Bytes(m),
Err(e) => { Err(e) => {
show_error!("invalid byte count '{}': {}", count, e); show_error!("invalid byte count '{}': {}", count, e);
return 1; return 1;
} }
}, }
None => {} }
},
}; };
let quiet = matches.opt_present("q"); let quiet = matches.opt_present("q");
@ -129,7 +128,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
for file in &files { for file in &files {
if settings.verbose { if settings.verbose {
if !firstime { if !firstime {
println!(""); println!();
} }
println!("==> {} <==", file); println!("==> {} <==", file);
} }
@ -160,7 +159,7 @@ fn obsolete(options: &[String]) -> (Vec<String>, Option<usize>) {
let current = options[a].clone(); let current = options[a].clone();
let current = current.as_bytes(); let current = current.as_bytes();
if current.len() > 1 && current[0] == '-' as u8 { if current.len() > 1 && current[0] == b'-' {
let len = current.len(); let len = current.len();
for pos in 1..len { for pos in 1..len {
// Ensure that the argument is only made out of digits // Ensure that the argument is only made out of digits

8
src/hostid/hostid.rs
View file

@ -16,9 +16,9 @@ extern crate uucore;
use libc::c_long; use libc::c_long;
static SYNTAX: &'static str = "[options]"; static SYNTAX: &str = "[options]";
static SUMMARY: &'static str = ""; static SUMMARY: &str = "";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub enum Mode { pub enum Mode {
HostId, HostId,
@ -49,6 +49,6 @@ fn hostid() {
result = gethostid(); result = gethostid();
} }
result &= 0xffffffff; result &= 0xffff_ffff;
println!("{:0>8x}", result); println!("{:0>8x}", result);
} }

6
src/hostname/hostname.rs
View file

@ -38,9 +38,9 @@ use libc::gethostname;
#[cfg(not(windows))] #[cfg(not(windows))]
use libc::sethostname; use libc::sethostname;
const SYNTAX: &'static str = "[OPTION]... [HOSTNAME]"; const SYNTAX: &str = "[OPTION]... [HOSTNAME]";
const SUMMARY: &'static str = "Print or set the system's host name."; const SUMMARY: &str = "Print or set the system's host name.";
const LONG_HELP: &'static str = ""; const LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
#[cfg(windows)] #[cfg(windows)]

6
src/install/install.rs
View file

@ -21,10 +21,10 @@ use std::fs;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::result::Result; use std::result::Result;
static NAME: &'static str = "install"; static NAME: &str = "install";
static SUMMARY: &'static str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing static SUMMARY: &str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
DIRECTORY, while setting permission modes and owner/group"; DIRECTORY, while setting permission modes and owner/group";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
const DEFAULT_MODE: u32 = 755; const DEFAULT_MODE: u32 = 755;

4
src/join/join.rs
View file

@ -19,8 +19,8 @@ use std::io::{stdin, BufRead, BufReader, Lines, Stdin};
use std::cmp::{min, Ordering}; use std::cmp::{min, Ordering};
use clap::{App, Arg}; use clap::{App, Arg};
static NAME: &'static str = "join"; static NAME: &str = "join";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Copy, Clone, PartialEq)] #[derive(Copy, Clone, PartialEq)]
enum FileNum { enum FileNum {

6
src/kill/kill.rs
View file

@ -18,9 +18,9 @@ use libc::{c_int, pid_t};
use std::io::Error; use std::io::Error;
use uucore::signals::ALL_SIGNALS; use uucore::signals::ALL_SIGNALS;
static SYNTAX: &'static str = "[options] <pid> [...]"; static SYNTAX: &str = "[options] <pid> [...]";
static SUMMARY: &'static str = ""; static SUMMARY: &str = "";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
static EXIT_OK: i32 = 0; static EXIT_OK: i32 = 0;
static EXIT_ERR: i32 = 1; static EXIT_ERR: i32 = 1;

6
src/link/link.rs
View file

@ -16,9 +16,9 @@ use std::fs::hard_link;
use std::path::Path; use std::path::Path;
use std::io::Error; use std::io::Error;
static SYNTAX: &'static str = "[OPTIONS] FILE1 FILE2"; static SYNTAX: &str = "[OPTIONS] FILE1 FILE2";
static SUMMARY: &'static str = "Create a link named FILE2 to FILE1"; static SUMMARY: &str = "Create a link named FILE2 to FILE1";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub fn normalize_error_message(e: Error) -> String { pub fn normalize_error_message(e: Error) -> String {
match e.raw_os_error() { match e.raw_os_error() {

6
src/ln/ln.rs
View file

@ -20,9 +20,9 @@ use std::os::unix::fs::symlink;
use std::os::windows::fs::{symlink_dir, symlink_file}; use std::os::windows::fs::{symlink_dir, symlink_file};
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
static NAME: &'static str = "ln"; static NAME: &str = "ln";
static SUMMARY: &'static str = ""; static SUMMARY: &str = "";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
In the 1st form, create a link to TARGET with the name LINK_NAME. In the 1st form, create a link to TARGET with the name LINK_NAME.
In the 2nd form, create a link to TARGET in the current directory. In the 2nd form, create a link to TARGET in the current directory.
In the 3rd and 4th forms, create links to each TARGET in DIRECTORY. In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.

6
src/logname/logname.rs
View file

@ -34,9 +34,9 @@ fn get_userlogin() -> Option<String> {
} }
} }
static SYNTAX: &'static str = ""; static SYNTAX: &str = "";
static SUMMARY: &'static str = "Print user's login name"; static SUMMARY: &str = "Print user's login name";
static LONG_HELP: &'static str = ""; static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args); new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args);

8
src/ls/ls.rs
View file

@ -44,16 +44,16 @@ use unicode_width::UnicodeWidthStr;
#[cfg(windows)] #[cfg(windows)]
use std::os::windows::fs::MetadataExt; use std::os::windows::fs::MetadataExt;
static NAME: &'static str = "ls"; static NAME: &str = "ls";
static SUMMARY: &'static str = ""; static SUMMARY: &str = "";
static LONG_HELP: &'static str = " static LONG_HELP: &str = "
By default, ls will list the files and contents of any directories on By default, ls will list the files and contents of any directories on
the command line, expect that it will ignore files and directories the command line, expect that it will ignore files and directories
whose names start with '.' whose names start with '.'
"; ";
#[cfg(unix)] #[cfg(unix)]
static DEFAULT_COLORS: &'static str = "rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:"; static DEFAULT_COLORS: &str = "rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:";
#[cfg(unix)] #[cfg(unix)]
lazy_static! { lazy_static! {

4
src/mkdir/mkdir.rs
View file

@ -18,8 +18,8 @@ extern crate uucore;
use std::fs; use std::fs;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
static NAME: &'static str = "mkdir"; static NAME: &str = "mkdir";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
/** /**
* Handles option parsing * Handles option parsing

4
src/mkfifo/mkfifo.rs
View file

@ -19,8 +19,8 @@ use libc::mkfifo;
use std::ffi::CString; use std::ffi::CString;
use std::io::Error; use std::io::Error;
static NAME: &'static str = "mkfifo"; static NAME: &str = "mkfifo";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/mknod/mknod.rs
View file

@ -23,8 +23,8 @@ use getopts::Options;
use std::ffi::CString; use std::ffi::CString;
static NAME: &'static str = "mknod"; static NAME: &str = "mknod";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

6
src/mktemp/mktemp.rs
View file

@ -26,9 +26,9 @@ use tempfile::NamedTempFileOptions;
mod tempdir; mod tempdir;
static NAME: &'static str = "mktemp"; static NAME: &str = "mktemp";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
static DEFAULT_TEMPLATE: &'static str = "tmp.XXXXXXXXXX"; static DEFAULT_TEMPLATE: &str = "tmp.XXXXXXXXXX";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/more/more.rs
View file

@ -35,8 +35,8 @@ pub enum Mode {
Version, Version,
} }
static NAME: &'static str = "more"; static NAME: &str = "more";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new(); let mut opts = Options::new();

4
src/mv/mv.rs
View file

@ -19,8 +19,8 @@ use std::env;
use std::io::{stdin, BufRead, BufReader, Result}; use std::io::{stdin, BufRead, BufReader, Result};
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
static NAME: &'static str = "mv"; static NAME: &str = "mv";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub struct Behaviour { pub struct Behaviour {
overwrite: OverwriteMode, overwrite: OverwriteMode,

4
src/nice/nice.rs
View file

@ -19,8 +19,8 @@ use libc::{c_char, c_int, execvp};
use std::ffi::CString; use std::ffi::CString;
use std::io::Error; use std::io::Error;
const NAME: &'static str = "nice"; const NAME: &str = "nice";
const VERSION: &'static str = env!("CARGO_PKG_VERSION"); const VERSION: &str = env!("CARGO_PKG_VERSION");
// XXX: PRIO_PROCESS is 0 on at least FreeBSD and Linux. Don't know about Mac OS X. // XXX: PRIO_PROCESS is 0 on at least FreeBSD and Linux. Don't know about Mac OS X.
const PRIO_PROCESS: c_int = 0; const PRIO_PROCESS: c_int = 0;

6
src/nl/nl.rs
View file

@ -26,9 +26,9 @@ use std::path::Path;
mod helper; mod helper;
static NAME: &'static str = "nl"; static NAME: &str = "nl";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
static USAGE: &'static str = "nl [OPTION]... [FILE]..."; static USAGE: &str = "nl [OPTION]... [FILE]...";
// A regular expression matching everything. // A regular expression matching everything.
// Settings store options used by nl to produce its output. // Settings store options used by nl to produce its output.

4
src/nohup/nohup.rs
View file

@ -25,8 +25,8 @@ use std::path::{Path, PathBuf};
use std::env; use std::env;
use uucore::fs::{is_stderr_interactive, is_stdin_interactive, is_stdout_interactive}; use uucore::fs::{is_stderr_interactive, is_stdin_interactive, is_stdout_interactive};
static NAME: &'static str = "nohup"; static NAME: &str = "nohup";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
extern "C" { extern "C" {

4
src/nproc/nproc.rs
View file

@ -29,8 +29,8 @@ pub const _SC_NPROCESSORS_CONF: libc::c_int = 57;
#[cfg(target_os = "netbsd")] #[cfg(target_os = "netbsd")]
pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001; pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001;
static NAME: &'static str = "nproc"; static NAME: &str = "nproc";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/numfmt/numfmt.rs
View file

@ -15,8 +15,8 @@ use getopts::{Matches, Options};
use std::fmt; use std::fmt;
use std::io::BufRead; use std::io::BufRead;
static NAME: &'static str = "numfmt"; static NAME: &str = "numfmt";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
const IEC_BASES: [f64; 10] = [ const IEC_BASES: [f64; 10] = [
//premature optimization //premature optimization

4
src/od/od.rs
View file

@ -47,10 +47,10 @@ use inputoffset::{InputOffset, Radix};
use inputdecoder::{InputDecoder, MemoryDecoder}; use inputdecoder::{InputDecoder, MemoryDecoder};
use output_info::OutputInfo; use output_info::OutputInfo;
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes
static USAGE: &'static str = r#"Usage: static USAGE: &str = r#"Usage:
od [OPTION]... [--] [FILENAME]... od [OPTION]... [--] [FILENAME]...
od [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]] od [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
od --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]] od --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]

2
src/od/prn_char.rs
View file

@ -13,7 +13,7 @@ pub static FORMAT_ITEM_C: FormatterItemInfo = FormatterItemInfo {
formatter: FormatWriter::MultibyteWriter(format_item_c), formatter: FormatWriter::MultibyteWriter(format_item_c),
}; };
static A_CHRS: [&'static str; 128] = [ static A_CHRS: [&str; 128] = [
"nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "nl", "vt", "ff", "cr", "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "nl", "vt", "ff", "cr",
"so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc", "so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc",
"fs", "gs", "rs", "us", "sp", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", "fs", "gs", "rs", "us", "sp", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-",

4
src/paste/paste.rs
View file

@ -19,8 +19,8 @@ use std::iter::repeat;
use std::fs::File; use std::fs::File;
use std::path::Path; use std::path::Path;
static NAME: &'static str = "paste"; static NAME: &str = "paste";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

8
src/pathchk/pathchk.rs
View file

@ -30,12 +30,12 @@ enum Mode {
Version, // show version information Version, // show version information
} }
static NAME: &'static str = "pathchk"; static NAME: &str = "pathchk";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
// a few global constants as used in the GNU implementation // a few global constants as used in the GNU implementation
static POSIX_PATH_MAX: usize = 256; const POSIX_PATH_MAX: usize = 256;
static POSIX_NAME_MAX: usize = 14; const POSIX_NAME_MAX: usize = 14;
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
// add options // add options

4
src/pinky/pinky.rs
View file

@ -24,8 +24,8 @@ use std::os::unix::fs::MetadataExt;
use std::path::PathBuf; use std::path::PathBuf;
static SYNTAX: &'static str = "[OPTION]... [USER]..."; static SYNTAX: &str = "[OPTION]... [USER]...";
static SUMMARY: &'static str = "A lightweight 'finger' program; print user information."; static SUMMARY: &str = "A lightweight 'finger' program; print user information.";
const BUFSIZE: usize = 1024; const BUFSIZE: usize = 1024;

4
src/printenv/printenv.rs
View file

@ -18,8 +18,8 @@ extern crate uucore;
use std::env; use std::env;
static NAME: &'static str = "printenv"; static NAME: &str = "printenv";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/printf/cli.rs
View file

@ -4,8 +4,8 @@
use std::io::{stderr, stdout, Write}; use std::io::{stderr, stdout, Write};
use std::env; use std::env;
pub static EXIT_OK: i32 = 0; pub const EXIT_OK: i32 = 0;
pub static EXIT_ERR: i32 = 1; pub const EXIT_ERR: i32 = 1;
pub fn err_msg(msg: &str) { pub fn err_msg(msg: &str) {
let exe_path = match env::current_exe() { let exe_path = match env::current_exe() {

10
src/printf/printf.rs
View file

@ -8,10 +8,10 @@ mod cli;
mod memo; mod memo;
mod tokenize; mod tokenize;
static NAME: &'static str = "printf"; static NAME: &str = "printf";
static VERSION: &'static str = "0.0.1"; static VERSION: &str = "0.0.1";
static SHORT_USAGE: &'static str = "printf: usage: printf [-v var] format [arguments]"; static SHORT_USAGE: &str = "printf: usage: printf [-v var] format [arguments]";
static LONGHELP_LEAD: &'static str = "printf static LONGHELP_LEAD: &str = "printf
USAGE: printf FORMATSTRING [ARGUMENT]... USAGE: printf FORMATSTRING [ARGUMENT]...
@ -26,7 +26,7 @@ Options:
--version output version information and exit --version output version information and exit
"; ";
static LONGHELP_BODY: &'static str = " static LONGHELP_BODY: &str = "
Prints the , replacing escaped character sequences with character literals Prints the , replacing escaped character sequences with character literals
and substitution field sequences with passed arguments and substitution field sequences with passed arguments

4
src/ptx/ptx.rs
View file

@ -26,8 +26,8 @@ use std::default::Default;
use std::fs::File; use std::fs::File;
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write}; use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
static NAME: &'static str = "ptx"; static NAME: &str = "ptx";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Debug)] #[derive(Debug)]
enum OutFormat { enum OutFormat {

4
src/pwd/pwd.rs
View file

@ -18,8 +18,8 @@ use std::env;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::io; use std::io;
static NAME: &'static str = "pwd"; static NAME: &str = "pwd";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn absolute_path(path: &Path) -> io::Result<PathBuf> { pub fn absolute_path(path: &Path) -> io::Result<PathBuf> {
let path_buf = path.canonicalize()?; let path_buf = path.canonicalize()?;

4
src/readlink/readlink.rs
View file

@ -19,8 +19,8 @@ use std::io::{stdout, Write};
use std::path::PathBuf; use std::path::PathBuf;
use uucore::fs::{canonicalize, CanonicalizeMode}; use uucore::fs::{canonicalize, CanonicalizeMode};
const NAME: &'static str = "readlink"; const NAME: &str = "readlink";
const VERSION: &'static str = env!("CARGO_PKG_VERSION"); const VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/realpath/realpath.rs
View file

@ -18,8 +18,8 @@ use std::fs;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use uucore::fs::{canonicalize, CanonicalizeMode}; use uucore::fs::{canonicalize, CanonicalizeMode};
static NAME: &'static str = "realpath"; static NAME: &str = "realpath";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/relpath/relpath.rs
View file

@ -18,8 +18,8 @@ use std::env;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use uucore::fs::{canonicalize, CanonicalizeMode}; use uucore::fs::{canonicalize, CanonicalizeMode};
static NAME: &'static str = "relpath"; static NAME: &str = "relpath";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/rm/rm.rs
View file

@ -42,8 +42,8 @@ struct Options {
verbose: bool, verbose: bool,
} }
static NAME: &'static str = "rm"; static NAME: &str = "rm";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
// TODO: make getopts support -R in addition to -r // TODO: make getopts support -R in addition to -r

4
src/rmdir/rmdir.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::fs; use std::fs;
use std::path::Path; use std::path::Path;
static NAME: &'static str = "rmdir"; static NAME: &str = "rmdir";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/seq/seq.rs
View file

@ -11,8 +11,8 @@ extern crate uucore;
use std::cmp; use std::cmp;
use std::io::{stdout, Write}; use std::io::{stdout, Write};
static NAME: &'static str = "seq"; static NAME: &str = "seq";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Clone)] #[derive(Clone)]
struct SeqOptions { struct SeqOptions {

6
src/shred/shred.rs
View file

@ -25,10 +25,10 @@ use std::path::{Path, PathBuf};
#[macro_use] #[macro_use]
extern crate uucore; extern crate uucore;
static NAME: &'static str = "shred"; static NAME: &str = "shred";
static VERSION_STR: &'static str = "1.0.0"; static VERSION_STR: &str = "1.0.0";
const BLOCK_SIZE: usize = 512; const BLOCK_SIZE: usize = 512;
const NAMESET: &'static str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_."; const NAMESET: &str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
// Patterns as shown in the GNU coreutils shred implementation // Patterns as shown in the GNU coreutils shred implementation
const PATTERNS: [&'static [u8]; 22] = [ const PATTERNS: [&'static [u8]; 22] = [

4
src/shuf/shuf.rs
View file

@ -26,8 +26,8 @@ enum Mode {
InputRange((usize, usize)), InputRange((usize, usize)),
} }
static NAME: &'static str = "shuf"; static NAME: &str = "shuf";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/sleep/sleep.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::thread; use std::thread;
use std::time::Duration; use std::time::Duration;
static NAME: &'static str = "sleep"; static NAME: &str = "sleep";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

8
src/sort/sort.rs
View file

@ -26,11 +26,11 @@ use uucore::fs::is_stdin_interactive;
use semver::Version; use semver::Version;
use itertools::Itertools; // for Iterator::dedup() use itertools::Itertools; // for Iterator::dedup()
static NAME: &'static str = "sort"; static NAME: &str = "sort";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
static DECIMAL_PT: char = '.'; const DECIMAL_PT: char = '.';
static THOUSANDS_SEP: char = ','; const THOUSANDS_SEP: char = ',';
enum SortMode { enum SortMode {
Numeric, Numeric,

4
src/split/split.rs
View file

@ -19,8 +19,8 @@ use std::fs::{File, OpenOptions};
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write}; use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::path::Path; use std::path::Path;
static NAME: &'static str = "split"; static NAME: &str = "split";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/stdbuf/build.rs
View file

@ -7,12 +7,12 @@ mod mkmain;
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
mod platform { mod platform {
pub const DYLIB_EXT: &'static str = ".so"; pub const DYLIB_EXT: &str = ".so";
} }
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
mod platform { mod platform {
pub const DYLIB_EXT: &'static str = ".dylib"; pub const DYLIB_EXT: &str = ".dylib";
} }
fn main() { fn main() {

6
src/stdbuf/stdbuf.rs
View file

@ -23,10 +23,10 @@ use std::os::unix::process::ExitStatusExt;
use std::path::PathBuf; use std::path::PathBuf;
use std::process::Command; use std::process::Command;
static NAME: &'static str = "stdbuf"; static NAME: &str = "stdbuf";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
const STDBUF_INJECT: &'static [u8] = include_bytes!(concat!(env!("OUT_DIR"), "/libstdbuf.so")); const STDBUF_INJECT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/libstdbuf.so"));
enum BufferType { enum BufferType {
Default, Default,

4
src/sum/sum.rs
View file

@ -18,8 +18,8 @@ use std::fs::File;
use std::io::{stdin, Read, Result}; use std::io::{stdin, Read, Result};
use std::path::Path; use std::path::Path;
static NAME: &'static str = "sum"; static NAME: &str = "sum";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
fn bsd_sum(mut reader: Box<Read>) -> (usize, u16) { fn bsd_sum(mut reader: Box<Read>) -> (usize, u16) {
let mut buf = [0; 1024]; let mut buf = [0; 1024];

4
src/sync/sync.rs
View file

@ -21,8 +21,8 @@ extern crate uucore;
#[cfg(not(windows))] #[cfg(not(windows))]
extern crate uucore; extern crate uucore;
static NAME: &'static str = "sync"; static NAME: &str = "sync";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(unix)] #[cfg(unix)]
mod platform { mod platform {

4
src/tac/tac.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::fs::File; use std::fs::File;
use std::io::{stdin, stdout, BufReader, Read, Stdout, Write}; use std::io::{stdin, stdout, BufReader, Read, Stdout, Write};
static NAME: &'static str = "tac"; static NAME: &str = "tac";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/tail/tail.rs
View file

@ -29,8 +29,8 @@ use std::str::from_utf8;
use std::thread::sleep; use std::thread::sleep;
use std::time::Duration; use std::time::Duration;
static NAME: &'static str = "tail"; static NAME: &str = "tail";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
enum FilterMode { enum FilterMode {
Bytes(u64), Bytes(u64),

4
src/tee/tee.rs
View file

@ -17,8 +17,8 @@ use std::fs::OpenOptions;
use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write}; use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write};
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
static NAME: &'static str = "tee"; static NAME: &str = "tee";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
match options(&args).and_then(exec) { match options(&args).and_then(exec) {

2
src/test/test.rs
View file

@ -18,7 +18,7 @@ use std::ffi::OsString;
use std::env::args_os; use std::env::args_os;
use std::str::from_utf8; use std::str::from_utf8;
static NAME: &'static str = "test"; static NAME: &str = "test";
// TODO: decide how to handle non-UTF8 input for all the utils // TODO: decide how to handle non-UTF8 input for all the utils
// Definitely don't use [u8], try keeping it as OsStr or OsString instead // Definitely don't use [u8], try keeping it as OsStr or OsString instead

6
src/timeout/timeout.rs
View file

@ -21,10 +21,10 @@ use std::process::{Command, Stdio};
use std::time::Duration; use std::time::Duration;
use uucore::process::ChildExt; use uucore::process::ChildExt;
static NAME: &'static str = "timeout"; static NAME: &str = "timeout";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
static ERR_EXIT_STATUS: i32 = 125; const ERR_EXIT_STATUS: i32 = 125;
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let program = args[0].clone(); let program = args[0].clone();

4
src/touch/touch.rs
View file

@ -21,8 +21,8 @@ use std::fs::{self, File};
use std::io::{self, Error}; use std::io::{self, Error};
use std::path::Path; use std::path::Path;
static NAME: &'static str = "touch"; static NAME: &str = "touch";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
// Since touch's date/timestamp parsing doesn't account for timezone, the // Since touch's date/timestamp parsing doesn't account for timezone, the
// returned value from time::strptime() is UTC. We get system's timezone to // returned value from time::strptime() is UTC. We get system's timezone to

4
src/tr/tr.rs
View file

@ -28,8 +28,8 @@ use expand::ExpandSet;
mod expand; mod expand;
static NAME: &'static str = "tr"; static NAME: &str = "tr";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
const BUFFER_LEN: usize = 1024; const BUFFER_LEN: usize = 1024;
trait SymbolTranslator { trait SymbolTranslator {

4
src/truncate/truncate.rs
View file

@ -31,8 +31,8 @@ enum TruncateMode {
RoundUp, RoundUp,
} }
static NAME: &'static str = "truncate"; static NAME: &str = "truncate";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/tsort/tsort.rs
View file

@ -20,8 +20,8 @@ use std::fs::File;
use std::io::{stdin, BufRead, BufReader, Read}; use std::io::{stdin, BufRead, BufReader, Read};
use std::path::Path; use std::path::Path;
static NAME: &'static str = "tsort"; static NAME: &str = "tsort";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

4
src/tty/tty.rs
View file

@ -24,8 +24,8 @@ extern "C" {
fn ttyname(filedesc: libc::c_int) -> *const libc::c_char; fn ttyname(filedesc: libc::c_int) -> *const libc::c_char;
} }
static NAME: &'static str = "tty"; static NAME: &str = "tty";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new(); let mut opts = getopts::Options::new();

32
src/uname/uname.rs
View file

@ -19,35 +19,35 @@ extern crate uucore;
use clap::{App, Arg}; use clap::{App, Arg};
use platform_info::*; use platform_info::*;
const VERSION: &'static str = env!("CARGO_PKG_VERSION"); const VERSION: &str = env!("CARGO_PKG_VERSION");
const ABOUT: &'static str = "Print certain system information. With no OPTION, same as -s."; const ABOUT: &str = "Print certain system information. With no OPTION, same as -s.";
const OPT_ALL: &'static str = "all"; const OPT_ALL: &str = "all";
const OPT_KERNELNAME: &'static str = "kernel-name"; const OPT_KERNELNAME: &str = "kernel-name";
const OPT_NODENAME: &'static str = "nodename"; const OPT_NODENAME: &str = "nodename";
const OPT_KERNELVERSION: &'static str = "kernel-version"; const OPT_KERNELVERSION: &str = "kernel-version";
const OPT_KERNELRELEASE: &'static str = "kernel-release"; const OPT_KERNELRELEASE: &str = "kernel-release";
const OPT_MACHINE: &'static str = "machine"; const OPT_MACHINE: &str = "machine";
//FIXME: unimplemented options //FIXME: unimplemented options
//const OPT_PROCESSOR: &'static str = "processor"; //const OPT_PROCESSOR: &'static str = "processor";
//const OPT_HWPLATFORM: &'static str = "hardware-platform"; //const OPT_HWPLATFORM: &'static str = "hardware-platform";
const OPT_OS: &'static str = "operating-system"; const OPT_OS: &str = "operating-system";
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
const HOST_OS: &'static str = "GNU/Linux"; const HOST_OS: &str = "GNU/Linux";
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
const HOST_OS: &'static str = "Windows NT"; const HOST_OS: &str = "Windows NT";
#[cfg(target_os = "freebsd")] #[cfg(target_os = "freebsd")]
const HOST_OS: &'static str = "FreeBSD"; const HOST_OS: &str = "FreeBSD";
#[cfg(target_os = "openbsd")] #[cfg(target_os = "openbsd")]
const HOST_OS: &'static str = "OpenBSD"; const HOST_OS: &str = "OpenBSD";
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
const HOST_OS: &'static str = "Darwin"; const HOST_OS: &str = "Darwin";
#[cfg(target_os = "fuchsia")] #[cfg(target_os = "fuchsia")]
const HOST_OS: &'static str = "Fuchsia"; const HOST_OS: &str = "Fuchsia";
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
const HOST_OS: &'static str = "Redox"; const HOST_OS: &str = "Redox";
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let usage = format!("{} [OPTION]...", executable!()); let usage = format!("{} [OPTION]...", executable!());

1
src/unexpand/Cargo.toml
View file

@ -14,7 +14,6 @@ unicode-width = "0.1.5"
[dependencies.uucore] [dependencies.uucore]
path = "../uucore" path = "../uucore"
features = ["utf8"]
[[bin]] [[bin]]
name = "unexpand" name = "unexpand"

8
src/unexpand/unexpand.rs
View file

@ -22,10 +22,10 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write}
use std::str::from_utf8; use std::str::from_utf8;
use unicode_width::UnicodeWidthChar; use unicode_width::UnicodeWidthChar;
static NAME: &'static str = "unexpand"; static NAME: &str = "unexpand";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
static DEFAULT_TABSTOP: usize = 8; const DEFAULT_TABSTOP: usize = 8;
fn tabstops_parse(s: String) -> Vec<usize> { fn tabstops_parse(s: String) -> Vec<usize> {
let words = s.split(',').collect::<Vec<&str>>(); let words = s.split(',').collect::<Vec<&str>>();
@ -239,7 +239,7 @@ fn unexpand(options: Options) {
} }
let (ctype, cwidth, nbytes) = if options.uflag { let (ctype, cwidth, nbytes) = if options.uflag {
let nbytes = uucore::utf8::utf8_char_width(buf[byte]); let nbytes = char::from(buf[byte]).len_utf8();
// figure out how big the next char is, if it's UTF-8 // figure out how big the next char is, if it's UTF-8
if byte + nbytes > buf.len() { if byte + nbytes > buf.len() {

4
src/uniq/uniq.rs
View file

@ -21,8 +21,8 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::path::Path; use std::path::Path;
use std::str::FromStr; use std::str::FromStr;
static NAME: &'static str = "uniq"; static NAME: &str = "uniq";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(PartialEq)] #[derive(PartialEq)]
enum Delimiters { enum Delimiters {

4
src/unlink/unlink.rs
View file

@ -24,8 +24,8 @@ use std::io::{Error, ErrorKind};
use std::mem::uninitialized; use std::mem::uninitialized;
use std::ffi::CString; use std::ffi::CString;
static NAME: &'static str = "unlink"; static NAME: &str = "unlink";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new(); let mut opts = Options::new();

4
src/uptime/uptime.rs
View file

@ -23,8 +23,8 @@ pub use uucore::libc;
use getopts::Options; use getopts::Options;
static NAME: &'static str = "uptime"; static NAME: &str = "uptime";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(unix)] #[cfg(unix)]
use libc::getloadavg; use libc::getloadavg;

4
src/users/users.rs
View file

@ -21,8 +21,8 @@ use uucore::utmpx::*;
use getopts::Options; use getopts::Options;
static NAME: &'static str = "users"; static NAME: &str = "users";
static VERSION: &'static str = env!("CARGO_PKG_VERSION"); static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 { pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new(); let mut opts = Options::new();

2
src/uucore/coreopts.rs
View file

@ -18,7 +18,7 @@ impl<'a> CoreOptions<'a> {
pub fn new(help_text: HelpText<'a>) -> Self { pub fn new(help_text: HelpText<'a>) -> Self {
let mut ret = CoreOptions { let mut ret = CoreOptions {
options: getopts::Options::new(), options: getopts::Options::new(),
help_text: help_text, help_text,
}; };
ret.options ret.options
.optflag("", "help", "print usage information") .optflag("", "help", "print usage information")

4
src/uucore/encoding.rs
View file

@ -66,8 +66,8 @@ impl<R: Read> Data<R> {
Data { Data {
line_wrap: 76, line_wrap: 76,
ignore_garbage: false, ignore_garbage: false,
input: input, input,
format: format, format,
alphabet: match format { alphabet: match format {
Base32 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=", Base32 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
Base64 => b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=+/", Base64 => b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=+/",

2
src/uucore/fs.rs
View file

@ -31,7 +31,7 @@ macro_rules! has {
) )
} }
pub fn resolve_relative_path<'a>(path: &'a Path) -> Cow<'a, Path> { pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
if path.components().all(|e| e != Component::ParentDir) { if path.components().all(|e| e != Component::ParentDir) {
return path.into(); return path.into();
} }

Some files were not shown because too many files have changed in this diff Show more