. in `cmd_foo(int argc, const char **argv, const char *prefix)`
   call
 
-       argc = parse_options(argc, argv, builtin_foo_options, builtin_foo_usage, flags);
+       argc = parse_options(argc, argv, prefix, builtin_foo_options, builtin_foo_usage, flags);
 +
 `parse_options()` will filter out the processed options of `argv[]` and leave the
 non-option arguments in `argv[]`.
 `argc` is updated appropriately because of the assignment.
 +
-You can also pass NULL instead of a usage array as fourth parameter of
+You can also pass NULL instead of a usage array as the fifth parameter of
 parse_options(), to avoid displaying a help screen with usage info and
 option list.  This should only be done if necessary, e.g. to implement
 a limited parser for only a subset of the options that needs to be run
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, opts, archive_usage, 0);
+       argc = parse_options(argc, argv, NULL, opts, archive_usage, 0);
 
        if (remote)
                die("Unexpected option --remote");
 
        int add_new_files;
        int require_pathspec;
 
-       argc = parse_options(argc, argv, builtin_add_options,
+       argc = parse_options(argc, argv, prefix, builtin_add_options,
                          builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
        if (patch_interactive)
                add_interactive = 1;
 
        if (apply_default_whitespace)
                parse_whitespace_option(apply_default_whitespace);
 
-       argc = parse_options(argc, argv, builtin_apply_options,
+       argc = parse_options(argc, argv, prefix, builtin_apply_options,
                        apply_usage, 0);
        fake_ancestor = parse_options_fix_filename(prefix, fake_ancestor);
        if (fake_ancestor)
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, local_opts, NULL, PARSE_OPT_KEEP_ALL);
+       argc = parse_options(argc, argv, prefix, local_opts, NULL,
+                            PARSE_OPT_KEEP_ALL);
 
        if (output)
                create_output_file(output);
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, options, git_bisect_helper_usage, 0);
+       argc = parse_options(argc, argv, prefix, options,
+                            git_bisect_helper_usage, 0);
 
        if (!next_all)
                usage_with_options(git_bisect_helper_usage, options);
 
        save_commit_buffer = 0;
        dashdash_pos = 0;
 
-       parse_options_start(&ctx, argc, argv, PARSE_OPT_KEEP_DASHDASH |
+       parse_options_start(&ctx, argc, argv, prefix, PARSE_OPT_KEEP_DASHDASH |
                            PARSE_OPT_KEEP_ARGV0);
        for (;;) {
                switch (parse_options_step(&ctx, options, blame_opt_usage)) {
 
        }
        hashcpy(merge_filter_ref, head_sha1);
 
-       argc = parse_options(argc, argv, options, builtin_branch_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
+                            0);
        if (!!delete + !!rename + !!force_create > 1)
                usage_with_options(builtin_branch_usage, options);
 
 
        if (argc != 3 && argc != 2)
                usage_with_options(cat_file_usage, options);
 
-       argc = parse_options(argc, argv, options, cat_file_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, cat_file_usage, 0);
 
        if (opt) {
                if (argc == 1)
 
        int cnt, i, doubledash;
        const char *errstr = NULL;
 
-       argc = parse_options(argc, argv, check_attr_options, check_attr_usage,
-               PARSE_OPT_KEEP_DASHDASH);
+       argc = parse_options(argc, argv, prefix, check_attr_options,
+                            check_attr_usage, PARSE_OPT_KEEP_DASHDASH);
        if (!argc)
                usage_with_options(check_attr_usage, check_attr_options);
 
 
                die("invalid cache");
        }
 
-       argc = parse_options(argc, argv, builtin_checkout_index_options,
+       argc = parse_options(argc, argv, prefix, builtin_checkout_index_options,
                        builtin_checkout_index_usage, 0);
        state.force = force;
        state.quiet = quiet;
 
 
        opts.track = BRANCH_TRACK_UNSPECIFIED;
 
-       argc = parse_options(argc, argv, options, checkout_usage,
+       argc = parse_options(argc, argv, prefix, options, checkout_usage,
                             PARSE_OPT_KEEP_DASHDASH);
 
        /* --track without -b should DWIM */
 
        else
                config_set = 1;
 
-       argc = parse_options(argc, argv, options, builtin_clean_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, builtin_clean_usage,
+                            0);
 
        memset(&dir, 0, sizeof(dir));
        if (ignored_only)
 
 
        junk_pid = getpid();
 
-       argc = parse_options(argc, argv, builtin_clone_options,
+       argc = parse_options(argc, argv, prefix, builtin_clone_options,
                             builtin_clone_usage, 0);
 
        if (argc == 0)
 
 {
        int f = 0;
 
-       argc = parse_options(argc, argv, builtin_commit_options, usage, 0);
+       argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
+                            0);
        logfile = parse_options_fix_filename(prefix, logfile);
        if (logfile)
                logfile = xstrdup(logfile);
 
 
        config_exclusive_filename = getenv(CONFIG_ENVIRONMENT);
 
-       argc = parse_options(argc, argv, builtin_config_options, builtin_config_usage,
+       argc = parse_options(argc, argv, prefix, builtin_config_options,
+                            builtin_config_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
 
        if (use_global_config + use_system_config + !!given_config_file > 1) {
 
                OPT_END(),
        };
 
-       argc = parse_options(argc, argv, opts, count_objects_usage, 0);
+       argc = parse_options(argc, argv, prefix, opts, count_objects_usage, 0);
        /* we do not take arguments other than flags for now */
        if (argc)
                usage_with_options(count_objects_usage, opts);
 
                OPT_END(),
        };
 
-       argc = parse_options(argc, argv, options, describe_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, describe_usage, 0);
        if (max_candidates < 0)
                max_candidates = 0;
        else if (max_candidates > MAX_TAGS)
 
 
        init_revisions(&revs, prefix);
        argc = setup_revisions(argc, argv, &revs, NULL);
-       argc = parse_options(argc, argv, options, fast_export_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, fast_export_usage, 0);
        if (argc > 1)
                usage_with_options (fast_export_usage, options);
 
 
        for (i = 1; i < argc; i++)
                strbuf_addf(&default_rla, " %s", argv[i]);
 
-       argc = parse_options(argc, argv,
+       argc = parse_options(argc, argv, prefix,
                             builtin_fetch_options, builtin_fetch_usage, 0);
 
        if (argc == 0)
 
        int ret;
 
        git_config(fmt_merge_msg_config, NULL);
-       argc = parse_options(argc, argv, options, fmt_merge_msg_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, fmt_merge_msg_usage,
+                            0);
        if (argc > 0)
                usage_with_options(fmt_merge_msg_usage, options);
        inpath = parse_options_fix_filename(prefix, inpath);
 
                OPT_END(),
        };
 
-       parse_options(argc, argv, opts, for_each_ref_usage, 0);
+       parse_options(argc, argv, prefix, opts, for_each_ref_usage, 0);
        if (maxcount < 0) {
                error("invalid --count argument: `%d'", maxcount);
                usage_with_options(for_each_ref_usage, opts);
 
 
        errors_found = 0;
 
-       argc = parse_options(argc, argv, fsck_opts, fsck_usage, 0);
+       argc = parse_options(argc, argv, prefix, fsck_opts, fsck_usage, 0);
        if (write_lost_and_found) {
                check_full = 1;
                include_reflogs = 0;
 
        if (pack_refs < 0)
                pack_refs = !is_bare_repository();
 
-       argc = parse_options(argc, argv, builtin_gc_options, builtin_gc_usage, 0);
+       argc = parse_options(argc, argv, prefix, builtin_gc_options,
+                            builtin_gc_usage, 0);
        if (argc > 0)
                usage_with_options(builtin_gc_usage, builtin_gc_options);
 
 
         * unrecognized non option is the beginning of the refs list
         * that continues up to the -- (if exists), and then paths.
         */
-       argc = parse_options(argc, argv, options, grep_usage,
+       argc = parse_options(argc, argv, prefix, options, grep_usage,
                             PARSE_OPT_KEEP_DASHDASH |
                             PARSE_OPT_STOP_AT_NON_OPTION |
                             PARSE_OPT_NO_INTERNAL_HELP);
 
        setup_git_directory_gently(&nongit);
        git_config(git_help_config, NULL);
 
-       argc = parse_options(argc, argv, builtin_help_options,
+       argc = parse_options(argc, argv, prefix, builtin_help_options,
                        builtin_help_usage, 0);
 
        if (show_all) {
 
         * like "git format-patch -o a123 HEAD^.." may fail; a123 is
         * possibly a valid SHA1.
         */
-       argc = parse_options(argc, argv, builtin_format_patch_options,
+       argc = parse_options(argc, argv, prefix, builtin_format_patch_options,
                             builtin_format_patch_usage,
                             PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN);
 
 
                prefix_offset = strlen(prefix);
        git_config(git_default_config, NULL);
 
-       argc = parse_options(argc, argv, builtin_ls_files_options,
+       argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
                        ls_files_usage, 0);
        if (show_tag || show_valid_bit) {
                tag_cached = "H ";
 
        };
 
        git_config(git_default_config, NULL);
-       argc = parse_options(argc, argv, options, merge_base_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0);
        if (argc < 2)
                usage_with_options(merge_base_usage, options);
        rev = xmalloc(argc * sizeof(*rev));
 
                        merge_style = git_xmerge_style;
        }
 
-       argc = parse_options(argc, argv, options, merge_file_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, merge_file_usage, 0);
        if (argc != 3)
                usage_with_options(merge_file_usage, options);
        if (quiet) {
 
                argv = xrealloc(argv, sizeof(*argv) * (argc + 2));
                memmove(argv + 1, argv, sizeof(*argv) * (argc + 1));
                argc++;
-               parse_options(argc, argv, builtin_merge_options,
+               parse_options(argc, argv, NULL, builtin_merge_options,
                              builtin_merge_usage, 0);
                free(buf);
        }
        if (diff_use_color_default == -1)
                diff_use_color_default = git_use_color_default;
 
-       argc = parse_options(argc, argv, builtin_merge_options,
+       argc = parse_options(argc, argv, prefix, builtin_merge_options,
                        builtin_merge_usage, 0);
        if (verbosity < 0)
                show_diffstat = 0;
 
                OPT_END()
        };
 
-       ac = parse_options(ac, av, option, mktree_usage, 0);
+       ac = parse_options(ac, av, prefix, option, mktree_usage, 0);
 
        while (!got_eof) {
                while (1) {
 
        if (read_cache() < 0)
                die("index file corrupt");
 
-       argc = parse_options(argc, argv, builtin_mv_options, builtin_mv_usage, 0);
+       argc = parse_options(argc, argv, prefix, builtin_mv_options,
+                            builtin_mv_usage, 0);
        if (--argc < 1)
                usage_with_options(builtin_mv_usage, builtin_mv_options);
 
 
        };
 
        git_config(git_default_config, NULL);
-       argc = parse_options(argc, argv, opts, name_rev_usage, 0);
+       argc = parse_options(argc, argv, prefix, opts, name_rev_usage, 0);
        if (!!all + !!transform_stdin + !!argc > 1) {
                error("Specify either a list, or --all, not both!");
                usage_with_options(name_rev_usage, opts);
 
                OPT_BIT(0, "prune", &flags, "prune loose refs (default)", PACK_REFS_PRUNE),
                OPT_END(),
        };
-       if (parse_options(argc, argv, opts, pack_refs_usage, 0))
+       if (parse_options(argc, argv, prefix, opts, pack_refs_usage, 0))
                usage_with_options(pack_refs_usage, opts);
        return pack_refs(flags);
 }
 
        save_commit_buffer = 0;
        init_revisions(&revs, prefix);
 
-       argc = parse_options(argc, argv, options, prune_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, prune_usage, 0);
        while (argc--) {
                unsigned char sha1[20];
                const char *name = *argv++;
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, options, push_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 
        if (tags)
                add_refspec("refs/tags/*");
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
+       argc = parse_options(argc, argv, NULL, options, builtin_remote_usage,
+                            0);
 
        if (argc < 2)
                usage_with_options(builtin_remote_usage, options);
        struct string_list info_list = { NULL, 0, 0, 0 };
        struct show_info info;
 
-       argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
+       argc = parse_options(argc, argv, NULL, options, builtin_remote_usage,
+                            0);
 
        if (argc < 1)
                return show_all();
                            "delete refs/remotes/<name>/HEAD"),
                OPT_END()
        };
-       argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
+       argc = parse_options(argc, argv, NULL, options, builtin_remote_usage,
+                            0);
        if (argc)
                strbuf_addf(&buf, "refs/remotes/%s/HEAD", argv[0]);
 
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
+       argc = parse_options(argc, argv, NULL, options, builtin_remote_usage,
+                            0);
 
        if (argc < 1)
                usage_with_options(builtin_remote_usage, options);
                OPT_END()
        };
 
-       argc = parse_options(argc, argv, options, builtin_remote_usage,
+       argc = parse_options(argc, argv, NULL, options, builtin_remote_usage,
                             PARSE_OPT_KEEP_ARGV0);
        if (argc < 2) {
                argc = 2;
        };
        int result;
 
-       argc = parse_options(argc, argv, options, builtin_remote_usage,
+       argc = parse_options(argc, argv, prefix, options, builtin_remote_usage,
                PARSE_OPT_STOP_AT_NON_OPTION);
 
        if (argc < 1)
 
 
        git_config(git_default_config, NULL);
 
-       argc = parse_options(argc, argv, options, git_reset_usage,
+       argc = parse_options(argc, argv, prefix, options, git_reset_usage,
                                                PARSE_OPT_KEEP_DASHDASH);
        reflog_action = args_to_str(argv);
        setenv("GIT_REFLOG_ACTION", reflog_action, 0);
 
        int onb = 0, osz = 0, unb = 0, usz = 0;
 
        strbuf_addstr(&parsed, "set --");
-       argc = parse_options(argc, argv, parseopt_opts, parseopt_usage,
+       argc = parse_options(argc, argv, prefix, parseopt_opts, parseopt_usage,
                             PARSE_OPT_KEEP_DASHDASH);
        if (argc < 1 || strcmp(argv[0], "--"))
                usage_with_options(parseopt_usage, parseopt_opts);
        /* put an OPT_END() */
        ALLOC_GROW(opts, onb + 1, osz);
        memset(opts + onb, 0, sizeof(opts[onb]));
-       argc = parse_options(argc, argv, opts, usage,
+       argc = parse_options(argc, argv, prefix, opts, usage,
                             keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0);
 
        strbuf_addf(&parsed, " --");
 
                OPT_END(),
        };
 
-       if (parse_options(argc, argv, options, usage_str, 0) != 1)
+       if (parse_options(argc, argv, NULL, options, usage_str, 0) != 1)
                usage_with_options(usage_str, options);
        arg = argv[0];
 
 
 
        git_config(git_default_config, NULL);
 
-       argc = parse_options(argc, argv, builtin_rm_options, builtin_rm_usage, 0);
+       argc = parse_options(argc, argv, prefix, builtin_rm_options,
+                            builtin_rm_usage, 0);
        if (!argc)
                usage_with_options(builtin_rm_usage, builtin_rm_options);
 
 
        git_config(git_default_config, NULL);
        shortlog_init(&log);
        init_revisions(&rev, prefix);
-       parse_options_start(&ctx, argc, argv, PARSE_OPT_KEEP_DASHDASH |
+       parse_options_start(&ctx, argc, argv, prefix, PARSE_OPT_KEEP_DASHDASH |
                            PARSE_OPT_KEEP_ARGV0);
 
        for (;;) {
 
                av = default_arg - 1; /* ick; we would not address av[0] */
        }
 
-       ac = parse_options(ac, av, builtin_show_branch_options,
+       ac = parse_options(ac, av, prefix, builtin_show_branch_options,
                           show_branch_usage, PARSE_OPT_STOP_AT_NON_OPTION);
        if (all_heads)
                all_remotes = 1;
 
        };
 
        git_config(git_default_config, NULL);
-       argc = parse_options(argc, argv, options, git_symbolic_ref_usage, 0);
+       argc = parse_options(argc, argv, prefix, options,
+                            git_symbolic_ref_usage, 0);
        if (msg &&!*msg)
                die("Refusing to perform update with empty message");
        switch (argc) {
 
 
        git_config(git_tag_config, NULL);
 
-       argc = parse_options(argc, argv, options, git_tag_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, git_tag_usage, 0);
        msgfile = parse_options_fix_filename(prefix, msgfile);
 
        if (keyid) {
 
        };
 
        git_config(git_default_config, NULL);
-       argc = parse_options(argc, argv, options, git_update_ref_usage, 0);
+       argc = parse_options(argc, argv, prefix, options, git_update_ref_usage,
+                            0);
        if (msg && !*msg)
                die("Refusing to perform update with empty message.");
 
 
 
        git_extract_argv0_path(argv[0]);
 
-       argc = parse_options(argc, argv, hash_object_options, hash_object_usage, 0);
+       argc = parse_options(argc, argv, NULL, hash_object_options,
+                            hash_object_usage, 0);
 
        if (write_object) {
                prefix = setup_git_directory();
 
 }
 
 void parse_options_start(struct parse_opt_ctx_t *ctx,
-                        int argc, const char **argv, int flags)
+                        int argc, const char **argv, const char *prefix,
+                        int flags)
 {
        memset(ctx, 0, sizeof(*ctx));
        ctx->argc = argc - 1;
        ctx->argv = argv + 1;
        ctx->out  = argv;
+       ctx->prefix = prefix;
        ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
        ctx->flags = flags;
        if ((flags & PARSE_OPT_KEEP_UNKNOWN) &&
        return ctx->cpidx + ctx->argc;
 }
 
-int parse_options(int argc, const char **argv, const struct option *options,
-                 const char * const usagestr[], int flags)
+int parse_options(int argc, const char **argv, const char *prefix,
+                 const struct option *options, const char * const usagestr[],
+                 int flags)
 {
        struct parse_opt_ctx_t ctx;
 
-       parse_options_start(&ctx, argc, argv, flags);
+       parse_options_start(&ctx, argc, argv, prefix, flags);
        switch (parse_options_step(&ctx, options, usagestr)) {
        case PARSE_OPT_HELP:
                exit(129);
 
  * non-option arguments in argv[].
  * Returns the number of arguments left in argv[].
  */
-extern int parse_options(int argc, const char **argv,
+extern int parse_options(int argc, const char **argv, const char *prefix,
                          const struct option *options,
                          const char * const usagestr[], int flags);
 
        int argc, cpidx;
        const char *opt;
        int flags;
+       const char *prefix;
 };
 
 extern int parse_options_usage(const char * const *usagestr,
                               const struct option *opts);
 
 extern void parse_options_start(struct parse_opt_ctx_t *ctx,
-                               int argc, const char **argv, int flags);
+                               int argc, const char **argv, const char *prefix,
+                               int flags);
 
 extern int parse_options_step(struct parse_opt_ctx_t *ctx,
                              const struct option *options,
 
        };
        int i;
 
-       argc = parse_options(argc, argv, options, usage, 0);
+       argc = parse_options(argc, argv, NULL, options, usage, 0);
 
        printf("boolean: %d\n", boolean);
        printf("integer: %u\n", integer);