help.c

   1 #include "git-compat-util.h"
   2 #include "alloc.h"
   3 #include "config.h"
   4 #include "builtin.h"
   5 #include "exec-cmd.h"
   6 #include "run-command.h"
   7 #include "levenshtein.h"
   8 #include "gettext.h"
   9 #include "help.h"
  10 #include "command-list.h"
  11 #include "string-list.h"
  12 #include "column.h"
  13 #include "version.h"
  14 #include "refs.h"
  15 #include "parse-options.h"
  16 #include "prompt.h"
  17 #include "fsmonitor-ipc.h"
  18
  19 struct category_description {
  20         uint32_t category;
  21         const char *desc;
  22 };
  23 static uint32_t common_mask =
  24         CAT_init | CAT_worktree | CAT_info |
  25         CAT_history | CAT_remote;
  26 static struct category_description common_categories[] = {
  27         { CAT_init, N_("start a working area (see also: git help tutorial)") },
  28         { CAT_worktree, N_("work on the current change (see also: git help everyday)") },
  29         { CAT_info, N_("examine the history and state (see also: git help revisions)") },
  30         { CAT_history, N_("grow, mark and tweak your common history") },
  31         { CAT_remote, N_("collaborate (see also: git help workflows)") },
  32         { 0, NULL }
  33 };
  34 static struct category_description main_categories[] = {
  35         { CAT_mainporcelain, N_("Main Porcelain Commands") },
  36         { CAT_ancillarymanipulators, N_("Ancillary Commands / Manipulators") },
  37         { CAT_ancillaryinterrogators, N_("Ancillary Commands / Interrogators") },
  38         { CAT_foreignscminterface, N_("Interacting with Others") },
  39         { CAT_plumbingmanipulators, N_("Low-level Commands / Manipulators") },
  40         { CAT_plumbinginterrogators, N_("Low-level Commands / Interrogators") },
  41         { CAT_synchingrepositories, N_("Low-level Commands / Syncing Repositories") },
  42         { CAT_purehelpers, N_("Low-level Commands / Internal Helpers") },
  43         { CAT_userinterfaces, N_("User-facing repository, command and file interfaces") },
  44         { CAT_developerinterfaces, N_("Developer-facing file formats, protocols and other interfaces") },
  45         { 0, NULL }
  46 };
  47
  48 static const char *drop_prefix(const char *name, uint32_t category)
  49 {
  50         const char *new_name;
  51         const char *prefix;
  52
  53         switch (category) {
  54         case CAT_guide:
  55         case CAT_userinterfaces:
  56         case CAT_developerinterfaces:
  57                 prefix = "git";
  58                 break;
  59         default:
  60                 prefix = "git-";
  61                 break;
  62         }
  63         if (skip_prefix(name, prefix, &new_name))
  64                 return new_name;
  65
  66         return name;
  67 }
  68
  69 static void extract_cmds(struct cmdname_help **p_cmds, uint32_t mask)
  70 {
  71         int i, nr = 0;
  72         struct cmdname_help *cmds;
  73
  74         if (ARRAY_SIZE(command_list) == 0)
  75                 BUG("empty command_list[] is a sign of broken generate-cmdlist.sh");
  76
  77         ALLOC_ARRAY(cmds, ARRAY_SIZE(command_list) + 1);
  78
  79         for (i = 0; i < ARRAY_SIZE(command_list); i++) {
  80                 const struct cmdname_help *cmd = command_list + i;
  81
  82                 if (!(cmd->category & mask))
  83                         continue;
  84
  85                 cmds[nr] = *cmd;
  86                 cmds[nr].name = drop_prefix(cmd->name, cmd->category);
  87
  88                 nr++;
  89         }
  90         cmds[nr].name = NULL;
  91         *p_cmds = cmds;
  92 }
  93
  94 static void print_command_list(const struct cmdname_help *cmds,
  95                                uint32_t mask, int longest)
  96 {
  97         int i;
  98
  99         for (i = 0; cmds[i].name; i++) {
 100                 if (cmds[i].category & mask) {
 101                         size_t len = strlen(cmds[i].name);
 102                         printf("   %s   ", cmds[i].name);
 103                         if (longest > len)
 104                                 mput_char(' ', longest - len);
 105                         puts(_(cmds[i].help));
 106                 }
 107         }
 108 }
 109
 110 static int cmd_name_cmp(const void *elem1, const void *elem2)
 111 {
 112         const struct cmdname_help *e1 = elem1;
 113         const struct cmdname_help *e2 = elem2;
 114
 115         return strcmp(e1->name, e2->name);
 116 }
 117
 118 static void print_cmd_by_category(const struct category_description *catdesc,
 119                                   int *longest_p)
 120 {
 121         struct cmdname_help *cmds;
 122         int longest = 0;
 123         int i, nr = 0;
 124         uint32_t mask = 0;
 125
 126         for (i = 0; catdesc[i].desc; i++)
 127                 mask |= catdesc[i].category;
 128
 129         extract_cmds(&cmds, mask);
 130
 131         for (i = 0; cmds[i].name; i++, nr++) {
 132                 if (longest < strlen(cmds[i].name))
 133                         longest = strlen(cmds[i].name);
 134         }
 135         QSORT(cmds, nr, cmd_name_cmp);
 136
 137         for (i = 0; catdesc[i].desc; i++) {
 138                 uint32_t mask = catdesc[i].category;
 139                 const char *desc = catdesc[i].desc;
 140
 141                 if (i)
 142                         putchar('\n');
 143                 puts(_(desc));
 144                 print_command_list(cmds, mask, longest);
 145         }
 146         free(cmds);
 147         if (longest_p)
 148                 *longest_p = longest;
 149 }
 150
 151 void add_cmdname(struct cmdnames *cmds, const char *name, int len)
 152 {
 153         struct cmdname *ent;
 154         FLEX_ALLOC_MEM(ent, name, name, len);
 155         ent->len = len;
 156
 157         ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);
 158         cmds->names[cmds->cnt++] = ent;
 159 }
 160
 161 static void clean_cmdnames(struct cmdnames *cmds)
 162 {
 163         int i;
 164         for (i = 0; i < cmds->cnt; ++i)
 165                 free(cmds->names[i]);
 166         free(cmds->names);
 167         cmds->cnt = 0;
 168         cmds->alloc = 0;
 169 }
 170
 171 static int cmdname_compare(const void *a_, const void *b_)
 172 {
 173         struct cmdname *a = *(struct cmdname **)a_;
 174         struct cmdname *b = *(struct cmdname **)b_;
 175         return strcmp(a->name, b->name);
 176 }
 177
 178 static void uniq(struct cmdnames *cmds)
 179 {
 180         int i, j;
 181
 182         if (!cmds->cnt)
 183                 return;
 184
 185         for (i = j = 1; i < cmds->cnt; i++) {
 186                 if (!strcmp(cmds->names[i]->name, cmds->names[j-1]->name))
 187                         free(cmds->names[i]);
 188                 else
 189                         cmds->names[j++] = cmds->names[i];
 190         }
 191
 192         cmds->cnt = j;
 193 }
 194
 195 void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
 196 {
 197         int ci, cj, ei;
 198         int cmp;
 199
 200         ci = cj = ei = 0;
 201         while (ci < cmds->cnt && ei < excludes->cnt) {
 202                 cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);
 203                 if (cmp < 0)
 204                         cmds->names[cj++] = cmds->names[ci++];
 205                 else if (cmp == 0) {
 206                         ei++;
 207                         free(cmds->names[ci++]);
 208                 } else if (cmp > 0)
 209                         ei++;
 210         }
 211
 212         while (ci < cmds->cnt)
 213                 cmds->names[cj++] = cmds->names[ci++];
 214
 215         cmds->cnt = cj;
 216 }
 217
 218 static void pretty_print_cmdnames(struct cmdnames *cmds, unsigned int colopts)
 219 {
 220         struct string_list list = STRING_LIST_INIT_NODUP;
 221         struct column_options copts;
 222         int i;
 223
 224         for (i = 0; i < cmds->cnt; i++)
 225                 string_list_append(&list, cmds->names[i]->name);
 226         /*
 227          * always enable column display, we only consult column.*
 228          * about layout strategy and stuff
 229          */
 230         colopts = (colopts & ~COL_ENABLE_MASK) | COL_ENABLED;
 231         memset(&copts, 0, sizeof(copts));
 232         copts.indent = "  ";
 233         copts.padding = 2;
 234         print_columns(&list, colopts, &copts);
 235         string_list_clear(&list, 0);
 236 }
 237
 238 static void list_commands_in_dir(struct cmdnames *cmds,
 239                                          const char *path,
 240                                          const char *prefix)
 241 {
 242         DIR *dir = opendir(path);
 243         struct dirent *de;
 244         struct strbuf buf = STRBUF_INIT;
 245         int len;
 246
 247         if (!dir)
 248                 return;
 249         if (!prefix)
 250                 prefix = "git-";
 251
 252         strbuf_addf(&buf, "%s/", path);
 253         len = buf.len;
 254
 255         while ((de = readdir(dir)) != NULL) {
 256                 const char *ent;
 257                 size_t entlen;
 258
 259                 if (!skip_prefix(de->d_name, prefix, &ent))
 260                         continue;
 261
 262                 strbuf_setlen(&buf, len);
 263                 strbuf_addstr(&buf, de->d_name);
 264                 if (!is_executable(buf.buf))
 265                         continue;
 266
 267                 entlen = strlen(ent);
 268                 strip_suffix(ent, ".exe", &entlen);
 269
 270                 add_cmdname(cmds, ent, entlen);
 271         }
 272         closedir(dir);
 273         strbuf_release(&buf);
 274 }
 275
 276 void load_command_list(const char *prefix,
 277                 struct cmdnames *main_cmds,
 278                 struct cmdnames *other_cmds)
 279 {
 280         const char *env_path = getenv("PATH");
 281         const char *exec_path = git_exec_path();
 282
 283         load_builtin_commands(prefix, main_cmds);
 284
 285         if (exec_path) {
 286                 list_commands_in_dir(main_cmds, exec_path, prefix);
 287                 QSORT(main_cmds->names, main_cmds->cnt, cmdname_compare);
 288                 uniq(main_cmds);
 289         }
 290
 291         if (env_path) {
 292                 char *paths, *path, *colon;
 293                 path = paths = xstrdup(env_path);
 294                 while (1) {
 295                         if ((colon = strchr(path, PATH_SEP)))
 296                                 *colon = 0;
 297                         if (!exec_path || strcmp(path, exec_path))
 298                                 list_commands_in_dir(other_cmds, path, prefix);
 299
 300                         if (!colon)
 301                                 break;
 302                         path = colon + 1;
 303                 }
 304                 free(paths);
 305
 306                 QSORT(other_cmds->names, other_cmds->cnt, cmdname_compare);
 307                 uniq(other_cmds);
 308         }
 309         exclude_cmds(other_cmds, main_cmds);
 310 }
 311
 312 static int get_colopts(const char *var, const char *value, void *data)
 313 {
 314         unsigned int *colopts = data;
 315
 316         if (starts_with(var, "column."))
 317                 return git_column_config(var, value, "help", colopts);
 318
 319         return 0;
 320 }
 321
 322 void list_commands(struct cmdnames *main_cmds, struct cmdnames *other_cmds)
 323 {
 324         unsigned int colopts = 0;
 325         git_config(get_colopts, &colopts);
 326
 327         if (main_cmds->cnt) {
 328                 const char *exec_path = git_exec_path();
 329                 printf_ln(_("available git commands in '%s'"), exec_path);
 330                 putchar('\n');
 331                 pretty_print_cmdnames(main_cmds, colopts);
 332                 putchar('\n');
 333         }
 334
 335         if (other_cmds->cnt) {
 336                 puts(_("git commands available from elsewhere on your $PATH"));
 337                 putchar('\n');
 338                 pretty_print_cmdnames(other_cmds, colopts);
 339                 putchar('\n');
 340         }
 341 }
 342
 343 void list_common_cmds_help(void)
 344 {
 345         puts(_("These are common Git commands used in various situations:"));
 346         putchar('\n');
 347         print_cmd_by_category(common_categories, NULL);
 348 }
 349
 350 void list_all_main_cmds(struct string_list *list)
 351 {
 352         struct cmdnames main_cmds, other_cmds;
 353         int i;
 354
 355         memset(&main_cmds, 0, sizeof(main_cmds));
 356         memset(&other_cmds, 0, sizeof(other_cmds));
 357         load_command_list("git-", &main_cmds, &other_cmds);
 358
 359         for (i = 0; i < main_cmds.cnt; i++)
 360                 string_list_append(list, main_cmds.names[i]->name);
 361
 362         clean_cmdnames(&main_cmds);
 363         clean_cmdnames(&other_cmds);
 364 }
 365
 366 void list_all_other_cmds(struct string_list *list)
 367 {
 368         struct cmdnames main_cmds, other_cmds;
 369         int i;
 370
 371         memset(&main_cmds, 0, sizeof(main_cmds));
 372         memset(&other_cmds, 0, sizeof(other_cmds));
 373         load_command_list("git-", &main_cmds, &other_cmds);
 374
 375         for (i = 0; i < other_cmds.cnt; i++)
 376                 string_list_append(list, other_cmds.names[i]->name);
 377
 378         clean_cmdnames(&main_cmds);
 379         clean_cmdnames(&other_cmds);
 380 }
 381
 382 void list_cmds_by_category(struct string_list *list,
 383                            const char *cat)
 384 {
 385         int i, n = ARRAY_SIZE(command_list);
 386         uint32_t cat_id = 0;
 387
 388         for (i = 0; category_names[i]; i++) {
 389                 if (!strcmp(cat, category_names[i])) {
 390                         cat_id = 1UL << i;
 391                         break;
 392                 }
 393         }
 394         if (!cat_id)
 395                 die(_("unsupported command listing type '%s'"), cat);
 396
 397         for (i = 0; i < n; i++) {
 398                 struct cmdname_help *cmd = command_list + i;
 399
 400                 if (!(cmd->category & cat_id))
 401                         continue;
 402                 string_list_append(list, drop_prefix(cmd->name, cmd->category));
 403         }
 404 }
 405
 406 void list_cmds_by_config(struct string_list *list)
 407 {
 408         const char *cmd_list;
 409
 410         if (git_config_get_string_tmp("completion.commands", &cmd_list))
 411                 return;
 412
 413         string_list_sort(list);
 414         string_list_remove_duplicates(list, 0);
 415
 416         while (*cmd_list) {
 417                 struct strbuf sb = STRBUF_INIT;
 418                 const char *p = strchrnul(cmd_list, ' ');
 419
 420                 strbuf_add(&sb, cmd_list, p - cmd_list);
 421                 if (sb.buf[0] == '-')
 422                         string_list_remove(list, sb.buf + 1, 0);
 423                 else
 424                         string_list_insert(list, sb.buf);
 425                 strbuf_release(&sb);
 426                 while (*p == ' ')
 427                         p++;
 428                 cmd_list = p;
 429         }
 430 }
 431
 432 void list_guides_help(void)
 433 {
 434         struct category_description catdesc[] = {
 435                 { CAT_guide, N_("The Git concept guides are:") },
 436                 { 0, NULL }
 437         };
 438         print_cmd_by_category(catdesc, NULL);
 439         putchar('\n');
 440 }
 441
 442 void list_user_interfaces_help(void)
 443 {
 444         struct category_description catdesc[] = {
 445                 { CAT_userinterfaces, N_("User-facing repository, command and file interfaces:") },
 446                 { 0, NULL }
 447         };
 448         print_cmd_by_category(catdesc, NULL);
 449         putchar('\n');
 450 }
 451
 452 void list_developer_interfaces_help(void)
 453 {
 454         struct category_description catdesc[] = {
 455                 { CAT_developerinterfaces, N_("File formats, protocols and other developer interfaces:") },
 456                 { 0, NULL }
 457         };
 458         print_cmd_by_category(catdesc, NULL);
 459         putchar('\n');
 460 }
 461
 462 static int get_alias(const char *var, const char *value, void *data)
 463 {
 464         struct string_list *list = data;
 465
 466         if (skip_prefix(var, "alias.", &var))
 467                 string_list_append(list, var)->util = xstrdup(value);
 468
 469         return 0;
 470 }
 471
 472 static void list_all_cmds_help_external_commands(void)
 473 {
 474         struct string_list others = STRING_LIST_INIT_DUP;
 475         int i;
 476
 477         list_all_other_cmds(&others);
 478         if (others.nr)
 479                 printf("\n%s\n", _("External commands"));
 480         for (i = 0; i < others.nr; i++)
 481                 printf("   %s\n", others.items[i].string);
 482         string_list_clear(&others, 0);
 483 }
 484
 485 static void list_all_cmds_help_aliases(int longest)
 486 {
 487         struct string_list alias_list = STRING_LIST_INIT_DUP;
 488         struct cmdname_help *aliases;
 489         int i;
 490
 491         git_config(get_alias, &alias_list);
 492         string_list_sort(&alias_list);
 493
 494         for (i = 0; i < alias_list.nr; i++) {
 495                 size_t len = strlen(alias_list.items[i].string);
 496                 if (longest < len)
 497                         longest = len;
 498         }
 499
 500         if (alias_list.nr) {
 501                 printf("\n%s\n", _("Command aliases"));
 502                 ALLOC_ARRAY(aliases, alias_list.nr + 1);
 503                 for (i = 0; i < alias_list.nr; i++) {
 504                         aliases[i].name = alias_list.items[i].string;
 505                         aliases[i].help = alias_list.items[i].util;
 506                         aliases[i].category = 1;
 507                 }
 508                 aliases[alias_list.nr].name = NULL;
 509                 print_command_list(aliases, 1, longest);
 510                 free(aliases);
 511         }
 512         string_list_clear(&alias_list, 1);
 513 }
 514
 515 void list_all_cmds_help(int show_external_commands, int show_aliases)
 516 {
 517         int longest;
 518
 519         puts(_("See 'git help <command>' to read about a specific subcommand"));
 520         putchar('\n');
 521         print_cmd_by_category(main_categories, &longest);
 522
 523         if (show_external_commands)
 524                 list_all_cmds_help_external_commands();
 525         if (show_aliases)
 526                 list_all_cmds_help_aliases(longest);
 527 }
 528
 529 int is_in_cmdlist(struct cmdnames *c, const char *s)
 530 {
 531         int i;
 532         for (i = 0; i < c->cnt; i++)
 533                 if (!strcmp(s, c->names[i]->name))
 534                         return 1;
 535         return 0;
 536 }
 537
 538 static int autocorrect;
 539 static struct cmdnames aliases;
 540
 541 #define AUTOCORRECT_PROMPT (-3)
 542 #define AUTOCORRECT_NEVER (-2)
 543 #define AUTOCORRECT_IMMEDIATELY (-1)
 544
 545 static int git_unknown_cmd_config(const char *var, const char *value,
 546                                   void *cb UNUSED)
 547 {
 548         const char *p;
 549
 550         if (!strcmp(var, "help.autocorrect")) {
 551                 if (!value)
 552                         return config_error_nonbool(var);
 553                 if (!strcmp(value, "never")) {
 554                         autocorrect = AUTOCORRECT_NEVER;
 555                 } else if (!strcmp(value, "immediate")) {
 556                         autocorrect = AUTOCORRECT_IMMEDIATELY;
 557                 } else if (!strcmp(value, "prompt")) {
 558                         autocorrect = AUTOCORRECT_PROMPT;
 559                 } else {
 560                         int v = git_config_int(var, value);
 561                         autocorrect = (v < 0)
 562                                 ? AUTOCORRECT_IMMEDIATELY : v;
 563                 }
 564         }
 565         /* Also use aliases for command lookup */
 566         if (skip_prefix(var, "alias.", &p))
 567                 add_cmdname(&aliases, p, strlen(p));
 568
 569         return 0;
 570 }
 571
 572 static int levenshtein_compare(const void *p1, const void *p2)
 573 {
 574         const struct cmdname *const *c1 = p1, *const *c2 = p2;
 575         const char *s1 = (*c1)->name, *s2 = (*c2)->name;
 576         int l1 = (*c1)->len;
 577         int l2 = (*c2)->len;
 578         return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
 579 }
 580
 581 static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
 582 {
 583         int i;
 584         ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
 585
 586         for (i = 0; i < old->cnt; i++)
 587                 cmds->names[cmds->cnt++] = old->names[i];
 588         FREE_AND_NULL(old->names);
 589         old->cnt = 0;
 590 }
 591
 592 /* An empirically derived magic number */
 593 #define SIMILARITY_FLOOR 7
 594 #define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
 595
 596 static const char bad_interpreter_advice[] =
 597         N_("'%s' appears to be a git command, but we were not\n"
 598         "able to execute it. Maybe git-%s is broken?");
 599
 600 const char *help_unknown_cmd(const char *cmd)
 601 {
 602         int i, n, best_similarity = 0;
 603         struct cmdnames main_cmds, other_cmds;
 604         struct cmdname_help *common_cmds;
 605
 606         memset(&main_cmds, 0, sizeof(main_cmds));
 607         memset(&other_cmds, 0, sizeof(other_cmds));
 608         memset(&aliases, 0, sizeof(aliases));
 609
 610         read_early_config(git_unknown_cmd_config, NULL);
 611
 612         /*
 613          * Disable autocorrection prompt in a non-interactive session
 614          */
 615         if ((autocorrect == AUTOCORRECT_PROMPT) && (!isatty(0) || !isatty(2)))
 616                 autocorrect = AUTOCORRECT_NEVER;
 617
 618         if (autocorrect == AUTOCORRECT_NEVER) {
 619                 fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
 620                 exit(1);
 621         }
 622
 623         load_command_list("git-", &main_cmds, &other_cmds);
 624
 625         add_cmd_list(&main_cmds, &aliases);
 626         add_cmd_list(&main_cmds, &other_cmds);
 627         QSORT(main_cmds.names, main_cmds.cnt, cmdname_compare);
 628         uniq(&main_cmds);
 629
 630         extract_cmds(&common_cmds, common_mask);
 631
 632         /* This abuses cmdname->len for levenshtein distance */
 633         for (i = 0, n = 0; i < main_cmds.cnt; i++) {
 634                 int cmp = 0; /* avoid compiler stupidity */
 635                 const char *candidate = main_cmds.names[i]->name;
 636
 637                 /*
 638                  * An exact match means we have the command, but
 639                  * for some reason exec'ing it gave us ENOENT; probably
 640                  * it's a bad interpreter in the #! line.
 641                  */
 642                 if (!strcmp(candidate, cmd))
 643                         die(_(bad_interpreter_advice), cmd, cmd);
 644
 645                 /* Does the candidate appear in common_cmds list? */
 646                 while (common_cmds[n].name &&
 647                        (cmp = strcmp(common_cmds[n].name, candidate)) < 0)
 648                         n++;
 649                 if (common_cmds[n].name && !cmp) {
 650                         /* Yes, this is one of the common commands */
 651                         n++; /* use the entry from common_cmds[] */
 652                         if (starts_with(candidate, cmd)) {
 653                                 /* Give prefix match a very good score */
 654                                 main_cmds.names[i]->len = 0;
 655                                 continue;
 656                         }
 657                 }
 658
 659                 main_cmds.names[i]->len =
 660                         levenshtein(cmd, candidate, 0, 2, 1, 3) + 1;
 661         }
 662         FREE_AND_NULL(common_cmds);
 663
 664         QSORT(main_cmds.names, main_cmds.cnt, levenshtein_compare);
 665
 666         if (!main_cmds.cnt)
 667                 die(_("Uh oh. Your system reports no Git commands at all."));
 668
 669         /* skip and count prefix matches */
 670         for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
 671                 ; /* still counting */
 672
 673         if (main_cmds.cnt <= n) {
 674                 /* prefix matches with everything? that is too ambiguous */
 675                 best_similarity = SIMILARITY_FLOOR + 1;
 676         } else {
 677                 /* count all the most similar ones */
 678                 for (best_similarity = main_cmds.names[n++]->len;
 679                      (n < main_cmds.cnt &&
 680                       best_similarity == main_cmds.names[n]->len);
 681                      n++)
 682                         ; /* still counting */
 683         }
 684         if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) {
 685                 const char *assumed = main_cmds.names[0]->name;
 686                 main_cmds.names[0] = NULL;
 687                 clean_cmdnames(&main_cmds);
 688                 fprintf_ln(stderr,
 689                            _("WARNING: You called a Git command named '%s', "
 690                              "which does not exist."),
 691                            cmd);
 692                 if (autocorrect == AUTOCORRECT_IMMEDIATELY)
 693                         fprintf_ln(stderr,
 694                                    _("Continuing under the assumption that "
 695                                      "you meant '%s'."),
 696                                    assumed);
 697                 else if (autocorrect == AUTOCORRECT_PROMPT) {
 698                         char *answer;
 699                         struct strbuf msg = STRBUF_INIT;
 700                         strbuf_addf(&msg, _("Run '%s' instead [y/N]? "), assumed);
 701                         answer = git_prompt(msg.buf, PROMPT_ECHO);
 702                         strbuf_release(&msg);
 703                         if (!(starts_with(answer, "y") ||
 704                               starts_with(answer, "Y")))
 705                                 exit(1);
 706                 } else {
 707                         fprintf_ln(stderr,
 708                                    _("Continuing in %0.1f seconds, "
 709                                      "assuming that you meant '%s'."),
 710                                    (float)autocorrect/10.0, assumed);
 711                         sleep_millisec(autocorrect * 100);
 712                 }
 713                 return assumed;
 714         }
 715
 716         fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
 717
 718         if (SIMILAR_ENOUGH(best_similarity)) {
 719                 fprintf_ln(stderr,
 720                            Q_("\nThe most similar command is",
 721                               "\nThe most similar commands are",
 722                            n));
 723
 724                 for (i = 0; i < n; i++)
 725                         fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
 726         }
 727
 728         exit(1);
 729 }
 730
 731 void get_version_info(struct strbuf *buf, int show_build_options)
 732 {
 733         /*
 734          * The format of this string should be kept stable for compatibility
 735          * with external projects that rely on the output of "git version".
 736          *
 737          * Always show the version, even if other options are given.
 738          */
 739         strbuf_addf(buf, "git version %s\n", git_version_string);
 740
 741         if (show_build_options) {
 742                 strbuf_addf(buf, "cpu: %s\n", GIT_HOST_CPU);
 743                 if (git_built_from_commit_string[0])
 744                         strbuf_addf(buf, "built from commit: %s\n",
 745                                git_built_from_commit_string);
 746                 else
 747                         strbuf_addstr(buf, "no commit associated with this build\n");
 748                 strbuf_addf(buf, "sizeof-long: %d\n", (int)sizeof(long));
 749                 strbuf_addf(buf, "sizeof-size_t: %d\n", (int)sizeof(size_t));
 750                 strbuf_addf(buf, "shell-path: %s\n", SHELL_PATH);
 751                 /* NEEDSWORK: also save and output GIT-BUILD_OPTIONS? */
 752
 753                 if (fsmonitor_ipc__is_supported())
 754                         strbuf_addstr(buf, "feature: fsmonitor--daemon\n");
 755         }
 756 }
 757
 758 int cmd_version(int argc, const char **argv, const char *prefix)
 759 {
 760         struct strbuf buf = STRBUF_INIT;
 761         int build_options = 0;
 762         const char * const usage[] = {
 763                 N_("git version [--build-options]"),
 764                 NULL
 765         };
 766         struct option options[] = {
 767                 OPT_BOOL(0, "build-options", &build_options,
 768                          "also print build options"),
 769                 OPT_END()
 770         };
 771
 772         argc = parse_options(argc, argv, prefix, options, usage, 0);
 773
 774         get_version_info(&buf, build_options);
 775         printf("%s", buf.buf);
 776
 777         strbuf_release(&buf);
 778
 779         return 0;
 780 }
 781
 782 struct similar_ref_cb {
 783         const char *base_ref;
 784         struct string_list *similar_refs;
 785 };
 786
 787 static int append_similar_ref(const char *refname,
 788                               const struct object_id *oid UNUSED,
 789                               int flags UNUSED, void *cb_data)
 790 {
 791         struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
 792         char *branch = strrchr(refname, '/') + 1;
 793
 794         /* A remote branch of the same name is deemed similar */
 795         if (starts_with(refname, "refs/remotes/") &&
 796             !strcmp(branch, cb->base_ref))
 797                 string_list_append_nodup(cb->similar_refs,
 798                                          shorten_unambiguous_ref(refname, 1));
 799         return 0;
 800 }
 801
 802 static struct string_list guess_refs(const char *ref)
 803 {
 804         struct similar_ref_cb ref_cb;
 805         struct string_list similar_refs = STRING_LIST_INIT_DUP;
 806
 807         ref_cb.base_ref = ref;
 808         ref_cb.similar_refs = &similar_refs;
 809         for_each_ref(append_similar_ref, &ref_cb);
 810         return similar_refs;
 811 }
 812
 813 NORETURN void help_unknown_ref(const char *ref, const char *cmd,
 814                                const char *error)
 815 {
 816         int i;
 817         struct string_list suggested_refs = guess_refs(ref);
 818
 819         fprintf_ln(stderr, _("%s: %s - %s"), cmd, ref, error);
 820
 821         if (suggested_refs.nr > 0) {
 822                 fprintf_ln(stderr,
 823                            Q_("\nDid you mean this?",
 824                               "\nDid you mean one of these?",
 825                               suggested_refs.nr));
 826                 for (i = 0; i < suggested_refs.nr; i++)
 827                         fprintf(stderr, "\t%s\n", suggested_refs.items[i].string);
 828         }
 829
 830         string_list_clear(&suggested_refs, 0);
 831         exit(1);
 832 }