Merge branch 'mk/rename'

diff --cc builtin-checkout-index.c
index 0000000000000000000000000000000000000000,29ea6fdc6232c1071d88524fa5c11d5ba1882dee..8d0dbad49ecd61edf8bdadc24e23e52d31d961a3
mode 000000,100644..100644
--- /dev/null
--- 2/builtin-checkout-index.c
+++ b/builtin-checkout-index.c
@@@ -1,0 -1,309 +1,309 @@@
 -                                      (&lock_file, get_index_file());
+ /*
+  * Check-out files from the "current cache directory"
+  *
+  * Copyright (C) 2005 Linus Torvalds
+  *
+  * Careful: order of argument flags does matter. For example,
+  *
+  *    git-checkout-index -a -f file.c
+  *
+  * Will first check out all files listed in the cache (but not
+  * overwrite any old ones), and then force-checkout "file.c" a
+  * second time (ie that one _will_ overwrite any old contents
+  * with the same filename).
+  *
+  * Also, just doing "git-checkout-index" does nothing. You probably
+  * meant "git-checkout-index -a". And if you want to force it, you
+  * want "git-checkout-index -f -a".
+  *
+  * Intuitiveness is not the goal here. Repeatability is. The
+  * reason for the "no arguments means no work" thing is that
+  * from scripts you are supposed to be able to do things like
+  *
+  *    find . -name '*.h' -print0 | xargs -0 git-checkout-index -f --
+  *
+  * or:
+  *
+  *    find . -name '*.h' -print0 | git-checkout-index -f -z --stdin
+  *
+  * which will force all existing *.h files to be replaced with
+  * their cached copies. If an empty command line implied "all",
+  * then this would force-refresh everything in the cache, which
+  * was not the point.
+  *
+  * Oh, and the "--" is just a good idea when you know the rest
+  * will be filenames. Just so that you wouldn't have a filename
+  * of "-a" causing problems (not possible in the above example,
+  * but get used to it in scripting!).
+  */
+ #include "cache.h"
+ #include "strbuf.h"
+ #include "quote.h"
+ #include "cache-tree.h"
+ 
+ #define CHECKOUT_ALL 4
+ static int line_termination = '\n';
+ static int checkout_stage; /* default to checkout stage0 */
+ static int to_tempfile;
+ static char topath[4][MAXPATHLEN+1];
+ 
+ static struct checkout state;
+ 
+ static void write_tempfile_record(const char *name, int prefix_length)
+ {
+       int i;
+ 
+       if (CHECKOUT_ALL == checkout_stage) {
+               for (i = 1; i < 4; i++) {
+                       if (i > 1)
+                               putchar(' ');
+                       if (topath[i][0])
+                               fputs(topath[i], stdout);
+                       else
+                               putchar('.');
+               }
+       } else
+               fputs(topath[checkout_stage], stdout);
+ 
+       putchar('\t');
+       write_name_quoted("", 0, name + prefix_length,
+               line_termination, stdout);
+       putchar(line_termination);
+ 
+       for (i = 0; i < 4; i++) {
+               topath[i][0] = 0;
+       }
+ }
+ 
+ static int checkout_file(const char *name, int prefix_length)
+ {
+       int namelen = strlen(name);
+       int pos = cache_name_pos(name, namelen);
+       int has_same_name = 0;
+       int did_checkout = 0;
+       int errs = 0;
+ 
+       if (pos < 0)
+               pos = -pos - 1;
+ 
+       while (pos < active_nr) {
+               struct cache_entry *ce = active_cache[pos];
+               if (ce_namelen(ce) != namelen ||
+                   memcmp(ce->name, name, namelen))
+                       break;
+               has_same_name = 1;
+               pos++;
+               if (ce_stage(ce) != checkout_stage
+                   && (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
+                       continue;
+               did_checkout = 1;
+               if (checkout_entry(ce, &state,
+                   to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
+                       errs++;
+       }
+ 
+       if (did_checkout) {
+               if (to_tempfile)
+                       write_tempfile_record(name, prefix_length);
+               return errs > 0 ? -1 : 0;
+       }
+ 
+       if (!state.quiet) {
+               fprintf(stderr, "git-checkout-index: %s ", name);
+               if (!has_same_name)
+                       fprintf(stderr, "is not in the cache");
+               else if (checkout_stage)
+                       fprintf(stderr, "does not exist at stage %d",
+                               checkout_stage);
+               else
+                       fprintf(stderr, "is unmerged");
+               fputc('\n', stderr);
+       }
+       return -1;
+ }
+ 
+ static int checkout_all(const char *prefix, int prefix_length)
+ {
+       int i, errs = 0;
+       struct cache_entry* last_ce = NULL;
+ 
+       for (i = 0; i < active_nr ; i++) {
+               struct cache_entry *ce = active_cache[i];
+               if (ce_stage(ce) != checkout_stage
+                   && (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
+                       continue;
+               if (prefix && *prefix &&
+                   (ce_namelen(ce) <= prefix_length ||
+                    memcmp(prefix, ce->name, prefix_length)))
+                       continue;
+               if (last_ce && to_tempfile) {
+                       if (ce_namelen(last_ce) != ce_namelen(ce)
+                           || memcmp(last_ce->name, ce->name, ce_namelen(ce)))
+                               write_tempfile_record(last_ce->name, prefix_length);
+               }
+               if (checkout_entry(ce, &state,
+                   to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
+                       errs++;
+               last_ce = ce;
+       }
+       if (last_ce && to_tempfile)
+               write_tempfile_record(last_ce->name, prefix_length);
+       if (errs)
+               /* we have already done our error reporting.
+                * exit with the same code as die().
+                */
+               exit(128);
+       return 0;
+ }
+ 
+ static const char checkout_cache_usage[] =
+ "git-checkout-index [-u] [-q] [-a] [-f] [-n] [--stage=[123]|all] [--prefix=<string>] [--temp] [--] <file>...";
+ 
+ static struct lock_file lock_file;
+ 
+ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
+ {
+       int i;
+       int newfd = -1;
+       int all = 0;
+       int read_from_stdin = 0;
+       int prefix_length;
+ 
+       git_config(git_default_config);
+       state.base_dir = "";
+       prefix_length = prefix ? strlen(prefix) : 0;
+ 
+       if (read_cache() < 0) {
+               die("invalid cache");
+       }
+ 
+       for (i = 1; i < argc; i++) {
+               const char *arg = argv[i];
+ 
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       break;
+               }
+               if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
+                       all = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-f") || !strcmp(arg, "--force")) {
+                       state.force = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) {
+                       state.quiet = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-n") || !strcmp(arg, "--no-create")) {
+                       state.not_new = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-u") || !strcmp(arg, "--index")) {
+                       state.refresh_cache = 1;
+                       if (newfd < 0)
+                               newfd = hold_lock_file_for_update
++                                      (&lock_file, get_index_file(), 1);
+                       if (newfd < 0)
+                               die("cannot open index.lock file.");
+                       continue;
+               }
+               if (!strcmp(arg, "-z")) {
+                       line_termination = 0;
+                       continue;
+               }
+               if (!strcmp(arg, "--stdin")) {
+                       if (i != argc - 1)
+                               die("--stdin must be at the end");
+                       read_from_stdin = 1;
+                       i++; /* do not consider arg as a file name */
+                       break;
+               }
+               if (!strcmp(arg, "--temp")) {
+                       to_tempfile = 1;
+                       continue;
+               }
+               if (!strncmp(arg, "--prefix=", 9)) {
+                       state.base_dir = arg+9;
+                       state.base_dir_len = strlen(state.base_dir);
+                       continue;
+               }
+               if (!strncmp(arg, "--stage=", 8)) {
+                       if (!strcmp(arg + 8, "all")) {
+                               to_tempfile = 1;
+                               checkout_stage = CHECKOUT_ALL;
+                       } else {
+                               int ch = arg[8];
+                               if ('1' <= ch && ch <= '3')
+                                       checkout_stage = arg[8] - '0';
+                               else
+                                       die("stage should be between 1 and 3 or all");
+                       }
+                       continue;
+               }
+               if (arg[0] == '-')
+                       usage(checkout_cache_usage);
+               break;
+       }
+ 
+       if (state.base_dir_len || to_tempfile) {
+               /* when --prefix is specified we do not
+                * want to update cache.
+                */
+               if (state.refresh_cache) {
+                       close(newfd); newfd = -1;
+                       rollback_lock_file(&lock_file);
+               }
+               state.refresh_cache = 0;
+       }
+ 
+       /* Check out named files first */
+       for ( ; i < argc; i++) {
+               const char *arg = argv[i];
+               const char *p;
+ 
+               if (all)
+                       die("git-checkout-index: don't mix '--all' and explicit filenames");
+               if (read_from_stdin)
+                       die("git-checkout-index: don't mix '--stdin' and explicit filenames");
+               p = prefix_path(prefix, prefix_length, arg);
+               checkout_file(p, prefix_length);
+               if (p < arg || p > arg + strlen(arg))
+                       free((char*)p);
+       }
+ 
+       if (read_from_stdin) {
+               struct strbuf buf;
+               if (all)
+                       die("git-checkout-index: don't mix '--all' and '--stdin'");
+               strbuf_init(&buf);
+               while (1) {
+                       char *path_name;
+                       const char *p;
+ 
+                       read_line(&buf, stdin, line_termination);
+                       if (buf.eof)
+                               break;
+                       if (line_termination && buf.buf[0] == '"')
+                               path_name = unquote_c_style(buf.buf, NULL);
+                       else
+                               path_name = buf.buf;
+                       p = prefix_path(prefix, prefix_length, path_name);
+                       checkout_file(p, prefix_length);
+                       if (p < path_name || p > path_name + strlen(path_name))
+                               free((char *)p);
+                       if (path_name != buf.buf)
+                               free(path_name);
+               }
+       }
+ 
+       if (all)
+               checkout_all(prefix, prefix_length);
+ 
+       if (0 <= newfd &&
+           (write_cache(newfd, active_cache, active_nr) ||
+            close(newfd) || commit_lock_file(&lock_file)))
+               die("Unable to write new index file");
+       return 0;
+ }

diff --cc builtin-verify-pack.c
index 0000000000000000000000000000000000000000,d700761e15e5785b8f17b161d5f45925112a214c..7d39d9bcd178a65686d6757f8a89065d25f55b23
mode 000000,100644..100644
--- /dev/null
--- 2/builtin-verify-pack.c
+++ b/builtin-verify-pack.c
@@@ -1,0 -1,79 +1,79 @@@
 -      if (has_extension(arg, len, ".pack")) {
+ #include "builtin.h"
+ #include "cache.h"
+ #include "pack.h"
+ 
+ static int verify_one_pack(const char *path, int verbose)
+ {
+       char arg[PATH_MAX];
+       int len;
+       struct packed_git *pack;
+       int err;
+ 
+       len = strlcpy(arg, path, PATH_MAX);
+       if (len >= PATH_MAX)
+               return error("name too long: %s", path);
+ 
+       /*
+        * In addition to "foo.idx" we accept "foo.pack" and "foo";
+        * normalize these forms to "foo.idx" for add_packed_git().
+        */
 -      } else if (!has_extension(arg, len, ".idx")) {
++      if (has_extension(arg, ".pack")) {
+               strcpy(arg + len - 5, ".idx");
+               len--;
++      } else if (!has_extension(arg, ".idx")) {
+               if (len + 4 >= PATH_MAX)
+                       return error("name too long: %s.idx", arg);
+               strcpy(arg + len, ".idx");
+               len += 4;
+       }
+ 
+       /*
+        * add_packed_git() uses our buffer (containing "foo.idx") to
+        * build the pack filename ("foo.pack").  Make sure it fits.
+        */
+       if (len + 1 >= PATH_MAX) {
+               arg[len - 4] = '\0';
+               return error("name too long: %s.pack", arg);
+       }
+ 
+       pack = add_packed_git(arg, len, 1);
+       if (!pack)
+               return error("packfile %s not found.", arg);
+ 
+       err = verify_pack(pack, verbose);
+       free(pack);
+ 
+       return err;
+ }
+ 
+ static const char verify_pack_usage[] = "git-verify-pack [-v] <pack>...";
+ 
+ int cmd_verify_pack(int argc, const char **argv, const char *prefix)
+ {
+       int err = 0;
+       int verbose = 0;
+       int no_more_options = 0;
+       int nothing_done = 1;
+ 
+       while (1 < argc) {
+               if (!no_more_options && argv[1][0] == '-') {
+                       if (!strcmp("-v", argv[1]))
+                               verbose = 1;
+                       else if (!strcmp("--", argv[1]))
+                               no_more_options = 1;
+                       else
+                               usage(verify_pack_usage);
+               }
+               else {
+                       if (verify_one_pack(argv[1], verbose))
+                               err = 1;
+                       nothing_done = 0;
+               }
+               argc--; argv++;
+       }
+ 
+       if (nothing_done)
+               usage(verify_pack_usage);
+ 
+       return err;
+ }

diff --cc help.c
index 0000000000000000000000000000000000000000,7a7f7759e592208b4604b6987bce8be46c936882..6484cb9df2651de7430ee608ef7d14a4d3ac4c99
mode 000000,100644..100644
--- /dev/null
--- 2/help.c
+++ b/help.c
@@@ -1,0 -1,234 +1,234 @@@
 -              if (has_extension(de->d_name, entlen, ".exe"))
+ /*
+  * builtin-help.c
+  *
+  * Builtin help-related commands (help, usage, version)
+  */
+ #include <sys/ioctl.h>
+ #include "cache.h"
+ #include "builtin.h"
+ #include "exec_cmd.h"
+ #include "common-cmds.h"
+ 
+ 
+ /* most GUI terminals set COLUMNS (although some don't export it) */
+ static int term_columns(void)
+ {
+       char *col_string = getenv("COLUMNS");
+       int n_cols = 0;
+ 
+       if (col_string && (n_cols = atoi(col_string)) > 0)
+               return n_cols;
+ 
+ #ifdef TIOCGWINSZ
+       {
+               struct winsize ws;
+               if (!ioctl(1, TIOCGWINSZ, &ws)) {
+                       if (ws.ws_col)
+                               return ws.ws_col;
+               }
+       }
+ #endif
+ 
+       return 80;
+ }
+ 
+ static void oom(void)
+ {
+       fprintf(stderr, "git: out of memory\n");
+       exit(1);
+ }
+ 
+ static inline void mput_char(char c, unsigned int num)
+ {
+       while(num--)
+               putchar(c);
+ }
+ 
+ static struct cmdname {
+       size_t len;
+       char name[1];
+ } **cmdname;
+ static int cmdname_alloc, cmdname_cnt;
+ 
+ static void add_cmdname(const char *name, int len)
+ {
+       struct cmdname *ent;
+       if (cmdname_alloc <= cmdname_cnt) {
+               cmdname_alloc = cmdname_alloc + 200;
+               cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
+               if (!cmdname)
+                       oom();
+       }
+       ent = malloc(sizeof(*ent) + len);
+       if (!ent)
+               oom();
+       ent->len = len;
+       memcpy(ent->name, name, len);
+       ent->name[len] = 0;
+       cmdname[cmdname_cnt++] = ent;
+ }
+ 
+ static int cmdname_compare(const void *a_, const void *b_)
+ {
+       struct cmdname *a = *(struct cmdname **)a_;
+       struct cmdname *b = *(struct cmdname **)b_;
+       return strcmp(a->name, b->name);
+ }
+ 
+ static void pretty_print_string_list(struct cmdname **cmdname, int longest)
+ {
+       int cols = 1, rows;
+       int space = longest + 1; /* min 1 SP between words */
+       int max_cols = term_columns() - 1; /* don't print *on* the edge */
+       int i, j;
+ 
+       if (space < max_cols)
+               cols = max_cols / space;
+       rows = (cmdname_cnt + cols - 1) / cols;
+ 
+       qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
+ 
+       for (i = 0; i < rows; i++) {
+               printf("  ");
+ 
+               for (j = 0; j < cols; j++) {
+                       int n = j * rows + i;
+                       int size = space;
+                       if (n >= cmdname_cnt)
+                               break;
+                       if (j == cols-1 || n + rows >= cmdname_cnt)
+                               size = 1;
+                       printf("%-*s", size, cmdname[n]->name);
+               }
+               putchar('\n');
+       }
+ }
+ 
+ static void list_commands(const char *exec_path, const char *pattern)
+ {
+       unsigned int longest = 0;
+       char path[PATH_MAX];
+       int dirlen;
+       DIR *dir = opendir(exec_path);
+       struct dirent *de;
+ 
+       if (!dir) {
+               fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
+               exit(1);
+       }
+ 
+       dirlen = strlen(exec_path);
+       if (PATH_MAX - 20 < dirlen) {
+               fprintf(stderr, "git: insanely long exec-path '%s'\n",
+                       exec_path);
+               exit(1);
+       }
+ 
+       memcpy(path, exec_path, dirlen);
+       path[dirlen++] = '/';
+ 
+       while ((de = readdir(dir)) != NULL) {
+               struct stat st;
+               int entlen;
+ 
+               if (strncmp(de->d_name, "git-", 4))
+                       continue;
+               strcpy(path+dirlen, de->d_name);
+               if (stat(path, &st) || /* stat, not lstat */
+                   !S_ISREG(st.st_mode) ||
+                   !(st.st_mode & S_IXUSR))
+                       continue;
+ 
+               entlen = strlen(de->d_name);
++              if (has_extension(de->d_name, ".exe"))
+                       entlen -= 4;
+ 
+               if (longest < entlen)
+                       longest = entlen;
+ 
+               add_cmdname(de->d_name + 4, entlen-4);
+       }
+       closedir(dir);
+ 
+       printf("git commands available in '%s'\n", exec_path);
+       printf("----------------------------");
+       mput_char('-', strlen(exec_path));
+       putchar('\n');
+       pretty_print_string_list(cmdname, longest - 4);
+       putchar('\n');
+ }
+ 
+ static void list_common_cmds_help(void)
+ {
+       int i, longest = 0;
+ 
+       for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+               if (longest < strlen(common_cmds[i].name))
+                       longest = strlen(common_cmds[i].name);
+       }
+ 
+       puts("The most commonly used git commands are:");
+       for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+               printf("    %s", common_cmds[i].name);
+               mput_char(' ', longest - strlen(common_cmds[i].name) + 4);
+               puts(common_cmds[i].help);
+       }
+       puts("(use 'git help -a' to get a list of all installed git commands)");
+ }
+ 
+ static void show_man_page(const char *git_cmd)
+ {
+       const char *page;
+ 
+       if (!strncmp(git_cmd, "git", 3))
+               page = git_cmd;
+       else {
+               int page_len = strlen(git_cmd) + 4;
+               char *p = malloc(page_len + 1);
+               strcpy(p, "git-");
+               strcpy(p + 4, git_cmd);
+               p[page_len] = 0;
+               page = p;
+       }
+ 
+       execlp("man", "man", page, NULL);
+ }
+ 
+ void help_unknown_cmd(const char *cmd)
+ {
+       printf("git: '%s' is not a git-command\n\n", cmd);
+       list_common_cmds_help();
+       exit(1);
+ }
+ 
+ int cmd_version(int argc, const char **argv, const char *prefix)
+ {
+       printf("git version %s\n", git_version_string);
+       return 0;
+ }
+ 
+ int cmd_help(int argc, const char **argv, const char *prefix)
+ {
+       const char *help_cmd = argc > 1 ? argv[1] : NULL;
+       const char *exec_path = git_exec_path();
+ 
+       if (!help_cmd) {
+               printf("usage: %s\n\n", git_usage_string);
+               list_common_cmds_help();
+               exit(1);
+       }
+ 
+       else if (!strcmp(help_cmd, "--all") || !strcmp(help_cmd, "-a")) {
+               printf("usage: %s\n\n", git_usage_string);
+               if(exec_path)
+                       list_commands(exec_path, "git-*");
+               exit(1);
+       }
+ 
+       else
+               show_man_page(help_cmd);
+ 
+       return 0;
+ }
+ 
+