systemctl: reorder cases in parse_argv() to match order in --help

Compatibility-only options (--fail, --irreversible, --ignore-dependencies,
--no-legend) are grouped at the end alongside the '.' / '?' error handlers.
The case 'P': … _fallthrough_; case 'p': pair is kept intact and placed at
-p's slot in --help, so -P sits immediately before -p in the source.

Co-developed-by: Claude Opus 4.7 <noreply@anthropic.com>

diff --git a/src/systemctl/systemctl.c b/src/systemctl/systemctl.c
index 632e54256cb8d0b37a7d7124378adc0482a070b3..799249fe42d132f411815dc9bb58199b9c1ad273 100644 (file)
--- a/src/systemctl/systemctl.c
+++ b/src/systemctl/systemctl.c
@@ -683,12 +683,55 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                 case ARG_VERSION:
                         return version();
 
+                case ARG_SYSTEM:
+                        arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
+                        break;
+
+                case ARG_USER:
+                        arg_runtime_scope = RUNTIME_SCOPE_USER;
+                        break;
+
+                case 'C':
+                        r = capsule_name_is_valid(optarg);
+                        if (r < 0)
+                                return log_error_errno(r, "Unable to validate capsule name '%s': %m", optarg);
+                        if (r == 0)
+                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid capsule name: %s", optarg);
+
+                        arg_host = optarg;
+                        arg_transport = BUS_TRANSPORT_CAPSULE;
+                        arg_runtime_scope = RUNTIME_SCOPE_USER;
+                        break;
+
+                case 'H':
+                        arg_transport = BUS_TRANSPORT_REMOTE;
+                        arg_host = optarg;
+                        break;
+
+                case 'M':
+                        r = parse_machine_argument(optarg, &arg_host, &arg_transport);
+                        if (r < 0)
+                                return r;
+                        break;
+
                 case 't':
                         r = parse_types_argument(optarg, &arg_types, &arg_states);
                         if (r <= 0)
                                 return r;
                         break;
 
+                case ARG_STATE:
+                        r = parse_states_argument(optarg, &arg_states);
+                        if (r <= 0)
+                                return r;
+                        break;
+
+                case ARG_FAILED:
+                        if (strv_extend(&arg_states, "failed") < 0)
+                                return log_oom();
+
+                        break;
+
                 case 'P':
                         SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
                         _fallthrough_;
@@ -708,13 +751,20 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_all = true;
                         break;
 
-                case ARG_REVERSE:
-                        arg_dependency = DEPENDENCY_REVERSE;
+                case 'l':
+                        arg_full = true;
                         break;
 
-                case ARG_AFTER:
-                        arg_dependency = DEPENDENCY_AFTER;
-                        arg_jobs_after = true;
+                case 'r':
+                        if (geteuid() != 0)
+                                return log_error_errno(SYNTHETIC_ERRNO(EPERM),
+                                                       "--recursive requires root privileges.");
+
+                        arg_recursive = true;
+                        break;
+
+                case ARG_REVERSE:
+                        arg_dependency = DEPENDENCY_REVERSE;
                         break;
 
                 case ARG_BEFORE:
@@ -722,107 +772,100 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_jobs_before = true;
                         break;
 
-                case ARG_SHOW_TYPES:
-                        arg_show_types = true;
+                case ARG_AFTER:
+                        arg_dependency = DEPENDENCY_AFTER;
+                        arg_jobs_after = true;
                         break;
 
-                case ARG_VALUE:
-                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
+                case ARG_WITH_DEPENDENCIES:
+                        arg_with_dependencies = true;
                         break;
 
                 case ARG_JOB_MODE:
                         _arg_job_mode = optarg;
                         break;
 
-                case ARG_FAIL:
-                        _arg_job_mode = "fail";
-                        break;
-
-                case ARG_IRREVERSIBLE:
-                        _arg_job_mode = "replace-irreversibly";
+                case 'T':
+                        arg_show_transaction = true;
                         break;
 
-                case ARG_IGNORE_DEPENDENCIES:
-                        _arg_job_mode = "ignore-dependencies";
+                case ARG_SHOW_TYPES:
+                        arg_show_types = true;
                         break;
 
-                case ARG_USER:
-                        arg_runtime_scope = RUNTIME_SCOPE_USER;
+                case ARG_VALUE:
+                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
                         break;
 
-                case ARG_SYSTEM:
-                        arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
+                case ARG_CHECK_INHIBITORS:
+                        r = parse_tristate_argument_with_auto("--check-inhibitors=", optarg, &arg_check_inhibitors);
+                        if (r < 0)
+                                return r;
                         break;
 
-                case ARG_GLOBAL:
-                        arg_runtime_scope = RUNTIME_SCOPE_GLOBAL;
+                case 'i':
+                        arg_check_inhibitors = 0;
                         break;
 
-                case 'C':
-                        r = capsule_name_is_valid(optarg);
-                        if (r < 0)
-                                return log_error_errno(r, "Unable to validate capsule name '%s': %m", optarg);
-                        if (r == 0)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid capsule name: %s", optarg);
-
-                        arg_host = optarg;
-                        arg_transport = BUS_TRANSPORT_CAPSULE;
-                        arg_runtime_scope = RUNTIME_SCOPE_USER;
+                case 's':
+                        r = parse_signal_argument(optarg, &arg_signal);
+                        if (r <= 0)
+                                return r;
                         break;
 
-                case ARG_WAIT:
-                        arg_wait = true;
+                case ARG_KILL_WHOM:
+                        arg_kill_whom = optarg;
                         break;
 
-                case ARG_NO_BLOCK:
-                        arg_no_block = true;
-                        break;
+                case ARG_KILL_VALUE: {
+                        unsigned u;
 
-                case ARG_NO_LEGEND:
-                        arg_legend = false;
-                        break;
+                        if (isempty(optarg)) {
+                                arg_kill_value_set = false;
+                                return 0;
+                        }
 
-                case ARG_LEGEND:
-                        r = parse_boolean_argument("--legend", optarg, NULL);
+                        /* First, try to parse unsigned, so that we can support the prefixes 0x, 0o, 0b */
+                        r = safe_atou_full(optarg, 0, &u);
                         if (r < 0)
-                                return r;
-                        arg_legend = r;
-                        break;
+                                /* If this didn't work, try as signed integer, without those prefixes */
+                                r = safe_atoi(optarg, &arg_kill_value);
+                        else if (u > INT_MAX)
+                                r = -ERANGE;
+                        else
+                                arg_kill_value = (int) u;
+                        if (r < 0)
+                                return log_error_errno(r, "Unable to parse signal queue value: %s", optarg);
 
-                case ARG_NO_PAGER:
-                        arg_pager_flags |= PAGER_DISABLE;
+                        arg_kill_value_set = true;
                         break;
+                }
 
-                case ARG_NO_WALL:
-                        arg_no_wall = true;
-                        break;
+                case ARG_KILL_SUBGROUP: {
+                        if (empty_or_root(optarg)) {
+                                arg_kill_subgroup = mfree(arg_kill_subgroup);
+                                break;
+                        }
 
-                case ARG_ROOT:
-                        r = parse_path_argument(optarg, false, &arg_root);
-                        if (r < 0)
-                                return r;
-                        break;
+                        _cleanup_free_ char *p = NULL;
+                        if (path_simplify_alloc(optarg, &p) < 0)
+                                return log_oom();
 
-                case ARG_IMAGE:
-                        r = parse_path_argument(optarg, false, &arg_image);
-                        if (r < 0)
-                                return r;
-                        break;
+                        if (!path_is_safe(p))
+                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Control group sub-path '%s' is not valid.", p);
 
-                case ARG_IMAGE_POLICY:
-                        r = parse_image_policy_argument(optarg, &arg_image_policy);
-                        if (r < 0)
-                                return r;
+                        free_and_replace(arg_kill_subgroup, p);
                         break;
+                }
 
-                case 'l':
-                        arg_full = true;
+                case ARG_WHAT:
+                        r = parse_what_argument(optarg, &arg_clean_what);
+                        if (r <= 0)
+                                return r;
                         break;
 
-                case ARG_FAILED:
-                        if (strv_extend(&arg_states, "failed") < 0)
-                                return log_oom();
-
+                case ARG_NOW:
+                        arg_now = true;
                         break;
 
                 case ARG_DRY_RUN:
@@ -841,65 +884,85 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_verbose = true;
                         break;
 
-                case 'f':
-                        arg_force++;
+                case ARG_NO_WARN:
+                        arg_no_warn = true;
                         break;
 
-                case ARG_NO_RELOAD:
-                        arg_no_reload = true;
+                case ARG_WAIT:
+                        arg_wait = true;
                         break;
 
-                case ARG_KILL_WHOM:
-                        arg_kill_whom = optarg;
+                case ARG_NO_BLOCK:
+                        arg_no_block = true;
                         break;
 
-                case ARG_KILL_VALUE: {
-                        unsigned u;
-
-                        if (isempty(optarg)) {
-                                arg_kill_value_set = false;
-                                return 0;
-                        }
+                case ARG_NO_WALL:
+                        arg_no_wall = true;
+                        break;
 
-                        /* First, try to parse unsigned, so that we can support the prefixes 0x, 0o, 0b */
-                        r = safe_atou_full(optarg, 0, &u);
-                        if (r < 0)
-                                /* If this didn't work, try as signed integer, without those prefixes */
-                                r = safe_atoi(optarg, &arg_kill_value);
-                        else if (u > INT_MAX)
-                                r = -ERANGE;
-                        else
-                                arg_kill_value = (int) u;
-                        if (r < 0)
-                                return log_error_errno(r, "Unable to parse signal queue value: %s", optarg);
+                case ARG_MESSAGE:
+                        if (strv_extend(&arg_wall, optarg) < 0)
+                                return log_oom();
+                        break;
 
-                        arg_kill_value_set = true;
+                case ARG_NO_RELOAD:
+                        arg_no_reload = true;
                         break;
-                }
 
-                case 's':
-                        r = parse_signal_argument(optarg, &arg_signal);
-                        if (r <= 0)
+                case ARG_LEGEND:
+                        r = parse_boolean_argument("--legend", optarg, NULL);
+                        if (r < 0)
                                 return r;
+                        arg_legend = r;
+                        break;
+
+                case ARG_NO_PAGER:
+                        arg_pager_flags |= PAGER_DISABLE;
                         break;
 
                 case ARG_NO_ASK_PASSWORD:
                         arg_ask_password = false;
                         break;
 
-                case 'H':
-                        arg_transport = BUS_TRANSPORT_REMOTE;
-                        arg_host = optarg;
+                case ARG_GLOBAL:
+                        arg_runtime_scope = RUNTIME_SCOPE_GLOBAL;
                         break;
 
-                case 'M':
-                        r = parse_machine_argument(optarg, &arg_host, &arg_transport);
+                case ARG_RUNTIME:
+                        arg_runtime = true;
+                        break;
+
+                case 'f':
+                        arg_force++;
+                        break;
+
+                case ARG_PRESET_MODE:
+                        if (streq(optarg, "help"))
+                                return DUMP_STRING_TABLE(unit_file_preset_mode, UnitFilePresetMode, _UNIT_FILE_PRESET_MODE_MAX);
+
+                        arg_preset_mode = unit_file_preset_mode_from_string(optarg);
+                        if (arg_preset_mode < 0)
+                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+                                                       "Failed to parse preset mode: %s.", optarg);
+
+                        break;
+
+                case ARG_ROOT:
+                        r = parse_path_argument(optarg, false, &arg_root);
                         if (r < 0)
                                 return r;
                         break;
 
-                case ARG_RUNTIME:
-                        arg_runtime = true;
+                case ARG_IMAGE:
+                        r = parse_path_argument(optarg, false, &arg_image);
+                        if (r < 0)
+                                return r;
+                        break;
+
+                case ARG_IMAGE_POLICY:
+                        r = parse_image_policy_argument(optarg, &arg_image_policy);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case 'n':
@@ -925,20 +988,6 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         }
                         break;
 
-                case 'i':
-                        arg_check_inhibitors = 0;
-                        break;
-
-                case ARG_CHECK_INHIBITORS:
-                        r = parse_tristate_argument_with_auto("--check-inhibitors=", optarg, &arg_check_inhibitors);
-                        if (r < 0)
-                                return r;
-                        break;
-
-                case ARG_PLAIN:
-                        arg_plain = true;
-                        break;
-
                 case ARG_FIRMWARE_SETUP:
                         arg_firmware_setup = true;
                         break;
@@ -964,54 +1013,6 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_boot_loader_entry = empty_to_null(optarg);
                         break;
 
-                case ARG_STATE:
-                        r = parse_states_argument(optarg, &arg_states);
-                        if (r <= 0)
-                                return r;
-                        break;
-
-                case 'r':
-                        if (geteuid() != 0)
-                                return log_error_errno(SYNTHETIC_ERRNO(EPERM),
-                                                       "--recursive requires root privileges.");
-
-                        arg_recursive = true;
-                        break;
-
-                case ARG_PRESET_MODE:
-                        if (streq(optarg, "help"))
-                                return DUMP_STRING_TABLE(unit_file_preset_mode, UnitFilePresetMode, _UNIT_FILE_PRESET_MODE_MAX);
-
-                        arg_preset_mode = unit_file_preset_mode_from_string(optarg);
-                        if (arg_preset_mode < 0)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Failed to parse preset mode: %s.", optarg);
-
-                        break;
-
-                case ARG_NOW:
-                        arg_now = true;
-                        break;
-
-                case ARG_MESSAGE:
-                        if (strv_extend(&arg_wall, optarg) < 0)
-                                return log_oom();
-                        break;
-
-                case 'T':
-                        arg_show_transaction = true;
-                        break;
-
-                case ARG_WITH_DEPENDENCIES:
-                        arg_with_dependencies = true;
-                        break;
-
-                case ARG_WHAT:
-                        r = parse_what_argument(optarg, &arg_clean_what);
-                        if (r <= 0)
-                                return r;
-                        break;
-
                 case ARG_REBOOT_ARG:
                         arg_reboot_argument = optarg;
                         break;
@@ -1031,6 +1032,10 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                                 return r;
                         break;
 
+                case ARG_PLAIN:
+                        arg_plain = true;
+                        break;
+
                 case ARG_TIMESTAMP_STYLE:
                         if (streq(optarg, "help"))
                                 return DUMP_STRING_TABLE(timestamp_style, TimestampStyle, _TIMESTAMP_STYLE_MAX);
@@ -1054,10 +1059,6 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_marked = true;
                         break;
 
-                case ARG_NO_WARN:
-                        arg_no_warn = true;
-                        break;
-
                 case ARG_DROP_IN:
                         arg_drop_in = optarg;
                         break;
@@ -1092,22 +1093,22 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_stdin = true;
                         break;
 
-                case ARG_KILL_SUBGROUP: {
-                        if (empty_or_root(optarg)) {
-                                arg_kill_subgroup = mfree(arg_kill_subgroup);
-                                break;
-                        }
+                /* Compatibility-only options, not shown in --help. */
+                case ARG_FAIL:
+                        _arg_job_mode = "fail";
+                        break;
 
-                        _cleanup_free_ char *p = NULL;
-                        if (path_simplify_alloc(optarg, &p) < 0)
-                                return log_oom();
+                case ARG_IRREVERSIBLE:
+                        _arg_job_mode = "replace-irreversibly";
+                        break;
 
-                        if (!path_is_safe(p))
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Control group sub-path '%s' is not valid.", p);
+                case ARG_IGNORE_DEPENDENCIES:
+                        _arg_job_mode = "ignore-dependencies";
+                        break;
 
-                        free_and_replace(arg_kill_subgroup, p);
+                case ARG_NO_LEGEND:
+                        arg_legend = false;
                         break;
-                }
 
                 case '.':
                         /* Output an error mimicking getopt, and print a hint afterwards */