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,
 313                        const struct config_context *ctx UNUSED, void *data)
 314 {
 315         unsigned int *colopts = data;
 316
 317         if (starts_with(var, "column."))
 318                 return git_column_config(var, value, "help", colopts);
 319
 320         return 0;
 321 }
 322
 323 void list_commands(struct cmdnames *main_cmds, struct cmdnames *other_cmds)
 324 {
 325         unsigned int colopts = 0;
 326         git_config(get_colopts, &colopts);
 327
 328         if (main_cmds->cnt) {
 329                 const char *exec_path = git_exec_path();
 330                 printf_ln(_("available git commands in '%s'"), exec_path);
 331                 putchar('\n');
 332                 pretty_print_cmdnames(main_cmds, colopts);
 333                 putchar('\n');
 334         }
 335
 336         if (other_cmds->cnt) {
 337                 puts(_("git commands available from elsewhere on your $PATH"));
 338                 putchar('\n');
 339                 pretty_print_cmdnames(other_cmds, colopts);
 340                 putchar('\n');
 341         }
 342 }
 343
 344 void list_common_cmds_help(void)
 345 {
 346         puts(_("These are common Git commands used in various situations:"));
 347         putchar('\n');
 348         print_cmd_by_category(common_categories, NULL);
 349 }
 350
 351 void list_all_main_cmds(struct string_list *list)
 352 {
 353         struct cmdnames main_cmds, other_cmds;
 354         int i;
 355
 356         memset(&main_cmds, 0, sizeof(main_cmds));
 357         memset(&other_cmds, 0, sizeof(other_cmds));
 358         load_command_list("git-", &main_cmds, &other_cmds);
 359
 360         for (i = 0; i < main_cmds.cnt; i++)
 361                 string_list_append(list, main_cmds.names[i]->name);
 362
 363         clean_cmdnames(&main_cmds);
 364         clean_cmdnames(&other_cmds);
 365 }
 366
 367 void list_all_other_cmds(struct string_list *list)
 368 {
 369         struct cmdnames main_cmds, other_cmds;
 370         int i;
 371
 372         memset(&main_cmds, 0, sizeof(main_cmds));
 373         memset(&other_cmds, 0, sizeof(other_cmds));
 374         load_command_list("git-", &main_cmds, &other_cmds);
 375
 376         for (i = 0; i < other_cmds.cnt; i++)
 377                 string_list_append(list, other_cmds.names[i]->name);
 378
 379         clean_cmdnames(&main_cmds);
 380         clean_cmdnames(&other_cmds);
 381 }
 382
 383 void list_cmds_by_category(struct string_list *list,
 384                            const char *cat)
 385 {
 386         int i, n = ARRAY_SIZE(command_list);
 387         uint32_t cat_id = 0;
 388
 389         for (i = 0; category_names[i]; i++) {
 390                 if (!strcmp(cat, category_names[i])) {
 391                         cat_id = 1UL << i;
 392                         break;
 393                 }
 394         }
 395         if (!cat_id)
 396                 die(_("unsupported command listing type '%s'"), cat);
 397
 398         for (i = 0; i < n; i++) {
 399                 struct cmdname_help *cmd = command_list + i;
 400
 401                 if (!(cmd->category & cat_id))
 402                         continue;
 403                 string_list_append(list, drop_prefix(cmd->name, cmd->category));
 404         }
 405 }
 406
 407 void list_cmds_by_config(struct string_list *list)
 408 {
 409         const char *cmd_list;
 410
 411         if (git_config_get_string_tmp("completion.commands", &cmd_list))
 412                 return;
 413
 414         string_list_sort(list);
 415         string_list_remove_duplicates(list, 0);
 416
 417         while (*cmd_list) {
 418                 struct strbuf sb = STRBUF_INIT;
 419                 const char *p = strchrnul(cmd_list, ' ');
 420
 421                 strbuf_add(&sb, cmd_list, p - cmd_list);
 422                 if (sb.buf[0] == '-')
 423                         string_list_remove(list, sb.buf + 1, 0);
 424                 else
 425                         string_list_insert(list, sb.buf);
 426                 strbuf_release(&sb);
 427                 while (*p == ' ')
 428                         p++;
 429                 cmd_list = p;
 430         }
 431 }
 432
 433 void list_guides_help(void)
 434 {
 435         struct category_description catdesc[] = {
 436                 { CAT_guide, N_("The Git concept guides are:") },
 437                 { 0, NULL }
 438         };
 439         print_cmd_by_category(catdesc, NULL);
 440         putchar('\n');
 441 }
 442
 443 void list_user_interfaces_help(void)
 444 {
 445         struct category_description catdesc[] = {
 446                 { CAT_userinterfaces, N_("User-facing repository, command and file interfaces:") },
 447                 { 0, NULL }
 448         };
 449         print_cmd_by_category(catdesc, NULL);
 450         putchar('\n');
 451 }
 452
 453 void list_developer_interfaces_help(void)
 454 {
 455         struct category_description catdesc[] = {
 456                 { CAT_developerinterfaces, N_("File formats, protocols and other developer interfaces:") },
 457                 { 0, NULL }
 458         };
 459         print_cmd_by_category(catdesc, NULL);
 460         putchar('\n');
 461 }
 462
 463 static int get_alias(const char *var, const char *value,
 464                      const struct config_context *ctx UNUSED, void *data)
 465 {
 466         struct string_list *list = data;
 467
 468         if (skip_prefix(var, "alias.", &var))
 469                 string_list_append(list, var)->util = xstrdup(value);
 470
 471         return 0;
 472 }
 473
 474 static void list_all_cmds_help_external_commands(void)
 475 {
 476         struct string_list others = STRING_LIST_INIT_DUP;
 477         int i;
 478
 479         list_all_other_cmds(&others);
 480         if (others.nr)
 481                 printf("\n%s\n", _("External commands"));
 482         for (i = 0; i < others.nr; i++)
 483                 printf("   %s\n", others.items[i].string);
 484         string_list_clear(&others, 0);
 485 }
 486
 487 static void list_all_cmds_help_aliases(int longest)
 488 {
 489         struct string_list alias_list = STRING_LIST_INIT_DUP;
 490         struct cmdname_help *aliases;
 491         int i;
 492
 493         git_config(get_alias, &alias_list);
 494         string_list_sort(&alias_list);
 495
 496         for (i = 0; i < alias_list.nr; i++) {
 497                 size_t len = strlen(alias_list.items[i].string);
 498                 if (longest < len)
 499                         longest = len;
 500         }
 501
 502         if (alias_list.nr) {
 503                 printf("\n%s\n", _("Command aliases"));
 504                 ALLOC_ARRAY(aliases, alias_list.nr + 1);
 505                 for (i = 0; i < alias_list.nr; i++) {
 506                         aliases[i].name = alias_list.items[i].string;
 507                         aliases[i].help = alias_list.items[i].util;
 508                         aliases[i].category = 1;
 509                 }
 510                 aliases[alias_list.nr].name = NULL;
 511                 print_command_list(aliases, 1, longest);
 512                 free(aliases);
 513         }
 514         string_list_clear(&alias_list, 1);
 515 }
 516
 517 void list_all_cmds_help(int show_external_commands, int show_aliases)
 518 {
 519         int longest;
 520
 521         puts(_("See 'git help <command>' to read about a specific subcommand"));
 522         putchar('\n');
 523         print_cmd_by_category(main_categories, &longest);
 524
 525         if (show_external_commands)
 526                 list_all_cmds_help_external_commands();
 527         if (show_aliases)
 528                 list_all_cmds_help_aliases(longest);
 529 }
 530
 531 int is_in_cmdlist(struct cmdnames *c, const char *s)
 532 {
 533         int i;
 534         for (i = 0; i < c->cnt; i++)
 535                 if (!strcmp(s, c->names[i]->name))
 536                         return 1;
 537         return 0;
 538 }
 539
 540 static int autocorrect;
 541 static struct cmdnames aliases;
 542
 543 #define AUTOCORRECT_PROMPT (-3)
 544 #define AUTOCORRECT_NEVER (-2)
 545 #define AUTOCORRECT_IMMEDIATELY (-1)
 546
 547 static int git_unknown_cmd_config(const char *var, const char *value,
 548                                   const struct config_context *ctx,
 549                                   void *cb UNUSED)
 550 {
 551         const char *p;
 552
 553         if (!strcmp(var, "help.autocorrect")) {
 554                 if (!value)
 555                         return config_error_nonbool(var);
 556                 if (!strcmp(value, "never")) {
 557                         autocorrect = AUTOCORRECT_NEVER;
 558                 } else if (!strcmp(value, "immediate")) {
 559                         autocorrect = AUTOCORRECT_IMMEDIATELY;
 560                 } else if (!strcmp(value, "prompt")) {
 561                         autocorrect = AUTOCORRECT_PROMPT;
 562                 } else {
 563                         int v = git_config_int(var, value, ctx->kvi);
 564                         autocorrect = (v < 0)
 565                                 ? AUTOCORRECT_IMMEDIATELY : v;
 566                 }
 567         }
 568         /* Also use aliases for command lookup */
 569         if (skip_prefix(var, "alias.", &p))
 570                 add_cmdname(&aliases, p, strlen(p));
 571
 572         return 0;
 573 }
 574
 575 static int levenshtein_compare(const void *p1, const void *p2)
 576 {
 577         const struct cmdname *const *c1 = p1, *const *c2 = p2;
 578         const char *s1 = (*c1)->name, *s2 = (*c2)->name;
 579         int l1 = (*c1)->len;
 580         int l2 = (*c2)->len;
 581         return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
 582 }
 583
 584 static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
 585 {
 586         int i;
 587         ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
 588
 589         for (i = 0; i < old->cnt; i++)
 590                 cmds->names[cmds->cnt++] = old->names[i];
 591         FREE_AND_NULL(old->names);
 592         old->cnt = 0;
 593 }
 594
 595 /* An empirically derived magic number */
 596 #define SIMILARITY_FLOOR 7
 597 #define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
 598
 599 static const char bad_interpreter_advice[] =
 600         N_("'%s' appears to be a git command, but we were not\n"
 601         "able to execute it. Maybe git-%s is broken?");
 602
 603 const char *help_unknown_cmd(const char *cmd)
 604 {
 605         int i, n, best_similarity = 0;
 606         struct cmdnames main_cmds, other_cmds;
 607         struct cmdname_help *common_cmds;
 608
 609         memset(&main_cmds, 0, sizeof(main_cmds));
 610         memset(&other_cmds, 0, sizeof(other_cmds));
 611         memset(&aliases, 0, sizeof(aliases));
 612
 613         read_early_config(git_unknown_cmd_config, NULL);
 614
 615         /*
 616          * Disable autocorrection prompt in a non-interactive session
 617          */
 618         if ((autocorrect == AUTOCORRECT_PROMPT) && (!isatty(0) || !isatty(2)))
 619                 autocorrect = AUTOCORRECT_NEVER;
 620
 621         if (autocorrect == AUTOCORRECT_NEVER) {
 622                 fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
 623                 exit(1);
 624         }
 625
 626         load_command_list("git-", &main_cmds, &other_cmds);
 627
 628         add_cmd_list(&main_cmds, &aliases);
 629         add_cmd_list(&main_cmds, &other_cmds);
 630         QSORT(main_cmds.names, main_cmds.cnt, cmdname_compare);
 631         uniq(&main_cmds);
 632
 633         extract_cmds(&common_cmds, common_mask);
 634
 635         /* This abuses cmdname->len for levenshtein distance */
 636         for (i = 0, n = 0; i < main_cmds.cnt; i++) {
 637                 int cmp = 0; /* avoid compiler stupidity */
 638                 const char *candidate = main_cmds.names[i]->name;
 639
 640                 /*
 641                  * An exact match means we have the command, but
 642                  * for some reason exec'ing it gave us ENOENT; probably
 643                  * it's a bad interpreter in the #! line.
 644                  */
 645                 if (!strcmp(candidate, cmd))
 646                         die(_(bad_interpreter_advice), cmd, cmd);
 647
 648                 /* Does the candidate appear in common_cmds list? */
 649                 while (common_cmds[n].name &&
 650                        (cmp = strcmp(common_cmds[n].name, candidate)) < 0)
 651                         n++;
 652                 if (common_cmds[n].name && !cmp) {
 653                         /* Yes, this is one of the common commands */
 654                         n++; /* use the entry from common_cmds[] */
 655                         if (starts_with(candidate, cmd)) {
 656                                 /* Give prefix match a very good score */
 657                                 main_cmds.names[i]->len = 0;
 658                                 continue;
 659                         }
 660                 }
 661
 662                 main_cmds.names[i]->len =
 663                         levenshtein(cmd, candidate, 0, 2, 1, 3) + 1;
 664         }
 665         FREE_AND_NULL(common_cmds);
 666
 667         QSORT(main_cmds.names, main_cmds.cnt, levenshtein_compare);
 668
 669         if (!main_cmds.cnt)
 670                 die(_("Uh oh. Your system reports no Git commands at all."));
 671
 672         /* skip and count prefix matches */
 673         for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
 674                 ; /* still counting */
 675
 676         if (main_cmds.cnt <= n) {
 677                 /* prefix matches with everything? that is too ambiguous */
 678                 best_similarity = SIMILARITY_FLOOR + 1;
 679         } else {
 680                 /* count all the most similar ones */
 681                 for (best_similarity = main_cmds.names[n++]->len;
 682                      (n < main_cmds.cnt &&
 683                       best_similarity == main_cmds.names[n]->len);
 684                      n++)
 685                         ; /* still counting */
 686         }
 687         if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) {
 688                 const char *assumed = main_cmds.names[0]->name;
 689                 main_cmds.names[0] = NULL;
 690                 clean_cmdnames(&main_cmds);
 691                 fprintf_ln(stderr,
 692                            _("WARNING: You called a Git command named '%s', "
 693                              "which does not exist."),
 694                            cmd);
 695                 if (autocorrect == AUTOCORRECT_IMMEDIATELY)
 696                         fprintf_ln(stderr,
 697                                    _("Continuing under the assumption that "
 698                                      "you meant '%s'."),
 699                                    assumed);
 700                 else if (autocorrect == AUTOCORRECT_PROMPT) {
 701                         char *answer;
 702                         struct strbuf msg = STRBUF_INIT;
 703                         strbuf_addf(&msg, _("Run '%s' instead [y/N]? "), assumed);
 704                         answer = git_prompt(msg.buf, PROMPT_ECHO);
 705                         strbuf_release(&msg);
 706                         if (!(starts_with(answer, "y") ||
 707                               starts_with(answer, "Y")))
 708                                 exit(1);
 709                 } else {
 710                         fprintf_ln(stderr,
 711                                    _("Continuing in %0.1f seconds, "
 712                                      "assuming that you meant '%s'."),
 713                                    (float)autocorrect/10.0, assumed);
 714                         sleep_millisec(autocorrect * 100);
 715                 }
 716                 return assumed;
 717         }
 718
 719         fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
 720
 721         if (SIMILAR_ENOUGH(best_similarity)) {
 722                 fprintf_ln(stderr,
 723                            Q_("\nThe most similar command is",
 724                               "\nThe most similar commands are",
 725                            n));
 726
 727                 for (i = 0; i < n; i++)
 728                         fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
 729         }
 730
 731         exit(1);
 732 }
 733
 734 void get_version_info(struct strbuf *buf, int show_build_options)
 735 {
 736         /*
 737          * The format of this string should be kept stable for compatibility
 738          * with external projects that rely on the output of "git version".
 739          *
 740          * Always show the version, even if other options are given.
 741          */
 742         strbuf_addf(buf, "git version %s\n", git_version_string);
 743
 744         if (show_build_options) {
 745                 strbuf_addf(buf, "cpu: %s\n", GIT_HOST_CPU);
 746                 if (git_built_from_commit_string[0])
 747                         strbuf_addf(buf, "built from commit: %s\n",
 748                                git_built_from_commit_string);
 749                 else
 750                         strbuf_addstr(buf, "no commit associated with this build\n");
 751                 strbuf_addf(buf, "sizeof-long: %d\n", (int)sizeof(long));
 752                 strbuf_addf(buf, "sizeof-size_t: %d\n", (int)sizeof(size_t));
 753                 strbuf_addf(buf, "shell-path: %s\n", SHELL_PATH);
 754                 /* NEEDSWORK: also save and output GIT-BUILD_OPTIONS? */
 755
 756                 if (fsmonitor_ipc__is_supported())
 757                         strbuf_addstr(buf, "feature: fsmonitor--daemon\n");
 758         }
 759 }
 760
 761 int cmd_version(int argc, const char **argv, const char *prefix)
 762 {
 763         struct strbuf buf = STRBUF_INIT;
 764         int build_options = 0;
 765         const char * const usage[] = {
 766                 N_("git version [--build-options]"),
 767                 NULL
 768         };
 769         struct option options[] = {
 770                 OPT_BOOL(0, "build-options", &build_options,
 771                          "also print build options"),
 772                 OPT_END()
 773         };
 774
 775         argc = parse_options(argc, argv, prefix, options, usage, 0);
 776
 777         get_version_info(&buf, build_options);
 778         printf("%s", buf.buf);
 779
 780         strbuf_release(&buf);
 781
 782         return 0;
 783 }
 784
 785 struct similar_ref_cb {
 786         const char *base_ref;
 787         struct string_list *similar_refs;
 788 };
 789
 790 static int append_similar_ref(const char *refname,
 791                               const struct object_id *oid UNUSED,
 792                               int flags UNUSED, void *cb_data)
 793 {
 794         struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
 795         char *branch = strrchr(refname, '/') + 1;
 796
 797         /* A remote branch of the same name is deemed similar */
 798         if (starts_with(refname, "refs/remotes/") &&
 799             !strcmp(branch, cb->base_ref))
 800                 string_list_append_nodup(cb->similar_refs,
 801                                          shorten_unambiguous_ref(refname, 1));
 802         return 0;
 803 }
 804
 805 static struct string_list guess_refs(const char *ref)
 806 {
 807         struct similar_ref_cb ref_cb;
 808         struct string_list similar_refs = STRING_LIST_INIT_DUP;
 809
 810         ref_cb.base_ref = ref;
 811         ref_cb.similar_refs = &similar_refs;
 812         for_each_ref(append_similar_ref, &ref_cb);
 813         return similar_refs;
 814 }
 815
 816 NORETURN void help_unknown_ref(const char *ref, const char *cmd,
 817                                const char *error)
 818 {
 819         int i;
 820         struct string_list suggested_refs = guess_refs(ref);
 821
 822         fprintf_ln(stderr, _("%s: %s - %s"), cmd, ref, error);
 823
 824         if (suggested_refs.nr > 0) {
 825                 fprintf_ln(stderr,
 826                            Q_("\nDid you mean this?",
 827                               "\nDid you mean one of these?",
 828                               suggested_refs.nr));
 829                 for (i = 0; i < suggested_refs.nr; i++)
 830                         fprintf(stderr, "\t%s\n", suggested_refs.items[i].string);
 831         }
 832
 833         string_list_clear(&suggested_refs, 0);
 834         exit(1);
 835 }