diff --git a/share/functions/history.fish b/share/functions/history.fish index c3dca2b22..286e0dd8e 100644 --- a/share/functions/history.fish +++ b/share/functions/history.fish @@ -22,7 +22,7 @@ function __fish_unexpected_hist_args --no-scope-shadowing return 0 end if set -q argv[1] - printf (_ "%ls: %ls command expected %d args, got %d\n") $cmd $hist_cmd 0 (count $argv) >&2 + printf (_ "%ls: %ls expected %d args, got %d\n") $cmd $hist_cmd 0 (count $argv) >&2 return 0 end return 1 diff --git a/src/autoload.h b/src/autoload.h index a5bd206ce..49891828f 100644 --- a/src/autoload.h +++ b/src/autoload.h @@ -82,7 +82,7 @@ class autoload_t : private lru_cache_t { protected: /// Overridable callback for when a command is removed. - virtual void command_removed(const wcstring &cmd) {} + virtual void command_removed(const wcstring &cmd) { UNUSED(cmd); } public: /// Create an autoload_t for the given environment variable name. diff --git a/src/builtin.cpp b/src/builtin.cpp index fd4d89d0d..d21d81f53 100644 --- a/src/builtin.cpp +++ b/src/builtin.cpp @@ -123,6 +123,7 @@ static int count_char(const wchar_t *str, wchar_t c) { /// A wcstring with a formatted manpage. /// wcstring builtin_help_get(parser_t &parser, io_streams_t &streams, const wchar_t *name) { + UNUSED(parser); // This won't ever work if no_exec is set. if (no_exec) return wcstring(); @@ -1294,6 +1295,7 @@ static bool builtin_echo_parse_numeric_sequence(const wchar_t *str, size_t *cons /// Bash only respects -n if it's the first argument. We'll do the same. We also support a new /// option -s to mean "no spaces" static int builtin_echo(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); // Skip first arg if (!*argv++) return STATUS_BUILTIN_ERROR; @@ -1446,6 +1448,12 @@ static int builtin_echo(parser_t &parser, io_streams_t &streams, wchar_t **argv) /// The pwd builtin. We don't respect -P to resolve symbolic links because we /// try to always resolve them. static int builtin_pwd(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); + if (argv[1] != NULL) { + streams.err.append_format(BUILTIN_ERR_ARG_COUNT1, argv[0], 0, builtin_count_args(argv)); + return STATUS_BUILTIN_ERROR; + } + wcstring res = wgetcwd(); if (res.empty()) { return STATUS_BUILTIN_ERROR; @@ -2402,6 +2410,7 @@ static int builtin_cd(parser_t &parser, io_streams_t &streams, wchar_t **argv) { /// Implementation of the builtin count command, used to count the number of arguments sent to it. static int builtin_count(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); int argc; argc = builtin_count_args(argv); streams.out.append_format(L"%d\n", argc - 1); @@ -2726,6 +2735,11 @@ static int builtin_break_continue(parser_t &parser, io_streams_t &streams, wchar /// Implementation of the builtin breakpoint command, used to launch the interactive debugger. static int builtin_breakpoint(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + if (argv[1] != NULL) { + streams.err.append_format(BUILTIN_ERR_ARG_COUNT1, argv[0], 0, builtin_count_args(argv)); + return STATUS_BUILTIN_ERROR; + } + parser.push_block(new breakpoint_block_t()); reader_read(STDIN_FILENO, streams.io_chain ? *streams.io_chain : io_chain_t()); @@ -2846,7 +2860,7 @@ static bool set_hist_cmd(wchar_t *const cmd, hist_cmd_t *hist_cmd, hist_cmd_t su break; \ } \ if (args.size() != 0) { \ - streams.err.append_format(BUILTIN_ERR_ARG_COUNT, cmd, \ + streams.err.append_format(BUILTIN_ERR_ARG_COUNT2, cmd, \ hist_cmd_to_string(hist_cmd).c_str(), 0, args.size()); \ status = STATUS_BUILTIN_ERROR; \ break; \ @@ -3094,10 +3108,22 @@ int builtin_parse(parser_t &parser, io_streams_t &streams, wchar_t **argv) #endif int builtin_true(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); + UNUSED(streams); + if (argv[1] != NULL) { + streams.err.append_format(BUILTIN_ERR_ARG_COUNT1, argv[0], 0, builtin_count_args(argv)); + return STATUS_BUILTIN_ERROR; + } return STATUS_BUILTIN_OK; } int builtin_false(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); + UNUSED(streams); + if (argv[1] != NULL) { + streams.err.append_format(BUILTIN_ERR_ARG_COUNT1, argv[0], 0, builtin_count_args(argv)); + return STATUS_BUILTIN_ERROR; + } return STATUS_BUILTIN_ERROR; } diff --git a/src/builtin.h b/src/builtin.h index 45c0b0f9a..b76f75a35 100644 --- a/src/builtin.h +++ b/src/builtin.h @@ -53,7 +53,8 @@ enum { COMMAND_NOT_BUILTIN, BUILTIN_REGULAR, BUILTIN_FUNCTION }; #define BUILTIN_ERR_UNKNOWN _(L"%ls: Unknown option '%ls'\n") /// Error message for unexpected args. -#define BUILTIN_ERR_ARG_COUNT _(L"%ls: %ls command expected %d args, got %d\n") +#define BUILTIN_ERR_ARG_COUNT1 _(L"%ls: expected %d args, got %d\n") +#define BUILTIN_ERR_ARG_COUNT2 _(L"%ls: %ls expected %d args, got %d\n") /// Error message for invalid character in variable name. #define BUILTIN_ERR_VARCHAR \ diff --git a/src/builtin_printf.cpp b/src/builtin_printf.cpp index 35e5b18d4..7442673fe 100644 --- a/src/builtin_printf.cpp +++ b/src/builtin_printf.cpp @@ -695,6 +695,7 @@ int builtin_printf_state_t::print_formatted(const wchar_t *format, int argc, wch /// The printf builtin. int builtin_printf(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); builtin_printf_state_t state(streams); wchar_t *format; diff --git a/src/builtin_test.cpp b/src/builtin_test.cpp index b0a131026..334cbfb50 100644 --- a/src/builtin_test.cpp +++ b/src/builtin_test.cpp @@ -771,6 +771,7 @@ static bool unary_primary_evaluate(test_expressions::token_t token, const wcstri /// /// Return status is the final shell status, i.e. 0 for true, 1 for false and 2 for error. int builtin_test(parser_t &parser, io_streams_t &streams, wchar_t **argv) { + UNUSED(parser); using namespace test_expressions; // The first argument should be the name of the command ('test'). diff --git a/src/common.cpp b/src/common.cpp index 5287f359e..9f7d9c504 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -1340,6 +1340,7 @@ bool unescape_string(const wcstring &input, wcstring *output, unescape_flags_t e void common_handle_winch(int signal) { // Don't run ioctl() here, it's not safe to use in signals. + UNUSED(signal); termsize_valid = false; } diff --git a/src/common.h b/src/common.h index ba404e6e1..c6aa76449 100644 --- a/src/common.h +++ b/src/common.h @@ -766,4 +766,10 @@ __attribute__((noinline)) void debug_thread_error(void); /// specified base, return -1. long convert_digit(wchar_t d, int base); +/// This is a macro that can be used to silence "unused parameter" warnings from the compiler for +/// functions which need to accept parameters they do not use because they need to be compatible +/// with an interface. It's similar to the Python idiom of doing `_ = expr` at the top of a +/// function in the same situation. +#define UNUSED(expr) do { (void)(expr); } while (0) + #endif diff --git a/src/env.cpp b/src/env.cpp index cf0f0d02b..f34ee9c27 100644 --- a/src/env.cpp +++ b/src/env.cpp @@ -267,7 +267,7 @@ static void react_to_variable_change(const wcstring &key) { /// Universal variable callback function. This function makes sure the proper events are triggered /// when an event occurs. -static void universal_callback(fish_message_type_t type, const wchar_t *name, const wchar_t *val) { +static void universal_callback(fish_message_type_t type, const wchar_t *name) { const wchar_t *str = NULL; switch (type) { @@ -1102,7 +1102,7 @@ void env_universal_barrier() { // Post callbacks. for (size_t i = 0; i < changes.size(); i++) { const callback_data_t &data = changes.at(i); - universal_callback(data.type, data.key.c_str(), data.val.c_str()); + universal_callback(data.type, data.key.c_str()); } } } diff --git a/src/env_universal_common.cpp b/src/env_universal_common.cpp index fd889fcf5..a77eb6a6e 100644 --- a/src/env_universal_common.cpp +++ b/src/env_universal_common.cpp @@ -1299,6 +1299,7 @@ class universal_notifier_named_pipe_t : public universal_notifier_t { // select() on our fd for a while, and sync periodically until the fd is no longer readable. // However, if we are the one who posted the notification, we don't sync (until we clean // up!) + UNUSED(fd); bool should_sync = false; if (readback_time_usec == 0) { polling_due_to_readable_fd = true; @@ -1494,4 +1495,7 @@ bool universal_notifier_t::poll() { return false; } unsigned long universal_notifier_t::usec_delay_between_polls() const { return 0; } -bool universal_notifier_t::notification_fd_became_readable(int fd) { return false; } +bool universal_notifier_t::notification_fd_became_readable(int fd) { + UNUSED(fd); + return false; +} diff --git a/src/exec.cpp b/src/exec.cpp index 7d826766d..777f8e354 100644 --- a/src/exec.cpp +++ b/src/exec.cpp @@ -159,6 +159,7 @@ char *get_interpreter(const char *command, char *interpreter, size_t buff_size) /// specified in \c p. It never returns. Called in a forked child! Do not allocate memory, etc. static void safe_launch_process(process_t *p, const char *actual_cmd, const char *const *cargv, const char *const *cenvv) { + UNUSED(p); int err; // debug( 1, L"exec '%ls'", p->argv[0] ); diff --git a/src/expand.cpp b/src/expand.cpp index af0ad2e91..1c2a92eb1 100644 --- a/src/expand.cpp +++ b/src/expand.cpp @@ -212,7 +212,7 @@ static int iswnumeric(const wchar_t *n) { } /// See if the process described by \c proc matches the commandline \c cmd. -static bool match_pid(const wcstring &cmd, const wchar_t *proc, int flags, size_t *offset) { +static bool match_pid(const wcstring &cmd, const wchar_t *proc, size_t *offset) { // Test for a direct match. If the proc string is empty (e.g. the user tries to complete against // %), then return an offset pointing at the base command. That ensures that you don't see a // bunch of dumb paths when completing against all processes. @@ -507,7 +507,7 @@ static int find_job(const struct find_job_data_t *info) { if (j->command_is_empty()) continue; size_t offset; - if (match_pid(j->command(), proc, flags, &offset)) { + if (match_pid(j->command(), proc, &offset)) { if (flags & EXPAND_FOR_COMPLETIONS) { append_completion(&completions, j->command_wcstr() + offset + wcslen(proc), COMPLETE_JOB_DESC, 0); @@ -527,7 +527,7 @@ static int find_job(const struct find_job_data_t *info) { if (p->actual_cmd.empty()) continue; size_t offset; - if (match_pid(p->actual_cmd, proc, flags, &offset)) { + if (match_pid(p->actual_cmd, proc, &offset)) { if (flags & EXPAND_FOR_COMPLETIONS) { append_completion(&completions, wcstring(p->actual_cmd, offset + wcslen(proc)), @@ -570,7 +570,7 @@ static void find_process(const wchar_t *proc, expand_flags_t flags, process_iterator_t iterator; while (iterator.next_process(&process_name, &process_pid)) { size_t offset; - if (match_pid(process_name, proc, flags, &offset)) { + if (match_pid(process_name, proc, &offset)) { if (flags & EXPAND_FOR_COMPLETIONS) { append_completion(out, process_name.c_str() + offset + wcslen(proc), COMPLETE_PROCESS_DESC, 0); @@ -1381,6 +1381,7 @@ static expand_error_t expand_stage_home_and_pid(const wcstring &input, static expand_error_t expand_stage_wildcards(const wcstring &input, std::vector *out, expand_flags_t flags, parse_error_list_t *errors) { + UNUSED(errors); expand_error_t result = EXPAND_OK; wcstring path_to_expand = input; diff --git a/src/fallback.cpp b/src/fallback.cpp index cc12d53c9..0c386fa1e 100644 --- a/src/fallback.cpp +++ b/src/fallback.cpp @@ -39,6 +39,7 @@ #include // IWYU pragma: keep #include // IWYU pragma: keep +#include "common.h" // IWYU pragma: keep #include "fallback.h" // IWYU pragma: keep #include "util.h" // IWYU pragma: keep @@ -244,8 +245,15 @@ char *fish_bindtextdomain(const char *domainname, const char *dirname) { char *fish_textdomain(const char *domainname) { return textdomain(domainname); } #else char *fish_gettext(const char *msgid) { return (char *)msgid; } -char *fish_bindtextdomain(const char *domainname, const char *dirname) { return NULL; } -char *fish_textdomain(const char *domainname) { return NULL; } +char *fish_bindtextdomain(const char *domainname, const char *dirname) { + UNUSED(domainname); + UNUSED(dirname); + return NULL; +} +char *fish_textdomain(const char *domainname) { + UNUSED(domainname); + return NULL; +} #endif #ifndef HAVE_KILLPG diff --git a/src/function.cpp b/src/function.cpp index 6b8d4c7fb..34dbd85cd 100644 --- a/src/function.cpp +++ b/src/function.cpp @@ -158,6 +158,7 @@ function_info_t::function_info_t(const function_info_t &data, const wchar_t *fil shadow_scope(data.shadow_scope) {} void function_add(const function_data_t &data, const parser_t &parser, int definition_line_offset) { + UNUSED(parser); ASSERT_IS_MAIN_THREAD(); CHECK(!data.name.empty(), ); diff --git a/src/highlight.cpp b/src/highlight.cpp index 49dd2f065..21b75bce3 100644 --- a/src/highlight.cpp +++ b/src/highlight.cpp @@ -1186,6 +1186,7 @@ const highlighter_t::color_array_t &highlighter_t::highlight() { void highlight_shell(const wcstring &buff, std::vector &color, size_t pos, wcstring_list_t *error, const env_vars_snapshot_t &vars) { + UNUSED(error); // Do something sucky and get the current working directory on this background thread. This // should really be passed in. const wcstring working_directory = env_get_pwd_slash(); @@ -1197,6 +1198,7 @@ void highlight_shell(const wcstring &buff, std::vector &color, void highlight_shell_no_io(const wcstring &buff, std::vector &color, size_t pos, wcstring_list_t *error, const env_vars_snapshot_t &vars) { + UNUSED(error); // Do something sucky and get the current working directory on this background thread. This // should really be passed in. const wcstring working_directory = env_get_pwd_slash(); @@ -1291,6 +1293,8 @@ static void highlight_universal_internal(const wcstring &buffstr, void highlight_universal(const wcstring &buff, std::vector &color, size_t pos, wcstring_list_t *error, const env_vars_snapshot_t &vars) { + UNUSED(error); + UNUSED(vars); assert(buff.size() == color.size()); std::fill(color.begin(), color.end(), 0); highlight_universal_internal(buff, color, pos); diff --git a/src/history.cpp b/src/history.cpp index c8f3f31ba..4a6d19629 100644 --- a/src/history.cpp +++ b/src/history.cpp @@ -1662,7 +1662,8 @@ static int threaded_perform_file_detection(file_detection_context_t *ctx) { } static void perform_file_detection_done(file_detection_context_t *ctx, - int success) { //!OCLINT(success is ignored) + int success) { + UNUSED(success); ASSERT_IS_MAIN_THREAD(); // Now that file detection is done, update the history item with the valid file paths. diff --git a/src/iothread.cpp b/src/iothread.cpp index 21ca3694c..a83631ef8 100644 --- a/src/iothread.cpp +++ b/src/iothread.cpp @@ -116,6 +116,7 @@ static void *this_thread() { return (void *)(intptr_t)pthread_self(); } /// The function that does thread work. static void *iothread_worker(void *unused) { + UNUSED(unused); scoped_lock locker(s_spawn_queue_lock); struct SpawnRequest_t *req; while ((req = dequeue_spawn_request()) != NULL) { diff --git a/src/lru.h b/src/lru.h index d8a692c2e..1097489d4 100644 --- a/src/lru.h +++ b/src/lru.h @@ -93,7 +93,7 @@ class lru_cache_t { lru_node_t mouth; /// Overridable callback for when a node is evicted. - virtual void node_was_evicted(node_type_t *node) {} + virtual void node_was_evicted(node_type_t *node) { UNUSED(node); } public: /// Constructor @@ -185,7 +185,8 @@ class lru_cache_t { public: explicit iterator(lru_node_t *val) : node(val) {} void operator++() { node = lru_cache_t::get_previous(node); } - void operator++(int x) { node = lru_cache_t::get_previous(node); } + //WTF + //void operator++(int x) { node = lru_cache_t::get_previous(node); } bool operator==(const iterator &other) { return node == other.node; } bool operator!=(const iterator &other) { return !(*this == other); } node_type_t *operator*() { return static_cast(node); } diff --git a/src/pager.cpp b/src/pager.cpp index 44e189bc7..b6663a24b 100644 --- a/src/pager.cpp +++ b/src/pager.cpp @@ -86,6 +86,9 @@ static int print_max(const wcstring &str, highlight_spec_t color, int max, bool line_t pager_t::completion_print_item(const wcstring &prefix, const comp_t *c, size_t row, size_t column, size_t width, bool secondary, bool selected, page_rendering_t *rendering) const { + UNUSED(column); + UNUSED(row); + UNUSED(rendering); size_t comp_width = 0, desc_width = 0; size_t written = 0; line_t line_data; @@ -254,8 +257,7 @@ static void join_completions(comp_info_list_t *comps) { } /// Generate a list of comp_t structures from a list of completions. -static comp_info_list_t process_completions_into_infos(const completion_list_t &lst, - const wcstring &prefix) { +static comp_info_list_t process_completions_into_infos(const completion_list_t &lst) { const size_t lst_size = lst.size(); // Make the list of the correct size up-front. @@ -340,7 +342,7 @@ void pager_t::refilter_completions() { void pager_t::set_completions(const completion_list_t &raw_completions) { // Get completion infos out of it. - unfiltered_completion_infos = process_completions_into_infos(raw_completions, prefix); + unfiltered_completion_infos = process_completions_into_infos(raw_completions); // Maybe join them. if (prefix == L"-") join_completions(&unfiltered_completion_infos); diff --git a/src/parse_execution.cpp b/src/parse_execution.cpp index 5ee3a12d0..a4a87c99e 100644 --- a/src/parse_execution.cpp +++ b/src/parse_execution.cpp @@ -1076,6 +1076,7 @@ parse_execution_result_t parse_execution_context_t::populate_block_process( job_t *job, process_t *proc, const parse_node_t &statement_node) { // We handle block statements by creating INTERNAL_BLOCK_NODE, that will bounce back to us when // it's time to execute them. + UNUSED(job); assert(statement_node.type == symbol_block_statement || statement_node.type == symbol_if_statement || statement_node.type == symbol_switch_statement); @@ -1133,6 +1134,7 @@ parse_execution_result_t parse_execution_context_t::populate_job_process( parse_execution_result_t parse_execution_context_t::populate_job_from_job_node( job_t *j, const parse_node_t &job_node, const block_t *associated_block) { + UNUSED(associated_block); assert(job_node.type == symbol_job); // Tell the job what its command is. diff --git a/src/parse_productions.cpp b/src/parse_productions.cpp index a9da3b325..3fff5a2b1 100644 --- a/src/parse_productions.cpp +++ b/src/parse_productions.cpp @@ -80,6 +80,7 @@ RESOLVE(job_list) { RESOLVE_ONLY(job) = {symbol_statement, symbol_job_continuation, symbol_optional_background}; RESOLVE(job_continuation) { + UNUSED(out_tag); P empty = {}; P piped = {parse_token_type_pipe, symbol_statement, symbol_job_continuation}; switch (token1.type) { @@ -94,6 +95,7 @@ RESOLVE(job_continuation) { // A statement is a normal command, or an if / while / and etc. RESOLVE(statement) { + UNUSED(out_tag); P boolean = {symbol_boolean_statement}; P block = {symbol_block_statement}; P ifs = {symbol_if_statement}; diff --git a/src/postfork.cpp b/src/postfork.cpp index 1c246a975..5f15f9954 100644 --- a/src/postfork.cpp +++ b/src/postfork.cpp @@ -285,6 +285,7 @@ pid_t execute_fork(bool wait_for_threads_to_die) { bool fork_actions_make_spawn_properties(posix_spawnattr_t *attr, posix_spawn_file_actions_t *actions, job_t *j, process_t *p, const io_chain_t &io_chain) { + UNUSED(p); // Initialize the output. if (posix_spawnattr_init(attr) != 0) { return false; diff --git a/src/proc.cpp b/src/proc.cpp index 69a53b9c2..1cdaece4f 100644 --- a/src/proc.cpp +++ b/src/proc.cpp @@ -254,12 +254,12 @@ int job_signal(job_t *j, int signal) { int res = 0; if (j->pgid != my_pid) { - res = killpg(j->pgid, SIGHUP); + res = killpg(j->pgid, signal); } else { for (process_t *p = j->first_process; p; p = p->next) { if (!p->completed) { if (p->pid) { - if (kill(p->pid, SIGHUP)) { + if (kill(p->pid, signal)) { res = -1; break; } @@ -272,7 +272,7 @@ int job_signal(job_t *j, int signal) { } /// Store the status of the process pid that was returned by waitpid. -static void mark_process_status(const job_t *j, process_t *p, int status) { +static void mark_process_status(process_t *p, int status) { // debug( 0, L"Process %ls %ls", p->argv[0], WIFSTOPPED (status)?L"stopped":(WIFEXITED( status // )?L"exited":(WIFSIGNALED( status )?L"signaled to exit":L"BLARGH")) ); p->status = status; @@ -291,6 +291,7 @@ static void mark_process_status(const job_t *j, process_t *p, int status) { void job_mark_process_as_failed(const job_t *job, process_t *p) { // The given process failed to even lift off (e.g. posix_spawn failed) and so doesn't have a // valid pid. Mark it as dead. + UNUSED(job); for (process_t *cursor = p; cursor != NULL; cursor = cursor->next) { cursor->completed = 1; } @@ -310,7 +311,7 @@ static void handle_child_status(pid_t pid, int status) { process_t *prev = 0; for (p = j->first_process; p; p = p->next) { if (pid == p->pid) { - mark_process_status(j, p, status); + mark_process_status(p, status); if (p->completed && prev != 0) { if (!prev->completed && prev->pid) { kill(prev->pid, SIGPIPE); @@ -455,7 +456,10 @@ static int process_mark_finished_children(bool wants_await) { } /// This is called from a signal handler. The signal is always SIGCHLD. -void job_handle_signal(int signal, siginfo_t *info, void *con) { +void job_handle_signal(int signal, siginfo_t *info, void *context) { + UNUSED(signal); + UNUSED(info); + UNUSED(context); // This is the only place that this generation count is modified. It's OK if it overflows. s_sigchld_generation_count += 1; } diff --git a/src/reader.cpp b/src/reader.cpp index 2ba41732d..d044a1753 100644 --- a/src/reader.cpp +++ b/src/reader.cpp @@ -468,7 +468,7 @@ static void reader_kill(editable_line_t *el, size_t begin_idx, size_t length, in } // This is called from a signal handler! -void reader_handle_int(int sig) { +void reader_handle_sigint() { if (!is_interactive_read) { parser_t::skip_all_blocks(); } @@ -846,7 +846,10 @@ void reader_repaint_if_needed() { } } -static void reader_repaint_if_needed_one_arg(void *unused) { reader_repaint_if_needed(); } +static void reader_repaint_if_needed_one_arg(void *unused) { + UNUSED(unused); + reader_repaint_if_needed(); +} void reader_react_to_color_change() { if (!data) return; @@ -2003,7 +2006,13 @@ parser_test_error_bits_t reader_shell_test(const wchar_t *b) { /// Test if the given string contains error. Since this is the error detection for general purpose, /// there are no invalid strings, so this function always returns false. -static parser_test_error_bits_t default_test(const wchar_t *b) { return 0; } +/// +/// TODO: Possibly remove this. It is called from only only one place: reader_push().Since it always +/// returns a static result it's not clear why it's needed. +static parser_test_error_bits_t default_test(const wchar_t *b) { + UNUSED(b); + return 0; +} void reader_push(const wchar_t *name) { reader_data_t *n = new reader_data_t(); @@ -2149,6 +2158,7 @@ static void highlight_search(void) { } static void highlight_complete(background_highlight_context_t *ctx, int result) { + UNUSED(result); // ignored because of the indirect invocation via iothread_perform() ASSERT_IS_MAIN_THREAD(); if (ctx->string_to_highlight == data->command_line.text) { // The data hasn't changed, so swap in our colors. The colors may not have changed, so do diff --git a/src/reader.h b/src/reader.h index 61d757167..519aa2a10 100644 --- a/src/reader.h +++ b/src/reader.h @@ -192,7 +192,7 @@ void reader_set_exit_on_interrupt(bool flag); bool shell_is_exiting(); /// The readers interrupt signal handler. Cancels all currently running blocks. -void reader_handle_int(int signal); +void reader_handle_sigint(); /// This function returns true if fish is exiting by force, i.e. because stdin died. int reader_exit_forced(); diff --git a/src/screen.cpp b/src/screen.cpp index 093fd9989..88a97a2dd 100644 --- a/src/screen.cpp +++ b/src/screen.cpp @@ -528,6 +528,7 @@ static void s_move(screen_t *s, data_buffer_t *b, int new_x, int new_y) { /// Set the pen color for the terminal. static void s_set_color(screen_t *s, data_buffer_t *b, highlight_spec_t c) { + UNUSED(s); scoped_buffer_t scoped_buffer(b); unsigned int uc = (unsigned int)c; @@ -893,6 +894,7 @@ static screen_layout_t compute_layout(screen_t *s, size_t screen_width, const wcstring &left_prompt_str, const wcstring &right_prompt_str, const wcstring &commandline, const wcstring &autosuggestion_str, const int *indent) { + UNUSED(s); screen_layout_t result = {}; // Start by ensuring that the prompts themselves can fit. diff --git a/src/signal.cpp b/src/signal.cpp index 213b2ffb7..a20f51cc4 100644 --- a/src/signal.cpp +++ b/src/signal.cpp @@ -192,6 +192,8 @@ const wchar_t *signal_get_desc(int sig) { /// Standard signal handler. static void default_handler(int signal, siginfo_t *info, void *context) { + UNUSED(info); + UNUSED(context); if (event_is_signal_observed(signal)) { event_fire_signal(signal); } @@ -200,6 +202,8 @@ static void default_handler(int signal, siginfo_t *info, void *context) { #ifdef SIGWINCH /// Respond to a winch signal by checking the terminal size. static void handle_winch(int sig, siginfo_t *info, void *context) { + UNUSED(info); + UNUSED(context); common_handle_winch(sig); default_handler(sig, 0, 0); } @@ -208,6 +212,8 @@ static void handle_winch(int sig, siginfo_t *info, void *context) { /// Respond to a hup signal by exiting, unless it is caught by a shellscript function, in which case /// we do nothing. static void handle_hup(int sig, siginfo_t *info, void *context) { + UNUSED(info); + UNUSED(context); if (event_is_signal_observed(SIGHUP)) { default_handler(sig, 0, 0); } else { @@ -217,6 +223,9 @@ static void handle_hup(int sig, siginfo_t *info, void *context) { /// Handle sigterm. The only thing we do is restore the front process ID, then die. static void handle_term(int sig, siginfo_t *info, void *context) { + UNUSED(sig); + UNUSED(info); + UNUSED(context); restore_term_foreground_process_group(); signal(SIGTERM, SIG_DFL); raise(SIGTERM); @@ -225,7 +234,7 @@ static void handle_term(int sig, siginfo_t *info, void *context) { /// Interactive mode ^C handler. Respond to int signal by setting interrupted-flag and stopping all /// loops and conditionals. static void handle_int(int sig, siginfo_t *info, void *context) { - reader_handle_int(sig); + reader_handle_sigint(); default_handler(sig, info, context); } diff --git a/tests/history.err b/tests/history.err index 97f07762f..dcaf16dc2 100644 --- a/tests/history.err +++ b/tests/history.err @@ -2,15 +2,15 @@ history: Invalid combination of options, you cannot do both 'search' and 'merge' in the same invocation history: you cannot use any options with the clear command history: you cannot use any options with the merge command -history: save command expected 0 args, got 1 +history: save expected 0 args, got 1 history: you cannot use any options with the save command history: you cannot use any options with the clear command -history: merge command expected 0 args, got 1 -history: clear command expected 0 args, got 2 +history: merge expected 0 args, got 1 +history: clear expected 0 args, got 2 history: you cannot use any options with the clear command history: you cannot use any options with the merge command -history: save command expected 0 args, got 1 +history: save expected 0 args, got 1 history: you cannot use any options with the clear command history: you cannot use any options with the merge command @@ -18,7 +18,7 @@ history: Invalid combination of options, you cannot do both 'search' and 'merge' in the same invocation history: you cannot use any options with the save command history: you cannot use any options with the clear command -history: merge command expected 0 args, got 1 -history: clear command expected 0 args, got 2 +history: merge expected 0 args, got 1 +history: clear expected 0 args, got 2 history: you cannot use any options with the save command history: you cannot use any options with the merge command