// Implementation of the math builtin. #include "config.h" // IWYU pragma: keep #include "builtin_math.h" #include #include #include #include #include #include #include #include "builtin.h" #include "common.h" #include "fallback.h" // IWYU pragma: keep #include "io.h" #include "tinyexpr.h" #include "wgetopt.h" #include "wutil.h" // IWYU pragma: keep // The maximum number of points after the decimal that we'll print. static constexpr int kDefaultScale = 6; // The end of the range such that every integer is representable as a double. // i.e. this is the first value such that x + 1 == x (or == x + 2, depending on rounding mode). static constexpr double kMaximumContiguousInteger = double(1LLU << std::numeric_limits::digits); struct math_cmd_opts_t { bool print_help = false; int scale = kDefaultScale; }; // This command is atypical in using the "+" (REQUIRE_ORDER) option for flag parsing. // This is needed because of the minus, `-`, operator in math expressions. static const wchar_t *const short_options = L"+:hs:"; static const struct woption long_options[] = {{L"scale", required_argument, nullptr, 's'}, {L"help", no_argument, nullptr, 'h'}, {nullptr, 0, nullptr, 0}}; static int parse_cmd_opts(math_cmd_opts_t &opts, int *optind, //!OCLINT(high ncss method) int argc, wchar_t **argv, parser_t &parser, io_streams_t &streams) { const wchar_t *cmd = L"math"; int opt; wgetopter_t w; while ((opt = w.wgetopt_long(argc, argv, short_options, long_options, nullptr)) != -1) { switch (opt) { case 's': { // "max" is the special value that tells us to pick the maximum scale. if (std::wcscmp(w.woptarg, L"max") == 0) { opts.scale = 15; } else { opts.scale = fish_wcstoi(w.woptarg); if (errno || opts.scale < 0 || opts.scale > 15) { streams.err.append_format(_(L"%ls: '%ls' is not a valid scale value\n"), cmd, w.woptarg); return STATUS_INVALID_ARGS; } } break; } case 'h': { opts.print_help = true; break; } case ':': { builtin_missing_argument(parser, streams, cmd, argv[w.woptind - 1]); return STATUS_INVALID_ARGS; } case '?': { // For most commands this is an error. We ignore it because a math expression // can begin with a minus sign. *optind = w.woptind - 1; return STATUS_CMD_OK; } default: { DIE("unexpected retval from wgetopt_long"); break; } } } *optind = w.woptind; return STATUS_CMD_OK; } // We read from stdin if we are the second or later process in a pipeline. static bool math_args_from_stdin(const io_streams_t &streams) { return streams.stdin_is_directly_redirected; } /// Get the arguments from stdin. static const wchar_t *math_get_arg_stdin(wcstring *storage, const io_streams_t &streams) { std::string arg; for (;;) { char ch = '\0'; long rc = read_blocked(streams.stdin_fd, &ch, 1); if (rc < 0) return nullptr; // failure if (rc == 0) { // EOF if (arg.empty()) return nullptr; break; } if (ch == '\n') break; // we're done arg += ch; } *storage = str2wcstring(arg); return storage->c_str(); } /// Return the next argument from argv. static const wchar_t *math_get_arg_argv(int *argidx, wchar_t **argv) { return argv && argv[*argidx] ? argv[(*argidx)++] : nullptr; } /// Get the arguments from argv or stdin based on the execution context. This mimics how builtin /// `string` does it. static const wchar_t *math_get_arg(int *argidx, wchar_t **argv, wcstring *storage, const io_streams_t &streams) { if (math_args_from_stdin(streams)) { return math_get_arg_stdin(storage, streams); } return math_get_arg_argv(argidx, argv); } static const wchar_t *math_describe_error(te_error_t &error) { if (error.position == 0) return L"NO ERROR?!?"; switch (error.type) { case TE_ERROR_NONE: DIE("Error has no position"); case TE_ERROR_UNKNOWN_FUNCTION: return _(L"Unknown function"); case TE_ERROR_MISSING_CLOSING_PAREN: return _(L"Missing closing parenthesis"); case TE_ERROR_MISSING_OPENING_PAREN: return _(L"Missing opening parenthesis"); case TE_ERROR_TOO_FEW_ARGS: return _(L"Too few arguments"); case TE_ERROR_TOO_MANY_ARGS: return _(L"Too many arguments"); case TE_ERROR_MISSING_OPERATOR: return _(L"Missing operator"); case TE_ERROR_UNEXPECTED_TOKEN: return _(L"Unexpected token"); case TE_ERROR_LOGICAL_OPERATOR: return _(L"Logical operations are not supported, use `test` instead"); case TE_ERROR_UNKNOWN: return _(L"Expression is bogus"); default: return L"Unknown error"; } } /// Return a formatted version of the value \p v respecting the given \p opts. static wcstring format_double(double v, const math_cmd_opts_t &opts) { // As a special-case, a scale of 0 means to truncate to an integer // instead of rounding. if (opts.scale == 0) { v = trunc(v); return format_string(L"%.*f", opts.scale, v); } wcstring ret = format_string(L"%.*f", opts.scale, v); // If we contain a decimal separator, trim trailing zeros after it, and then the separator // itself if there's nothing after it. Detect a decimal separator as a non-digit. const wchar_t *const digits = L"0123456789"; if (ret.find_first_not_of(digits) != wcstring::npos) { while (ret.back() == L'0') { ret.pop_back(); } if (!std::wcschr(digits, ret.back())) { ret.pop_back(); } } // If we trimmed everything it must have just been zero. if (ret.empty()) { ret.push_back(L'0'); } return ret; } /// Evaluate math expressions. static int evaluate_expression(const wchar_t *cmd, parser_t &parser, io_streams_t &streams, math_cmd_opts_t &opts, wcstring &expression) { UNUSED(parser); int retval = STATUS_CMD_OK; te_error_t error; std::string narrow_str = wcs2string(expression); // Switch locale while computing stuff. // This means that the "." is always the radix character, // so numbers work the same across locales. char *saved_locale = strdup(setlocale(LC_NUMERIC, nullptr)); setlocale(LC_NUMERIC, "C"); double v = te_interp(narrow_str.c_str(), &error); if (error.position == 0) { // Check some runtime errors after the fact. // TODO: Really, this should be done in tinyexpr // (e.g. infinite is the result of "x / 0"), // but that's much more work. const char *error_message = nullptr; if (std::isinf(v)) { error_message = "Result is infinite"; } else if (std::isnan(v)) { error_message = "Result is not a number"; } else if (std::abs(v) >= kMaximumContiguousInteger) { error_message = "Result magnitude is too large"; } if (error_message) { streams.err.append_format(L"%ls: Error: %s\n", cmd, error_message); streams.err.append_format(L"'%ls'\n", expression.c_str()); retval = STATUS_CMD_ERROR; } else { streams.out.append(format_double(v, opts)); streams.out.push_back(L'\n'); } } else { streams.err.append_format(L"%ls: Error: %ls\n", cmd, math_describe_error(error)); streams.err.append_format(L"'%ls'\n", expression.c_str()); streams.err.append_format(L"%*ls%ls\n", error.position - 1, L" ", L"^"); retval = STATUS_CMD_ERROR; } setlocale(LC_NUMERIC, saved_locale); free(saved_locale); return retval; } /// The math builtin evaluates math expressions. int builtin_math(parser_t &parser, io_streams_t &streams, wchar_t **argv) { wchar_t *cmd = argv[0]; int argc = builtin_count_args(argv); math_cmd_opts_t opts; int optind; // Is this really the right way to handle no expression present? // if (argc == 0) return STATUS_CMD_OK; int retval = parse_cmd_opts(opts, &optind, argc, argv, parser, streams); if (retval != STATUS_CMD_OK) return retval; if (opts.print_help) { builtin_print_help(parser, streams, cmd); return STATUS_CMD_OK; } wcstring expression; wcstring storage; while (const wchar_t *arg = math_get_arg(&optind, argv, &storage, streams)) { if (!expression.empty()) expression.push_back(L' '); expression.append(arg); } if (expression.empty()) { streams.err.append_format(BUILTIN_ERR_MIN_ARG_COUNT1, L"math", 1, 0); return STATUS_CMD_ERROR; } return evaluate_expression(cmd, parser, streams, opts, expression); }