Merge branch 'master' into js/fmt-patch

* master: (119 commits)
  diff family: add --check option
  Document that "git add" only adds non-ignored files.
  Add a conversion tool to migrate remote information into the config
  fetch, pull: ask config for remote information
  Fix build procedure for builtin-init-db
  read-tree -m -u: do not overwrite or remove untracked working tree files.
  apply --cached: do not check newly added file in the working tree
  Implement a --dry-run option to git-quiltimport
  Implement git-quiltimport
  Revert "builtin-grep: workaround for non GNU grep."
  builtin-grep: workaround for non GNU grep.
  builtin-grep: workaround for non GNU grep.
  git-am: use apply --cached
  apply --cached: apply a patch without using working tree.
  apply --numstat: show new name, not old name.
  Documentation/Makefile: create tarballs for the man pages and html files
  Allow pickaxe and diff-filter options to be used by git log.
  Libify the index refresh logic
  Builtin git-init-db
  Remove unnecessary local in get_ref_sha1.
  ...

diff --cc builtin-diff.c
Simple merge

diff --cc builtin-log.c
Simple merge

diff --cc builtin-rev-list.c
index 0000000000000000000000000000000000000000,446802d37758c0aa5b2ff3ec917b49316d303312..7942297d137aa3ccd6bf5f6b4bca1afa35ae5450
mode 000000,100644..100644
--- /dev/null
--- 2/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@@ -1,0 -1,358 +1,358 @@@
 -                                  revs.abbrev);
+ #include "cache.h"
+ #include "refs.h"
+ #include "tag.h"
+ #include "commit.h"
+ #include "tree.h"
+ #include "blob.h"
+ #include "tree-walk.h"
+ #include "diff.h"
+ #include "revision.h"
+ #include "builtin.h"
+ 
+ /* bits #0-15 in revision.h */
+ 
+ #define COUNTED               (1u<<16)
+ 
+ static const char rev_list_usage[] =
+ "git-rev-list [OPTION] <commit-id>... [ -- paths... ]\n"
+ "  limiting output:\n"
+ "    --max-count=nr\n"
+ "    --max-age=epoch\n"
+ "    --min-age=epoch\n"
+ "    --sparse\n"
+ "    --no-merges\n"
+ "    --remove-empty\n"
+ "    --all\n"
+ "  ordering output:\n"
+ "    --topo-order\n"
+ "    --date-order\n"
+ "  formatting output:\n"
+ "    --parents\n"
+ "    --objects | --objects-edge\n"
+ "    --unpacked\n"
+ "    --header | --pretty\n"
+ "    --abbrev=nr | --no-abbrev\n"
+ "    --abbrev-commit\n"
+ "  special purpose:\n"
+ "    --bisect"
+ ;
+ 
+ static struct rev_info revs;
+ 
+ static int bisect_list = 0;
+ static int show_timestamp = 0;
+ static int hdr_termination = 0;
+ static const char *header_prefix;
+ 
+ static void show_commit(struct commit *commit)
+ {
+       if (show_timestamp)
+               printf("%lu ", commit->date);
+       if (header_prefix)
+               fputs(header_prefix, stdout);
+       if (commit->object.flags & BOUNDARY)
+               putchar('-');
+       if (revs.abbrev_commit && revs.abbrev)
+               fputs(find_unique_abbrev(commit->object.sha1, revs.abbrev),
+                     stdout);
+       else
+               fputs(sha1_to_hex(commit->object.sha1), stdout);
+       if (revs.parents) {
+               struct commit_list *parents = commit->parents;
+               while (parents) {
+                       struct object *o = &(parents->item->object);
+                       parents = parents->next;
+                       if (o->flags & TMP_MARK)
+                               continue;
+                       printf(" %s", sha1_to_hex(o->sha1));
+                       o->flags |= TMP_MARK;
+               }
+               /* TMP_MARK is a general purpose flag that can
+                * be used locally, but the user should clean
+                * things up after it is done with them.
+                */
+               for (parents = commit->parents;
+                    parents;
+                    parents = parents->next)
+                       parents->item->object.flags &= ~TMP_MARK;
+       }
+       if (revs.commit_format == CMIT_FMT_ONELINE)
+               putchar(' ');
+       else
+               putchar('\n');
+ 
+       if (revs.verbose_header) {
+               static char pretty_header[16384];
+               pretty_print_commit(revs.commit_format, commit, ~0,
+                                   pretty_header, sizeof(pretty_header),
++                                  revs.abbrev, NULL);
+               printf("%s%c", pretty_header, hdr_termination);
+       }
+       fflush(stdout);
+ }
+ 
+ static struct object_list **process_blob(struct blob *blob,
+                                        struct object_list **p,
+                                        struct name_path *path,
+                                        const char *name)
+ {
+       struct object *obj = &blob->object;
+ 
+       if (!revs.blob_objects)
+               return p;
+       if (obj->flags & (UNINTERESTING | SEEN))
+               return p;
+       obj->flags |= SEEN;
+       return add_object(obj, p, path, name);
+ }
+ 
+ static struct object_list **process_tree(struct tree *tree,
+                                        struct object_list **p,
+                                        struct name_path *path,
+                                        const char *name)
+ {
+       struct object *obj = &tree->object;
+       struct tree_entry_list *entry;
+       struct name_path me;
+ 
+       if (!revs.tree_objects)
+               return p;
+       if (obj->flags & (UNINTERESTING | SEEN))
+               return p;
+       if (parse_tree(tree) < 0)
+               die("bad tree object %s", sha1_to_hex(obj->sha1));
+       obj->flags |= SEEN;
+       p = add_object(obj, p, path, name);
+       me.up = path;
+       me.elem = name;
+       me.elem_len = strlen(name);
+       entry = tree->entries;
+       tree->entries = NULL;
+       while (entry) {
+               struct tree_entry_list *next = entry->next;
+               if (entry->directory)
+                       p = process_tree(entry->item.tree, p, &me, entry->name);
+               else
+                       p = process_blob(entry->item.blob, p, &me, entry->name);
+               free(entry);
+               entry = next;
+       }
+       return p;
+ }
+ 
+ static void show_commit_list(struct rev_info *revs)
+ {
+       struct commit *commit;
+       struct object_list *objects = NULL, **p = &objects, *pending;
+ 
+       while ((commit = get_revision(revs)) != NULL) {
+               p = process_tree(commit->tree, p, NULL, "");
+               show_commit(commit);
+       }
+       for (pending = revs->pending_objects; pending; pending = pending->next) {
+               struct object *obj = pending->item;
+               const char *name = pending->name;
+               if (obj->flags & (UNINTERESTING | SEEN))
+                       continue;
+               if (obj->type == tag_type) {
+                       obj->flags |= SEEN;
+                       p = add_object(obj, p, NULL, name);
+                       continue;
+               }
+               if (obj->type == tree_type) {
+                       p = process_tree((struct tree *)obj, p, NULL, name);
+                       continue;
+               }
+               if (obj->type == blob_type) {
+                       p = process_blob((struct blob *)obj, p, NULL, name);
+                       continue;
+               }
+               die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
+       }
+       while (objects) {
+               /* An object with name "foo\n0000000..." can be used to
+                * confuse downstream git-pack-objects very badly.
+                */
+               const char *ep = strchr(objects->name, '\n');
+               if (ep) {
+                       printf("%s %.*s\n", sha1_to_hex(objects->item->sha1),
+                              (int) (ep - objects->name),
+                              objects->name);
+               }
+               else
+                       printf("%s %s\n", sha1_to_hex(objects->item->sha1), objects->name);
+               objects = objects->next;
+       }
+ }
+ 
+ /*
+  * This is a truly stupid algorithm, but it's only
+  * used for bisection, and we just don't care enough.
+  *
+  * We care just barely enough to avoid recursing for
+  * non-merge entries.
+  */
+ static int count_distance(struct commit_list *entry)
+ {
+       int nr = 0;
+ 
+       while (entry) {
+               struct commit *commit = entry->item;
+               struct commit_list *p;
+ 
+               if (commit->object.flags & (UNINTERESTING | COUNTED))
+                       break;
+               if (!revs.prune_fn || (commit->object.flags & TREECHANGE))
+                       nr++;
+               commit->object.flags |= COUNTED;
+               p = commit->parents;
+               entry = p;
+               if (p) {
+                       p = p->next;
+                       while (p) {
+                               nr += count_distance(p);
+                               p = p->next;
+                       }
+               }
+       }
+ 
+       return nr;
+ }
+ 
+ static void clear_distance(struct commit_list *list)
+ {
+       while (list) {
+               struct commit *commit = list->item;
+               commit->object.flags &= ~COUNTED;
+               list = list->next;
+       }
+ }
+ 
+ static struct commit_list *find_bisection(struct commit_list *list)
+ {
+       int nr, closest;
+       struct commit_list *p, *best;
+ 
+       nr = 0;
+       p = list;
+       while (p) {
+               if (!revs.prune_fn || (p->item->object.flags & TREECHANGE))
+                       nr++;
+               p = p->next;
+       }
+       closest = 0;
+       best = list;
+ 
+       for (p = list; p; p = p->next) {
+               int distance;
+ 
+               if (revs.prune_fn && !(p->item->object.flags & TREECHANGE))
+                       continue;
+ 
+               distance = count_distance(p);
+               clear_distance(list);
+               if (nr - distance < distance)
+                       distance = nr - distance;
+               if (distance > closest) {
+                       best = p;
+                       closest = distance;
+               }
+       }
+       if (best)
+               best->next = NULL;
+       return best;
+ }
+ 
+ static void mark_edge_parents_uninteresting(struct commit *commit)
+ {
+       struct commit_list *parents;
+ 
+       for (parents = commit->parents; parents; parents = parents->next) {
+               struct commit *parent = parents->item;
+               if (!(parent->object.flags & UNINTERESTING))
+                       continue;
+               mark_tree_uninteresting(parent->tree);
+               if (revs.edge_hint && !(parent->object.flags & SHOWN)) {
+                       parent->object.flags |= SHOWN;
+                       printf("-%s\n", sha1_to_hex(parent->object.sha1));
+               }
+       }
+ }
+ 
+ static void mark_edges_uninteresting(struct commit_list *list)
+ {
+       for ( ; list; list = list->next) {
+               struct commit *commit = list->item;
+ 
+               if (commit->object.flags & UNINTERESTING) {
+                       mark_tree_uninteresting(commit->tree);
+                       continue;
+               }
+               mark_edge_parents_uninteresting(commit);
+       }
+ }
+ 
+ int cmd_rev_list(int argc, const char **argv, char **envp)
+ {
+       struct commit_list *list;
+       int i;
+ 
+       init_revisions(&revs);
+       revs.abbrev = 0;
+       revs.commit_format = CMIT_FMT_UNSPECIFIED;
+       argc = setup_revisions(argc, argv, &revs, NULL);
+ 
+       for (i = 1 ; i < argc; i++) {
+               const char *arg = argv[i];
+ 
+               if (!strcmp(arg, "--header")) {
+                       revs.verbose_header = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "--timestamp")) {
+                       show_timestamp = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "--bisect")) {
+                       bisect_list = 1;
+                       continue;
+               }
+               usage(rev_list_usage);
+ 
+       }
+       if (revs.commit_format != CMIT_FMT_UNSPECIFIED) {
+               /* The command line has a --pretty  */
+               hdr_termination = '\n';
+               if (revs.commit_format == CMIT_FMT_ONELINE)
+                       header_prefix = "";
+               else
+                       header_prefix = "commit ";
+       }
+       else if (revs.verbose_header)
+               /* Only --header was specified */
+               revs.commit_format = CMIT_FMT_RAW;
+ 
+       list = revs.commits;
+ 
+       if ((!list &&
+            (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) &&
+             !revs.pending_objects)) ||
+           revs.diff)
+               usage(rev_list_usage);
+ 
+       save_commit_buffer = revs.verbose_header;
+       track_object_refs = 0;
+       if (bisect_list)
+               revs.limited = 1;
+ 
+       prepare_revision_walk(&revs);
+       if (revs.tree_objects)
+               mark_edges_uninteresting(revs.commits);
+ 
+       if (bisect_list)
+               revs.commits = find_bisection(revs.commits);
+ 
+       show_commit_list(&revs);
+ 
+       return 0;
+ }

diff --cc builtin.h
Simple merge

diff --cc cache.h
Simple merge

diff --cc commit.c
index 93b3903ea78fac0b5a40074ec64d0c98bb8cfa94,4a26070c137243bf099cf10415b2910eca230368..84558bac29afd64e295a451ad7baa099237ae045
--- 1/commit.c
--- 2/commit.c
+++ b/commit.c
@@@ -22,25 -22,33 +22,34 @@@ struct sort_nod
  
  const char *commit_type = "commit";
  
+ struct cmt_fmt_map {
+       const char *n;
+       size_t cmp_len;
+       enum cmit_fmt v;
+ } cmt_fmts[] = {
+       { "raw",        1,      CMIT_FMT_RAW },
+       { "medium",     1,      CMIT_FMT_MEDIUM },
+       { "short",      1,      CMIT_FMT_SHORT },
++      { "email",      1,      CMIT_FMT_EMAIL },
+       { "full",       5,      CMIT_FMT_FULL },
+       { "fuller",     5,      CMIT_FMT_FULLER },
+       { "oneline",    1,      CMIT_FMT_ONELINE },
+ };
+ 
  enum cmit_fmt get_commit_format(const char *arg)
  {
-       if (!*arg)
+       int i;
+ 
+       if (!arg || !*arg)
                return CMIT_FMT_DEFAULT;
-       if (!strcmp(arg, "=raw"))
-               return CMIT_FMT_RAW;
-       if (!strcmp(arg, "=medium"))
-               return CMIT_FMT_MEDIUM;
-       if (!strcmp(arg, "=short"))
-               return CMIT_FMT_SHORT;
-       if (!strcmp(arg, "=full"))
-               return CMIT_FMT_FULL;
-       if (!strcmp(arg, "=fuller"))
-               return CMIT_FMT_FULLER;
-       if (!strcmp(arg, "=email"))
-               return CMIT_FMT_EMAIL;
-       if (!strcmp(arg, "=oneline"))
-               return CMIT_FMT_ONELINE;
-       die("invalid --pretty format");
+       if (*arg == '=')
+               arg++;
+       for (i = 0; i < ARRAY_SIZE(cmt_fmts); i++) {
+               if (!strncmp(arg, cmt_fmts[i].n, cmt_fmts[i].cmp_len))
+                       return cmt_fmts[i].v;
+       }
+ 
+       die("invalid --pretty format: %s", arg);
  }
  
  static struct commit *check_commit(struct object *obj,

diff --cc git.c
index a8f7926b4875512b1d93768c1bc6d934111954f6,3216d311b2efdd238f0eb023d6a918e0a43b54ab..f4dff02bd3c2711a2eeac72be7b604bceda1a664
--- 1/git.c
--- 2/git.c
+++ b/git.c
@@@ -47,9 -47,12 +47,13 @@@ static void handle_internal_command(in
                { "whatchanged", cmd_whatchanged },
                { "show", cmd_show },
                { "push", cmd_push },
 +              { "fmt-patch", cmd_format_patch },
                { "count-objects", cmd_count_objects },
                { "diff", cmd_diff },
+               { "grep", cmd_grep },
+               { "rev-list", cmd_rev_list },
+               { "init-db", cmd_init_db },
+               { "check-ref-format", cmd_check_ref_format }
        };
        int i;