diff --git a/CMakeLists.txt b/CMakeLists.txt index 281455fed..5a6c54981 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -105,7 +105,7 @@ set(FISH_BUILTIN_SRCS src/builtins/disown.cpp src/builtins/eval.cpp src/builtins/fg.cpp src/builtins/function.cpp src/builtins/functions.cpp src/builtins/history.cpp - src/builtins/jobs.cpp src/builtins/math.cpp src/builtins/printf.cpp src/builtins/path.cpp + src/builtins/jobs.cpp src/builtins/math.cpp src/builtins/path.cpp src/builtins/read.cpp src/builtins/set.cpp src/builtins/set_color.cpp src/builtins/source.cpp src/builtins/status.cpp src/builtins/string.cpp src/builtins/test.cpp src/builtins/type.cpp src/builtins/ulimit.cpp diff --git a/fish-rust/src/builtins/mod.rs b/fish-rust/src/builtins/mod.rs index 171493f1e..bee42d858 100644 --- a/fish-rust/src/builtins/mod.rs +++ b/fish-rust/src/builtins/mod.rs @@ -7,6 +7,7 @@ pub mod contains; pub mod echo; pub mod emit; pub mod exit; +pub mod printf; pub mod pwd; pub mod random; pub mod realpath; diff --git a/fish-rust/src/builtins/printf.rs b/fish-rust/src/builtins/printf.rs new file mode 100644 index 000000000..7aa53ab00 --- /dev/null +++ b/fish-rust/src/builtins/printf.rs @@ -0,0 +1,810 @@ +// printf - format and print data +// Copyright (C) 1990-2007 Free Software Foundation, Inc. +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ +// Usage: printf format [argument...] +// +// A front end to the printf function that lets it be used from the shell. +// +// Backslash escapes: +// +// \" = double quote +// \\ = backslash +// \a = alert (bell) +// \b = backspace +// \c = produce no further output +// \e = escape +// \f = form feed +// \n = new line +// \r = carriage return +// \t = horizontal tab +// \v = vertical tab +// \ooo = octal number (ooo is 1 to 3 digits) +// \xhh = hexadecimal number (hhh is 1 to 2 digits) +// \uhhhh = 16-bit Unicode character (hhhh is 4 digits) +// \Uhhhhhhhh = 32-bit Unicode character (hhhhhhhh is 8 digits) +// +// Additional directive: +// +// %b = print an argument string, interpreting backslash escapes, +// except that octal escapes are of the form \0 or \0ooo. +// +// The `format' argument is re-used as many times as necessary +// to convert all of the given arguments. +// +// David MacKenzie + +// This file has been imported from source code of printf command in GNU Coreutils version 6.9. + +use libc::c_int; +use num_traits; +use std::result::Result; + +use crate::builtins::shared::{io_streams_t, STATUS_CMD_ERROR, STATUS_CMD_OK, STATUS_INVALID_ARGS}; +use crate::ffi::parser_t; +use crate::locale::{get_numeric_locale, Locale}; +use crate::wchar::{encode_byte_to_char, wstr, WExt, WString, L}; +use crate::wutil::errors::Error; +use crate::wutil::gettext::{wgettext, wgettext_fmt}; +use crate::wutil::wcstod::wcstod; +use crate::wutil::wcstoi::{fish_wcstoi_partial, Options as WcstoiOpts}; +use crate::wutil::{sprintf, wstr_offset_in}; +use printf_compat::args::ToArg; +use printf_compat::printf::sprintf_locale; + +/// \return true if \p c is an octal digit. +fn is_octal_digit(c: char) -> bool { + ('0'..='7').contains(&c) +} + +/// \return true if \p c is a decimal digit. +fn iswdigit(c: char) -> bool { + c.is_ascii_digit() +} + +/// \return true if \p c is a hexadecimal digit. +fn iswxdigit(c: char) -> bool { + c.is_ascii_hexdigit() +} + +struct builtin_printf_state_t<'a> { + // Out and err streams. Note this is a captured reference! + streams: &'a mut io_streams_t, + + // The status of the operation. + exit_code: c_int, + + // Whether we should stop outputting. This gets set in the case of an error, and also with the + // \c escape. + early_exit: bool, + + // Our output buffer, so we don't write() constantly. + // Our strategy is simple: + // We print once per argument, and we flush the buffer before the error. + buff: WString, + + // The locale, which affects printf output and also parsing of floats due to decimal separators. + locale: Locale, +} + +/// Convert to a scalar type. \return the result of conversion, and the end of the converted string. +/// On conversion failure, \p end is not modified. +trait RawStringToScalarType: Copy + num_traits::Zero + std::convert::From { + /// Convert from a string to our self type. + /// \return the result of conversion, and the remainder of the string. + fn raw_string_to_scalar_type<'a>( + s: &'a wstr, + locale: &Locale, + end: &mut &'a wstr, + ) -> Result; + + /// Convert from a Unicode code point to this type. + /// This supports printf's ability to convert from char to scalar via a leading quote. + /// Try it: + /// > printf "%f" "'a" + /// 97.000000 + /// Wild stuff. + fn from_ord(c: char) -> Self { + let as_u32: u32 = c.into(); + as_u32.into() + } +} + +impl RawStringToScalarType for i64 { + fn raw_string_to_scalar_type<'a>( + s: &'a wstr, + _locale: &Locale, + end: &mut &'a wstr, + ) -> Result { + let mut consumed = 0; + let res = fish_wcstoi_partial(s, WcstoiOpts::default(), &mut consumed); + *end = s.slice_from(consumed); + res + } +} + +impl RawStringToScalarType for u64 { + fn raw_string_to_scalar_type<'a>( + s: &'a wstr, + _locale: &Locale, + end: &mut &'a wstr, + ) -> Result { + let mut consumed = 0; + let res = fish_wcstoi_partial( + s, + WcstoiOpts { + wrap_negatives: true, + ..Default::default() + }, + &mut consumed, + ); + *end = s.slice_from(consumed); + res + } +} + +impl RawStringToScalarType for f64 { + fn raw_string_to_scalar_type<'a>( + s: &'a wstr, + locale: &Locale, + end: &mut &'a wstr, + ) -> Result { + let mut consumed: usize = 0; + let mut result = wcstod(s, locale.decimal_point, &mut consumed); + if result.is_ok() && consumed == s.chars().count() { + *end = s.slice_from(consumed); + return result; + } + // The conversion using the user's locale failed. That may be due to the string not being a + // valid floating point value. It could also be due to the locale using different separator + // characters than the normal english convention. So try again by forcing the use of a locale + // that employs the english convention for writing floating point numbers. + consumed = 0; + result = wcstod(s, '.', &mut consumed); + if result.is_ok() { + *end = s.slice_from(consumed); + } + return result; + } +} + +/// Convert a string to a scalar type. +/// Use state.verify_numeric to report any errors. +fn string_to_scalar_type( + s: &wstr, + state: &mut builtin_printf_state_t, +) -> T { + if s.char_at(0) == '"' || s.char_at(0) == '\'' { + // Note that if the string is really just a leading quote, + // we really do want to convert the "trailing nul". + T::from_ord(s.char_at(1)) + } else { + let mut end = s; + let mval = T::raw_string_to_scalar_type(s, &state.locale, &mut end); + state.verify_numeric(s, end, mval.err()); + mval.unwrap_or(T::zero()) + } +} + +/// For each character in str, set the corresponding boolean in the array to the given flag. +fn modify_allowed_format_specifiers(ok: &mut [bool; 256], str: &str, flag: bool) { + for c in str.chars() { + ok[c as usize] = flag; + } +} + +impl<'a> builtin_printf_state_t<'a> { + #[allow(clippy::partialeq_to_none)] + fn verify_numeric(&mut self, s: &wstr, end: &wstr, errcode: Option) { + // This check matches the historic `errcode != EINVAL` check from C++. + // Note that empty or missing values will be silently treated as 0. + if errcode != None && errcode != Some(Error::InvalidChar) && errcode != Some(Error::Empty) { + match errcode.unwrap() { + Error::Overflow => { + self.fatal_error(sprintf!("%ls: %ls", s, wgettext!("Number out of range"))); + } + Error::Empty => { + self.fatal_error(sprintf!("%ls: %ls", s, wgettext!("Number was empty"))); + } + Error::InvalidChar | Error::CharsLeft => { + panic!("Unreachable"); + } + } + } else if !end.is_empty() { + if s.as_ptr() == end.as_ptr() { + self.fatal_error(wgettext_fmt!("%ls: expected a numeric value", s)); + } else { + // This isn't entirely fatal - the value should still be printed. + self.nonfatal_error(wgettext_fmt!( + "%ls: value not completely converted (can't convert '%ls')", + s, + end + )); + // Warn about octal numbers as they can be confusing. + // Do it if the unconverted digit is a valid hex digit, + // because it could also be an "0x" -> "0" typo. + if s.char_at(0) == '0' && iswxdigit(end.char_at(0)) { + self.nonfatal_error(wgettext_fmt!( + "Hint: a leading '0' without an 'x' indicates an octal number" + )); + } + } + } + } + + /// Evaluate a printf conversion specification. SPEC is the start of the directive, and CONVERSION + /// specifies the type of conversion. SPEC does not include any length modifier or the + /// conversion specifier itself. FIELD_WIDTH and PRECISION are the field width and + /// precision for '*' values, if HAVE_FIELD_WIDTH and HAVE_PRECISION are true, respectively. + /// ARGUMENT is the argument to be formatted. + #[allow(clippy::collapsible_else_if, clippy::too_many_arguments)] + fn print_direc( + &mut self, + spec: &wstr, + conversion: char, + have_field_width: bool, + field_width: i32, + have_precision: bool, + precision: i32, + argument: &wstr, + ) { + /// Printf macro helper which provides our locale. + macro_rules! sprintf_loc { + ( + $fmt:expr, // format string of type &wstr + $($arg:expr),* // arguments + ) => { + sprintf_locale( + $fmt, + &self.locale, + &[$($arg.to_arg()),*] + ) + } + } + + // Start with everything except the conversion specifier. + let mut fmt = spec.to_owned(); + + // Create a copy of the % directive, with a width modifier substituted for any + // existing integer length modifier. + match conversion { + 'x' | 'X' | 'd' | 'i' | 'o' | 'u' => { + fmt.push_str("ll"); + } + 'a' | 'e' | 'f' | 'g' | 'A' | 'E' | 'F' | 'G' => { + fmt.push_str("L"); + } + 's' | 'c' => { + fmt.push_str("l"); + } + _ => {} + } + + // Append the conversion itself. + fmt.push(conversion); + + // Rebind as a ref. + let fmt: &wstr = &fmt; + match conversion { + 'd' | 'i' => { + let arg: i64 = string_to_scalar_type(argument, self); + if !have_field_width { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, precision, arg)); + } + } else { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, field_width, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, field_width, precision, arg)); + } + } + } + 'o' | 'u' | 'x' | 'X' => { + let arg: u64 = string_to_scalar_type(argument, self); + if !have_field_width { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, precision, arg)); + } + } else { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, field_width, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, field_width, precision, arg)); + } + } + } + + 'a' | 'A' | 'e' | 'E' | 'f' | 'F' | 'g' | 'G' => { + let arg: f64 = string_to_scalar_type(argument, self); + if !have_field_width { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, precision, arg)); + } + } else { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, field_width, arg)); + } else { + self.append_output_str(sprintf_loc!(fmt, field_width, precision, arg)); + } + } + } + + 'c' => { + if !have_field_width { + self.append_output_str(sprintf_loc!(fmt, argument.char_at(0))); + } else { + self.append_output_str(sprintf_loc!(fmt, field_width, argument.char_at(0))); + } + } + + 's' => { + if !have_field_width { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, argument)); + } else { + self.append_output_str(sprintf_loc!(fmt, precision, argument)); + } + } else { + if !have_precision { + self.append_output_str(sprintf_loc!(fmt, field_width, argument)); + } else { + self.append_output_str(sprintf_loc!(fmt, field_width, precision, argument)); + } + } + } + + _ => { + panic!("unexpected opt: {}", conversion); + } + } + } + + /// Print the text in FORMAT, using ARGV for arguments to any `%' directives. + /// Return the number of elements of ARGV used. + fn print_formatted(&mut self, format: &wstr, mut argv: &[&wstr]) -> usize { + let mut argc = argv.len(); + let save_argc = argc; /* Preserve original value. */ + let mut f: &wstr; /* Pointer into `format'. */ + let mut direc_start: &wstr; /* Start of % directive. */ + let mut direc_length: usize; /* Length of % directive. */ + let mut have_field_width: bool; /* True if FIELD_WIDTH is valid. */ + let mut field_width: c_int = 0; /* Arg to first '*'. */ + let mut have_precision: bool; /* True if PRECISION is valid. */ + let mut precision = 0; /* Arg to second '*'. */ + let mut ok = [false; 256]; /* ok['x'] is true if %x is allowed. */ + + // N.B. this was originally written as a loop like so: + // for (f = format; *f != L'\0'; ++f) { + // so we emulate that. + f = format; + let mut first = true; + loop { + if !first { + f = &f[1..]; + } + first = false; + if f.is_empty() { + break; + } + + match f.char_at(0) { + '%' => { + direc_start = f; + f = &f[1..]; + direc_length = 1; + have_field_width = false; + have_precision = false; + if f.char_at(0) == '%' { + self.append_output('%'); + continue; + } + if f.char_at(0) == 'b' { + // FIXME: Field width and precision are not supported for %b, even though POSIX + // requires it. + if argc > 0 { + self.print_esc_string(argv[0]); + argv = &argv[1..]; + argc -= 1; + } + continue; + } + + modify_allowed_format_specifiers(&mut ok, "aAcdeEfFgGiosuxX", true); + let mut continue_looking_for_flags = true; + while continue_looking_for_flags { + match f.char_at(0) { + 'I' | '\'' => { + modify_allowed_format_specifiers(&mut ok, "aAceEosxX", false); + } + + '-' | '+' | ' ' => { + // pass + } + + '#' => { + modify_allowed_format_specifiers(&mut ok, "cdisu", false); + } + + '0' => { + modify_allowed_format_specifiers(&mut ok, "cs", false); + } + + _ => { + continue_looking_for_flags = false; + } + } + if continue_looking_for_flags { + f = &f[1..]; + direc_length += 1; + } + } + + if f.char_at(0) == '*' { + f = &f[1..]; + direc_length += 1; + if argc > 0 { + let width: i64 = string_to_scalar_type(argv[0], self); + if (c_int::MIN as i64) <= width && width <= (c_int::MAX as i64) { + field_width = width as c_int; + } else { + self.fatal_error(wgettext_fmt!( + "invalid field width: %ls", + argv[0] + )); + } + argv = &argv[1..]; + argc -= 1; + } else { + field_width = 0; + } + have_field_width = true; + } else { + while iswdigit(f.char_at(0)) { + f = &f[1..]; + direc_length += 1; + } + } + + if f.char_at(0) == '.' { + f = &f[1..]; + direc_length += 1; + modify_allowed_format_specifiers(&mut ok, "c", false); + if f.char_at(0) == '*' { + f = &f[1..]; + direc_length += 1; + if argc > 0 { + let prec: i64 = string_to_scalar_type(argv[0], self); + if prec < 0 { + // A negative precision is taken as if the precision were omitted, + // so -1 is safe here even if prec < INT_MIN. + precision = -1; + } else if (c_int::MAX as i64) < prec { + self.fatal_error(wgettext_fmt!( + "invalid precision: %ls", + argv[0] + )); + } else { + precision = prec as c_int; + } + argv = &argv[1..]; + argc -= 1; + } else { + precision = 0; + } + have_precision = true; + } else { + while iswdigit(f.char_at(0)) { + f = &f[1..]; + direc_length += 1; + } + } + } + + while matches!(f.char_at(0), 'l' | 'L' | 'h' | 'j' | 't' | 'z') { + f = &f[1..]; + } + + let conversion = f.char_at(0); + if (conversion as usize) > 0xFF || !ok[conversion as usize] { + self.fatal_error(wgettext_fmt!( + "%.*ls: invalid conversion specification", + wstr_offset_in(f, direc_start) + 1, + direc_start + )); + return 0; + } + + let mut argument = L!(""); + if argc > 0 { + argument = argv[0]; + argv = &argv[1..]; + argc -= 1; + } + self.print_direc( + &direc_start[..direc_length], + f.char_at(0), + have_field_width, + field_width, + have_precision, + precision, + argument, + ); + } + '\\' => { + let consumed_minus_1 = self.print_esc(f, false); + f = &f[consumed_minus_1..]; // Loop increment will add 1. + } + + c => { + self.append_output(c); + } + } + } + save_argc - argc + } + + fn nonfatal_error>(&mut self, errstr: Str) { + let errstr = errstr.as_ref(); + // Don't error twice. + if self.early_exit { + return; + } + + // If we have output, write it so it appears first. + if !self.buff.is_empty() { + self.streams.out.append(&self.buff); + self.buff.clear(); + } + + self.streams.err.append(errstr); + if !errstr.ends_with('\n') { + self.streams.err.append1('\n'); + } + + // We set the exit code to error, because one occurred, + // but we don't do an early exit so we still print what we can. + self.exit_code = STATUS_CMD_ERROR.unwrap(); + } + + fn fatal_error>(&mut self, errstr: Str) { + let errstr = errstr.as_ref(); + + // Don't error twice. + if self.early_exit { + return; + } + + // If we have output, write it so it appears first. + if !self.buff.is_empty() { + self.streams.out.append(&self.buff); + self.buff.clear(); + } + + self.streams.err.append(errstr); + if !errstr.ends_with('\n') { + self.streams.err.append1('\n'); + } + + self.exit_code = STATUS_CMD_ERROR.unwrap(); + self.early_exit = true; + } + + /// Print a \ escape sequence starting at ESCSTART. + /// Return the number of characters in the string, *besides the backslash*. + /// That is this is ONE LESS than the number of characters consumed. + /// If octal_0 is nonzero, octal escapes are of the form \0ooo, where o + /// is an octal digit; otherwise they are of the form \ooo. + fn print_esc(&mut self, escstart: &wstr, octal_0: bool) -> usize { + assert!(escstart.char_at(0) == '\\'); + let mut p = &escstart[1..]; + let mut esc_value = 0; /* Value of \nnn escape. */ + let mut esc_length; /* Length of \nnn escape. */ + if p.char_at(0) == 'x' { + // A hexadecimal \xhh escape sequence must have 1 or 2 hex. digits. + p = &p[1..]; + esc_length = 0; + while esc_length < 2 && iswxdigit(p.char_at(0)) { + esc_value = esc_value * 16 + p.char_at(0).to_digit(16).unwrap(); + esc_length += 1; + p = &p[1..]; + } + if esc_length == 0 { + self.fatal_error(wgettext!("missing hexadecimal number in escape")); + } + self.append_output(encode_byte_to_char((esc_value % 256) as u8)); + } else if is_octal_digit(p.char_at(0)) { + // Parse \0ooo (if octal_0 && *p == L'0') or \ooo (otherwise). Allow \ooo if octal_0 && *p + // != L'0'; this is an undocumented extension to POSIX that is compatible with Bash 2.05b. + // Wrap mod 256, which matches historic behavior. + esc_length = 0; + if octal_0 && p.char_at(0) == '0' { + p = &p[1..]; + } + while esc_length < 3 && is_octal_digit(p.char_at(0)) { + esc_value = esc_value * 8 + p.char_at(0).to_digit(8).unwrap(); + esc_length += 1; + p = &p[1..]; + } + self.append_output(encode_byte_to_char((esc_value % 256) as u8)); + } else if "\"\\abcefnrtv".contains(p.char_at(0)) { + self.print_esc_char(p.char_at(0)); + p = &p[1..]; + } else if p.char_at(0) == 'u' || p.char_at(0) == 'U' { + let esc_char: char = p.char_at(0); + p = &p[1..]; + let mut uni_value = 0; + let exp_esc_length = if esc_char == 'u' { 4 } else { 8 }; + for esc_length in 0..exp_esc_length { + if !iswxdigit(p.char_at(0)) { + // Escape sequence must be done. Complain if we didn't get anything. + if esc_length == 0 { + self.fatal_error(wgettext!("Missing hexadecimal number in Unicode escape")); + } + break; + } + uni_value = uni_value * 16 + p.char_at(0).to_digit(16).unwrap(); + p = &p[1..]; + } + // N.B. we assume __STDC_ISO_10646__. + if uni_value > 0x10FFFF { + self.fatal_error(wgettext_fmt!( + "Unicode character out of range: \\%c%0*x", + esc_char, + exp_esc_length, + uni_value + )); + } else { + // TODO-RUST: if uni_value is a surrogate, we need to encode it using our PUA scheme. + if let Some(c) = char::from_u32(uni_value) { + self.append_output(c); + } else { + self.fatal_error(wgettext!("Invalid code points not yet supported by printf")); + } + } + } else { + self.append_output('\\'); + if !p.is_empty() { + self.append_output(p.char_at(0)); + p = &p[1..]; + } + } + return wstr_offset_in(p, escstart) - 1; + } + + /// Print string str, evaluating \ escapes. + fn print_esc_string(&mut self, mut str: &wstr) { + // Emulating the following loop: for (; *str; str++) + while !str.is_empty() { + let c = str.char_at(0); + if c == '\\' { + let consumed_minus_1 = self.print_esc(str, false); + str = &str[consumed_minus_1..]; + } else { + self.append_output(c); + } + str = &str[1..]; + } + } + + /// Output a single-character \ escape. + fn print_esc_char(&mut self, c: char) { + match c { + 'a' => { + // alert + self.append_output('\x07'); // \a + } + 'b' => { + // backspace + self.append_output('\x08'); // \b + } + 'c' => { + // cancel the rest of the output + self.early_exit = true; + } + 'e' => { + // escape + self.append_output('\x1B'); + } + 'f' => { + // form feed + self.append_output('\x0C'); // \f + } + 'n' => { + // new line + self.append_output('\n'); + } + 'r' => { + // carriage return + self.append_output('\r'); + } + 't' => { + // horizontal tab + self.append_output('\t'); + } + 'v' => { + // vertical tab + self.append_output('\x0B'); // \v + } + _ => { + self.append_output(c); + } + } + } + + fn append_output(&mut self, c: char) { + // Don't output if we're done. + if self.early_exit { + return; + } + + self.buff.push(c); + } + + fn append_output_str>(&mut self, s: Str) { + // Don't output if we're done. + if self.early_exit { + return; + } + + self.buff.push_utfstr(&s); + } +} + +/// The printf builtin. +pub fn printf( + _parser: &mut parser_t, + streams: &mut io_streams_t, + argv: &mut [&wstr], +) -> Option { + let mut argc = argv.len(); + + // Rebind argv as immutable slice (can't rearrange its elements), skipping the command name. + let mut argv: &[&wstr] = &argv[1..]; + argc -= 1; + if argc < 1 { + return STATUS_INVALID_ARGS; + } + + let mut state = builtin_printf_state_t { + streams, + exit_code: STATUS_CMD_OK.unwrap(), + early_exit: false, + buff: WString::new(), + locale: get_numeric_locale(), + }; + let format = argv[0]; + argc -= 1; + argv = &argv[1..]; + loop { + let args_used = state.print_formatted(format, argv); + argc -= args_used; + argv = &argv[args_used..]; + if !state.buff.is_empty() { + state.streams.out.append(&state.buff); + state.buff.clear(); + } + if !(args_used > 0 && argc > 0 && !state.early_exit) { + break; + } + } + return Some(state.exit_code); +} diff --git a/fish-rust/src/builtins/shared.rs b/fish-rust/src/builtins/shared.rs index f7163dab3..0504689fb 100644 --- a/fish-rust/src/builtins/shared.rs +++ b/fish-rust/src/builtins/shared.rs @@ -1,4 +1,4 @@ -use crate::builtins::wait; +use crate::builtins::{printf, wait}; use crate::ffi::{self, parser_t, wcharz_t, Repin, RustBuiltin}; use crate::wchar::{self, wstr, L}; use crate::wchar_ffi::{c_str, empty_wstring}; @@ -45,7 +45,9 @@ pub const STATUS_CMD_OK: Option = Some(0); /// The status code used for failure exit in a command (but not if the args were invalid). pub const STATUS_CMD_ERROR: Option = Some(1); -/// A handy return value for invalid args. +/// The status code used for invalid arguments given to a command. This is distinct from valid +/// arguments that might result in a command failure. An invalid args condition is something +/// like an unrecognized flag, missing or too many arguments, an invalid integer, etc. pub const STATUS_INVALID_ARGS: Option = Some(2); /// A wrapper around output_stream_t. @@ -61,6 +63,11 @@ impl output_stream_t { pub fn append>(&mut self, s: Str) -> bool { self.ffi().append1(c_str!(s)) } + + /// Append a char. + pub fn append1(&mut self, c: char) -> bool { + self.append(wstr::from_char_slice(&[c])) + } } // Convenience wrappers around C++ io_streams_t. @@ -132,6 +139,7 @@ pub fn run_builtin( RustBuiltin::Realpath => super::realpath::realpath(parser, streams, args), RustBuiltin::Return => super::r#return::r#return(parser, streams, args), RustBuiltin::Wait => wait::wait(parser, streams, args), + RustBuiltin::Printf => printf::printf(parser, streams, args), } } diff --git a/fish-rust/src/wchar_ext.rs b/fish-rust/src/wchar_ext.rs index a9e4ae876..7f7633f1c 100644 --- a/fish-rust/src/wchar_ext.rs +++ b/fish-rust/src/wchar_ext.rs @@ -153,6 +153,13 @@ pub trait WExt { /// Access the chars of a WString or wstr. fn as_char_slice(&self) -> &[char]; + /// Return a char slice from a *char index*. + /// This is different from Rust string slicing, which takes a byte index. + fn slice_from(&self, start: usize) -> &wstr { + let chars = self.as_char_slice(); + wstr::from_char_slice(&chars[start..]) + } + /// \return the char at an index. /// If the index is equal to the length, return '\0'. /// If the index exceeds the length, then panic. diff --git a/fish-rust/src/wutil/mod.rs b/fish-rust/src/wutil/mod.rs index 358c9add7..12f2ac374 100644 --- a/fish-rust/src/wutil/mod.rs +++ b/fish-rust/src/wutil/mod.rs @@ -8,6 +8,7 @@ pub mod wcstoi; mod wrealpath; use crate::common::fish_reserved_codepoint; +use crate::wchar::wstr; pub(crate) use gettext::{wgettext, wgettext_fmt}; pub use normalize_path::*; pub(crate) use printf::sprintf; @@ -48,3 +49,32 @@ fn fish_is_pua(c: char) -> bool { pub fn fish_iswalnum(c: char) -> bool { !fish_reserved_codepoint(c) && !fish_is_pua(c) && c.is_alphanumeric() } + +/// Given that \p cursor is a pointer into \p base, return the offset in characters. +/// This emulates C pointer arithmetic: +/// `wstr_offset_in(cursor, base)` is equivalent to C++ `cursor - base`. +pub fn wstr_offset_in(cursor: &wstr, base: &wstr) -> usize { + let cursor = cursor.as_slice(); + let base = base.as_slice(); + // cursor may be a zero-length slice at the end of base, + // which base.as_ptr_range().contains(cursor.as_ptr()) will reject. + let base_range = base.as_ptr_range(); + let curs_range = cursor.as_ptr_range(); + assert!( + base_range.start <= curs_range.start && curs_range.end <= base_range.end, + "cursor should be a subslice of base" + ); + let offset = unsafe { cursor.as_ptr().offset_from(base.as_ptr()) }; + assert!(offset >= 0, "offset should be non-negative"); + offset as usize +} + +#[test] +fn test_wstr_offset_in() { + use crate::wchar::L; + let base = L!("hello world"); + assert_eq!(wstr_offset_in(&base[6..], base), 6); + assert_eq!(wstr_offset_in(&base[0..], base), 0); + assert_eq!(wstr_offset_in(&base[6..], &base[6..]), 0); + assert_eq!(wstr_offset_in(&base[base.len()..], base), base.len()); +} diff --git a/src/builtin.cpp b/src/builtin.cpp index 3bf424c8e..9c2c0070e 100644 --- a/src/builtin.cpp +++ b/src/builtin.cpp @@ -44,7 +44,6 @@ #include "builtins/jobs.h" #include "builtins/math.h" #include "builtins/path.h" -#include "builtins/printf.h" #include "builtins/read.h" #include "builtins/set.h" #include "builtins/set_color.h" @@ -393,7 +392,7 @@ static constexpr builtin_data_t builtin_datas[] = { {L"not", &builtin_generic, N_(L"Negate exit status of job")}, {L"or", &builtin_generic, N_(L"Execute command if previous command failed")}, {L"path", &builtin_path, N_(L"Handle paths")}, - {L"printf", &builtin_printf, N_(L"Prints formatted text")}, + {L"printf", &implemented_in_rust, N_(L"Prints formatted text")}, {L"pwd", &implemented_in_rust, N_(L"Print the working directory")}, {L"random", &implemented_in_rust, N_(L"Generate random number")}, {L"read", &builtin_read, N_(L"Read a line of input into variables")}, @@ -558,6 +557,9 @@ static maybe_t try_get_rust_builtin(const wcstring &cmd) { if (cmd == L"wait") { return RustBuiltin::Wait; } + if (cmd == L"printf") { + return RustBuiltin::Printf; + } if (cmd == L"return") { return RustBuiltin::Return; } diff --git a/src/builtin.h b/src/builtin.h index 40774d4b8..944fba4e2 100644 --- a/src/builtin.h +++ b/src/builtin.h @@ -116,6 +116,7 @@ enum RustBuiltin : int32_t { Echo, Emit, Exit, + Printf, Pwd, Random, Realpath, diff --git a/src/builtins/printf.cpp b/src/builtins/printf.cpp deleted file mode 100644 index 7a09438e2..000000000 --- a/src/builtins/printf.cpp +++ /dev/null @@ -1,713 +0,0 @@ -// printf - format and print data -// Copyright (C) 1990-2007 Free Software Foundation, Inc. -// -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation; either version 2, or (at your option) -// any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software Foundation, -// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ - -// Usage: printf format [argument...] -// -// A front end to the printf function that lets it be used from the shell. -// -// Backslash escapes: -// -// \" = double quote -// \\ = backslash -// \a = alert (bell) -// \b = backspace -// \c = produce no further output -// \e = escape -// \f = form feed -// \n = new line -// \r = carriage return -// \t = horizontal tab -// \v = vertical tab -// \ooo = octal number (ooo is 1 to 3 digits) -// \xhh = hexadecimal number (hhh is 1 to 2 digits) -// \uhhhh = 16-bit Unicode character (hhhh is 4 digits) -// \Uhhhhhhhh = 32-bit Unicode character (hhhhhhhh is 8 digits) -// -// Additional directive: -// -// %b = print an argument string, interpreting backslash escapes, -// except that octal escapes are of the form \0 or \0ooo. -// -// The `format' argument is re-used as many times as necessary -// to convert all of the given arguments. -// -// David MacKenzie - -// This file has been imported from source code of printf command in GNU Coreutils version 6.9. -#include "config.h" // IWYU pragma: keep - -#include "printf.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef HAVE_XLOCALE_H -#include -#endif - -#include "../builtin.h" -#include "../common.h" -#include "../io.h" -#include "../maybe.h" -#include "../wcstringutil.h" -#include "../wutil.h" // IWYU pragma: keep - -class parser_t; - -namespace { -struct builtin_printf_state_t { - // Out and err streams. Note this is a captured reference! - io_streams_t &streams; - - // The status of the operation. - int exit_code; - - // Whether we should stop outputting. This gets set in the case of an error, and also with the - // \c escape. - bool early_exit; - // Our output buffer, so we don't write() constantly. - // Our strategy is simple: - // We print once per argument, and we flush the buffer before the error. - wcstring buff; - - explicit builtin_printf_state_t(io_streams_t &s) - : streams(s), exit_code(0), early_exit(false) {} - - void verify_numeric(const wchar_t *s, const wchar_t *end, int errcode); - - void print_direc(const wchar_t *start, size_t length, wchar_t conversion, bool have_field_width, - int field_width, bool have_precision, int precision, wchar_t const *argument); - - int print_formatted(const wchar_t *format, int argc, const wchar_t **argv); - - void nonfatal_error(const wchar_t *fmt, ...); - void fatal_error(const wchar_t *fmt, ...); - - long print_esc(const wchar_t *escstart, bool octal_0); - void print_esc_string(const wchar_t *str); - void print_esc_char(wchar_t c); - - void append_output(wchar_t c); - void append_format_output(const wchar_t *fmt, ...); -}; -} // namespace - -static bool is_octal_digit(wchar_t c) { return iswdigit(c) && c < L'8'; } - -void builtin_printf_state_t::nonfatal_error(const wchar_t *fmt, ...) { - // Don't error twice. - if (early_exit) return; - - // If we have output, write it so it appears first. - if (!buff.empty()) { - streams.out.append(buff); - buff.clear(); - } - - va_list va; - va_start(va, fmt); - wcstring errstr = vformat_string(fmt, va); - va_end(va); - streams.err.append(errstr); - if (!string_suffixes_string(L"\n", errstr)) streams.err.push_back(L'\n'); - - // We set the exit code to error, because one occurred, - // but we don't do an early exit so we still print what we can. - this->exit_code = STATUS_CMD_ERROR; -} - -void builtin_printf_state_t::fatal_error(const wchar_t *fmt, ...) { - // Don't error twice. - if (early_exit) return; - - // If we have output, write it so it appears first. - if (!buff.empty()) { - streams.out.append(buff); - buff.clear(); - } - - va_list va; - va_start(va, fmt); - wcstring errstr = vformat_string(fmt, va); - va_end(va); - streams.err.append(errstr); - if (!string_suffixes_string(L"\n", errstr)) streams.err.push_back(L'\n'); - - this->exit_code = STATUS_CMD_ERROR; - this->early_exit = true; -} -void builtin_printf_state_t::append_output(wchar_t c) { - // Don't output if we're done. - if (early_exit) return; - - buff.push_back(c); -} - -void builtin_printf_state_t::append_format_output(const wchar_t *fmt, ...) { - // Don't output if we're done. - if (early_exit) return; - - va_list va; - va_start(va, fmt); - wcstring tmp = vformat_string(fmt, va); - va_end(va); - buff.append(tmp); -} - -void builtin_printf_state_t::verify_numeric(const wchar_t *s, const wchar_t *end, int errcode) { - if (errcode != 0 && errcode != EINVAL) { - if (errcode == ERANGE) { - this->fatal_error(L"%ls: %ls", s, _(L"Number out of range")); - } else { - this->fatal_error(L"%ls: %s", s, std::strerror(errcode)); - } - } else if (*end) { - if (s == end) { - this->fatal_error(_(L"%ls: expected a numeric value"), s); - } else { - // This isn't entirely fatal - the value should still be printed. - this->nonfatal_error(_(L"%ls: value not completely converted (can't convert '%ls')"), s, - end); - // Warn about octal numbers as they can be confusing. - // Do it if the unconverted digit is a valid hex digit, - // because it could also be an "0x" -> "0" typo. - if (*s == L'0' && iswxdigit(*end)) { - this->nonfatal_error( - _(L"Hint: a leading '0' without an 'x' indicates an octal number"), s, end); - } - } - } -} - -template -static T raw_string_to_scalar_type(const wchar_t *s, wchar_t **end); - -template <> -intmax_t raw_string_to_scalar_type(const wchar_t *s, wchar_t **end) { - return std::wcstoimax(s, end, 0); -} - -template <> -uintmax_t raw_string_to_scalar_type(const wchar_t *s, wchar_t **end) { - return std::wcstoumax(s, end, 0); -} - -template <> -long double raw_string_to_scalar_type(const wchar_t *s, wchar_t **end) { - double val = std::wcstod(s, end); - if (**end == L'\0') return val; - // The conversion using the user's locale failed. That may be due to the string not being a - // valid floating point value. It could also be due to the locale using different separator - // characters than the normal english convention. So try again by forcing the use of a locale - // that employs the english convention for writing floating point numbers. - return wcstod_l(s, end, fish_c_locale()); -} - -template -static T string_to_scalar_type(const wchar_t *s, builtin_printf_state_t *state) { - T val; - if (*s == L'\"' || *s == L'\'') { - wchar_t ch = *++s; - val = ch; - } else { - wchar_t *end = nullptr; - errno = 0; - val = raw_string_to_scalar_type(s, &end); - state->verify_numeric(s, end, errno); - } - return val; -} - -/// Output a single-character \ escape. -void builtin_printf_state_t::print_esc_char(wchar_t c) { - switch (c) { - case L'a': { // alert - this->append_output(L'\a'); - break; - } - case L'b': { // backspace - this->append_output(L'\b'); - break; - } - case L'c': { // cancel the rest of the output - this->early_exit = true; - break; - } - case L'e': { // escape - this->append_output(L'\x1B'); - break; - } - case L'f': { // form feed - this->append_output(L'\f'); - break; - } - case L'n': { // new line - this->append_output(L'\n'); - break; - } - case L'r': { // carriage return - this->append_output(L'\r'); - break; - } - case L't': { // horizontal tab - this->append_output(L'\t'); - break; - } - case L'v': { // vertical tab - this->append_output(L'\v'); - break; - } - default: { - this->append_output(c); - break; - } - } -} - -/// Print a \ escape sequence starting at ESCSTART. -/// Return the number of characters in the escape sequence besides the backslash.. -/// If OCTAL_0 is nonzero, octal escapes are of the form \0ooo, where o -/// is an octal digit; otherwise they are of the form \ooo. -long builtin_printf_state_t::print_esc(const wchar_t *escstart, bool octal_0) { - const wchar_t *p = escstart + 1; - int esc_value = 0; /* Value of \nnn escape. */ - int esc_length; /* Length of \nnn escape. */ - - if (*p == L'x') { - // A hexadecimal \xhh escape sequence must have 1 or 2 hex. digits. - for (esc_length = 0, ++p; esc_length < 2 && iswxdigit(*p); ++esc_length, ++p) - esc_value = esc_value * 16 + convert_digit(*p, 16); - if (esc_length == 0) this->fatal_error(_(L"missing hexadecimal number in escape")); - this->append_output(ENCODE_DIRECT_BASE + esc_value % 256); - } else if (is_octal_digit(*p)) { - // Parse \0ooo (if octal_0 && *p == L'0') or \ooo (otherwise). Allow \ooo if octal_0 && *p - // != L'0'; this is an undocumented extension to POSIX that is compatible with Bash 2.05b. - // Wrap mod 256, which matches historic behavior. - for (esc_length = 0, p += octal_0 && *p == L'0'; esc_length < 3 && is_octal_digit(*p); - ++esc_length, ++p) - esc_value = esc_value * 8 + convert_digit(*p, 8); - this->append_output(ENCODE_DIRECT_BASE + esc_value % 256); - } else if (*p && std::wcschr(L"\"\\abcefnrtv", *p)) { - print_esc_char(*p++); - } else if (*p == L'u' || *p == L'U') { - wchar_t esc_char = *p; - p++; - uint32_t uni_value = 0; - for (size_t esc_length = 0; esc_length < (esc_char == L'u' ? 4 : 8); esc_length++) { - if (!iswxdigit(*p)) { - // Escape sequence must be done. Complain if we didn't get anything. - if (esc_length == 0) { - this->fatal_error(_(L"Missing hexadecimal number in Unicode escape")); - } - break; - } - uni_value = uni_value * 16 + convert_digit(*p, 16); - p++; - } - - // PCA GNU printf respects the limitations described in ISO N717, about which universal - // characters "shall not" be specified. I believe this limitation is for the benefit of - // compilers; I see no reason to impose it in builtin_printf. - // - // If __STDC_ISO_10646__ is defined, then it means wchar_t can and does hold Unicode code - // points, so just use that. If not defined, use the %lc printf conversion; this probably - // won't do anything good if your wide character set is not Unicode, but such platforms are - // exceedingly rare. - if (uni_value > 0x10FFFF) { - this->fatal_error(_(L"Unicode character out of range: \\%c%0*x"), esc_char, - (esc_char == L'u' ? 4 : 8), uni_value); - } else { -#if defined(__STDC_ISO_10646__) - this->append_output(uni_value); -#else - this->append_format_output(L"%lc", uni_value); -#endif - } - } else { - this->append_output(L'\\'); - if (*p) { - this->append_output(*p); - p++; - } - } - return p - escstart - 1; -} - -/// Print string STR, evaluating \ escapes. -void builtin_printf_state_t::print_esc_string(const wchar_t *str) { - for (; *str; str++) - if (*str == L'\\') - str += print_esc(str, true); - else - this->append_output(*str); -} - -/// Evaluate a printf conversion specification. START is the start of the directive, LENGTH is its -/// length, and CONVERSION specifies the type of conversion. LENGTH does not include any length -/// modifier or the conversion specifier itself. FIELD_WIDTH and PRECISION are the field width and -/// precision for '*' values, if HAVE_FIELD_WIDTH and HAVE_PRECISION are true, respectively. -/// ARGUMENT is the argument to be formatted. -void builtin_printf_state_t::print_direc(const wchar_t *start, size_t length, wchar_t conversion, - bool have_field_width, int field_width, - bool have_precision, int precision, - wchar_t const *argument) { - // Start with everything except the conversion specifier. - wcstring fmt(start, length); - - // Create a copy of the % directive, with an intmax_t-wide width modifier substituted for any - // existing integer length modifier. - switch (conversion) { - case L'x': - case L'X': - case L'd': - case L'i': - case L'o': - case L'u': { - fmt.append(L"ll"); - break; - } - case L'a': - case L'e': - case L'f': - case L'g': - case L'A': - case L'E': - case L'F': - case L'G': { - fmt.append(L"L"); - break; - } - case L's': - case L'c': { - fmt.append(L"l"); - break; - } - default: { - break; - } - } - - // Append the conversion itself. - fmt.push_back(conversion); - - switch (conversion) { - case L'd': - case L'i': { - auto arg = string_to_scalar_type(argument, this); - if (!have_field_width) { - if (!have_precision) - this->append_format_output(fmt.c_str(), arg); - else - this->append_format_output(fmt.c_str(), precision, arg); - } else { - if (!have_precision) - this->append_format_output(fmt.c_str(), field_width, arg); - else - this->append_format_output(fmt.c_str(), field_width, precision, arg); - } - break; - } - case L'o': - case L'u': - case L'x': - case L'X': { - auto arg = string_to_scalar_type(argument, this); - if (!have_field_width) { - if (!have_precision) - this->append_format_output(fmt.c_str(), arg); - else - this->append_format_output(fmt.c_str(), precision, arg); - } else { - if (!have_precision) - this->append_format_output(fmt.c_str(), field_width, arg); - else - this->append_format_output(fmt.c_str(), field_width, precision, arg); - } - break; - } - case L'a': - case L'A': - case L'e': - case L'E': - case L'f': - case L'F': - case L'g': - case L'G': { - auto arg = string_to_scalar_type(argument, this); - if (!have_field_width) { - if (!have_precision) { - this->append_format_output(fmt.c_str(), arg); - } else { - this->append_format_output(fmt.c_str(), precision, arg); - } - } else { - if (!have_precision) { - this->append_format_output(fmt.c_str(), field_width, arg); - } else { - this->append_format_output(fmt.c_str(), field_width, precision, arg); - } - } - break; - } - case L'c': { - if (!have_field_width) { - this->append_format_output(fmt.c_str(), *argument); - } else { - this->append_format_output(fmt.c_str(), field_width, *argument); - } - break; - } - case L's': { - if (!have_field_width) { - if (!have_precision) { - this->append_format_output(fmt.c_str(), argument); - } else { - this->append_format_output(fmt.c_str(), precision, argument); - } - } else { - if (!have_precision) { - this->append_format_output(fmt.c_str(), field_width, argument); - } else { - this->append_format_output(fmt.c_str(), field_width, precision, argument); - } - } - break; - } - default: { - DIE("unexpected opt"); - } - } -} - -/// For each character in str, set the corresponding boolean in the array to the given flag. -static inline void modify_allowed_format_specifiers(bool ok[UCHAR_MAX + 1], const char *str, - bool flag) { - for (const char *c = str; *c != '\0'; c++) { - auto idx = static_cast(*c); - ok[idx] = flag; - } -} - -/// Print the text in FORMAT, using ARGV (with ARGC elements) for arguments to any `%' directives. -/// Return the number of elements of ARGV used. -int builtin_printf_state_t::print_formatted(const wchar_t *format, int argc, const wchar_t **argv) { - int save_argc = argc; /* Preserve original value. */ - const wchar_t *f; /* Pointer into `format'. */ - const wchar_t *direc_start; /* Start of % directive. */ - size_t direc_length; /* Length of % directive. */ - bool have_field_width; /* True if FIELD_WIDTH is valid. */ - int field_width = 0; /* Arg to first '*'. */ - bool have_precision; /* True if PRECISION is valid. */ - int precision = 0; /* Arg to second '*'. */ - bool ok[UCHAR_MAX + 1] = {}; /* ok['x'] is true if %x is allowed. */ - - for (f = format; *f != L'\0'; ++f) { - switch (*f) { - case L'%': { - direc_start = f++; - direc_length = 1; - have_field_width = have_precision = false; - if (*f == L'%') { - this->append_output(L'%'); - break; - } - if (*f == L'b') { - // FIXME: Field width and precision are not supported for %b, even though POSIX - // requires it. - if (argc > 0) { - print_esc_string(*argv); - ++argv; - --argc; - } - break; - } - - modify_allowed_format_specifiers(ok, "aAcdeEfFgGiosuxX", true); - for (bool continue_looking_for_flags = true; continue_looking_for_flags;) { - switch (*f) { - case L'I': - case L'\'': { - modify_allowed_format_specifiers(ok, "aAceEosxX", false); - break; - } - case '-': - case '+': - case ' ': { - break; - } - case L'#': { - modify_allowed_format_specifiers(ok, "cdisu", false); - break; - } - case '0': { - modify_allowed_format_specifiers(ok, "cs", false); - break; - } - default: { - continue_looking_for_flags = false; - break; - } - } - if (continue_looking_for_flags) { - f++; - direc_length++; - } - } - - if (*f == L'*') { - ++f; - ++direc_length; - if (argc > 0) { - auto width = string_to_scalar_type(*argv, this); - if (INT_MIN <= width && width <= INT_MAX) - field_width = static_cast(width); - else - this->fatal_error(_(L"invalid field width: %ls"), *argv); - ++argv; - --argc; - } else { - field_width = 0; - } - have_field_width = true; - } else { - while (iswdigit(*f)) { - ++f; - ++direc_length; - } - } - if (*f == L'.') { - ++f; - ++direc_length; - modify_allowed_format_specifiers(ok, "c", false); - if (*f == L'*') { - ++f; - ++direc_length; - if (argc > 0) { - auto prec = string_to_scalar_type(*argv, this); - if (prec < 0) { - // A negative precision is taken as if the precision were omitted, - // so -1 is safe here even if prec < INT_MIN. - precision = -1; - } else if (INT_MAX < prec) - this->fatal_error(_(L"invalid precision: %ls"), *argv); - else { - precision = static_cast(prec); - } - ++argv; - --argc; - } else { - precision = 0; - } - have_precision = true; - } else { - while (iswdigit(*f)) { - ++f; - ++direc_length; - } - } - } - - while (*f == L'l' || *f == L'L' || *f == L'h' || *f == L'j' || *f == L't' || - *f == L'z') { - ++f; - } - - wchar_t conversion = *f; - if (conversion > 0xFF || !ok[conversion]) { - this->fatal_error(_(L"%.*ls: invalid conversion specification"), - static_cast(f + 1 - direc_start), direc_start); - return 0; - } - - const wchar_t *argument = L""; - if (argc > 0) { - argument = *argv++; - argc--; - } - print_direc(direc_start, direc_length, *f, have_field_width, field_width, - have_precision, precision, argument); - break; - } - case L'\\': { - f += print_esc(f, false); - break; - } - default: { - this->append_output(*f); - break; - } - } - } - return save_argc - argc; -} - -/// The printf builtin. -maybe_t builtin_printf(parser_t &parser, io_streams_t &streams, const wchar_t **argv) { - UNUSED(parser); - int argc = builtin_count_args(argv); - - argv++; - argc--; - - if (argc < 1) { - return STATUS_INVALID_ARGS; - } - -#if defined(HAVE_USELOCALE) || defined(__GLIBC__) - // We use a locale-dependent LC_NUMERIC here, - // unlike the rest of fish (which uses LC_NUMERIC=C). - // Because we do output as well as wcstod (which would have wcstod_l), - // we need to set the locale here. - // (glibc has uselocale since 2.3, but our configure checks fail us) - locale_t prev_locale = uselocale(fish_numeric_locale()); -#else - // NetBSD does not have uselocale, - // so the best we can do is setlocale. - auto prev_locale = setlocale(LC_NUMERIC, nullptr); - setlocale(LC_NUMERIC, ""); -#endif - - builtin_printf_state_t state(streams); - int args_used; - const wchar_t *format = argv[0]; - argc--; - argv++; - - do { - args_used = state.print_formatted(format, argc, argv); - argc -= args_used; - argv += args_used; - if (!state.buff.empty()) { - streams.out.append(state.buff); - state.buff.clear(); - } - } while (args_used > 0 && argc > 0 && !state.early_exit); - -#if defined(HAVE_USELOCALE) || defined(__GLIBC__) - uselocale(prev_locale); -#else - setlocale(LC_NUMERIC, prev_locale); -#endif - - return state.exit_code; -} diff --git a/src/builtins/printf.h b/src/builtins/printf.h deleted file mode 100644 index 7f7daebbf..000000000 --- a/src/builtins/printf.h +++ /dev/null @@ -1,11 +0,0 @@ -// Prototypes for functions for executing builtin_printf functions. -#ifndef FISH_BUILTIN_PRINTF_H -#define FISH_BUILTIN_PRINTF_H - -#include "../maybe.h" - -class parser_t; -struct io_streams_t; - -maybe_t builtin_printf(parser_t &parser, io_streams_t &streams, const wchar_t **argv); -#endif diff --git a/tests/checks/printf.fish b/tests/checks/printf.fish index 1c3a15afc..cbedab18d 100644 --- a/tests/checks/printf.fish +++ b/tests/checks/printf.fish @@ -124,6 +124,15 @@ printf '%d\n' 0g echo $status # CHECK: 1 +printf '%f\n' 0x2 +# CHECK: 2.000000 + +printf '%f\n' 0x2p3 +# CHECK: 16.000000 + +printf '%.1f\n' -0X1.5P8 +# CHECK: -336.0 + # Test that we ignore options printf -a printf --foo