Merge branch 'lt/dirwalk'

This makes 'git add' and 'git rm' built-ins.

* lt/dirwalk:
  Add builtin "git rm" command
  Move pathspec matching from builtin-add.c into dir.c
  Prevent bogus paths from being added to the index.
  builtin-add: fix unmatched pathspec warnings.
  Remove old "git-add.sh" remnants
  builtin-add: warn on unmatched pathspecs
  Do "git add" as a builtin
  Clean up git-ls-file directory walking library interface
  libify git-ls-files directory traversal

diff --cc Makefile
index 5423b7a,d4a9113..46c83cb
--- 1/Makefile
--- 2/Makefile
+++ b/Makefile
@@@ -170,8 -170,8 +170,9 @@@ PROGRAMS = 
  
  BUILT_INS = git-log$X git-whatchanged$X git-show$X \
        git-count-objects$X git-diff$X git-push$X \
-       git-grep$X git-rev-list$X git-check-ref-format$X \
+       git-grep$X git-add$X git-rm$X git-rev-list$X \
 -      git-check-ref-format$X
++      git-check-ref-format$X \
 +      git-init-db$X
  
  # what 'all' will build and 'install' will install, in gitexecdir
  ALL_PROGRAMS = $(PROGRAMS) $(SIMPLE_PROGRAMS) $(SCRIPTS)
@@@ -219,8 -219,8 +220,8 @@@ LIB_OBJS = 
  
  BUILTIN_OBJS = \
        builtin-log.o builtin-help.o builtin-count.o builtin-diff.o builtin-push.o \
-       builtin-grep.o builtin-rev-list.o builtin-check-ref-format.o \
-       builtin-init-db.o
+       builtin-grep.o builtin-add.o builtin-rev-list.o builtin-check-ref-format.o \
 -      builtin-rm.o
++      builtin-rm.o builtin-init-db.o
  
  GITLIBS = $(LIB_FILE) $(XDIFF_LIB)
  LIBS = $(GITLIBS) -lz

diff --cc builtin.h
index 6054126,c1cb765..1a41d47
--- 1/builtin.h
--- 2/builtin.h
+++ b/builtin.h
@@@ -24,8 -24,7 +24,10 @@@ extern int cmd_count_objects(int argc, 
  
  extern int cmd_push(int argc, const char **argv, char **envp);
  extern int cmd_grep(int argc, const char **argv, char **envp);
+ extern int cmd_rm(int argc, const char **argv, char **envp);
+ extern int cmd_add(int argc, const char **argv, char **envp);
 +extern int cmd_rev_list(int argc, const char **argv, char **envp);
 +extern int cmd_check_ref_format(int argc, const char **argv, char **envp);
 +extern int cmd_init_db(int argc, const char **argv, char **envp);
  
  #endif

diff --cc cache.h
Simple merge

diff --cc git.c
index 3216d31,20c0f19..4a2c4ba
--- 1/git.c
--- 2/git.c
+++ b/git.c
@@@ -50,9 -50,8 +50,11 @@@ static void handle_internal_command(in
                { "count-objects", cmd_count_objects },
                { "diff", cmd_diff },
                { "grep", cmd_grep },
+               { "rm", cmd_rm },
+               { "add", cmd_add },
 +              { "rev-list", cmd_rev_list },
 +              { "init-db", cmd_init_db },
 +              { "check-ref-format", cmd_check_ref_format }
        };
        int i;
  

diff --cc read-cache.c
Simple merge

diff --cc update-index.c
index 7d6de82,859efc7..5854d11
--- 1/update-index.c
--- 2/update-index.c
+++ b/update-index.c
@@@ -120,70 -140,103 +120,6 @@@ static int add_file_to_cache(const cha
        return 0;
  }
  
--/*
-  * We fundamentally don't like some paths: we don't want
-  * dot or dot-dot anywhere, and for obvious reasons don't
-  * want to recurse into ".git" either.
 - * "refresh" does not calculate a new sha1 file or bring the
 - * cache up-to-date for mode/content changes. But what it
 - * _does_ do is to "re-match" the stat information of a file
 - * with the cache, so that you can refresh the cache for a
 - * file that hasn't been changed but where the stat entry is
 - * out of date.
-- *
-  * Also, we don't want double slashes or slashes at the
-  * end that can make pathnames ambiguous.
 - * For example, you'd want to do this after doing a "git-read-tree",
 - * to link up the stat cache details with the proper files.
-- */
- static int verify_dotfile(const char *rest)
 -static struct cache_entry *refresh_entry(struct cache_entry *ce, int really)
--{
-       /*
-        * The first character was '.', but that
-        * has already been discarded, we now test
-        * the rest.
-        */
-       switch (*rest) {
-       /* "." is not allowed */
-       case '\0': case '/':
-               return 0;
 -      struct stat st;
 -      struct cache_entry *updated;
 -      int changed, size;
--
-       /*
-        * ".git" followed by  NUL or slash is bad. This
-        * shares the path end test with the ".." case.
-        */
-       case 'g':
-               if (rest[1] != 'i')
-                       break;
-               if (rest[2] != 't')
-                       break;
-               rest += 2;
-       /* fallthrough */
-       case '.':
-               if (rest[1] == '\0' || rest[1] == '/')
-                       return 0;
 -      if (lstat(ce->name, &st) < 0)
 -              return ERR_PTR(-errno);
 -
 -      changed = ce_match_stat(ce, &st, really);
 -      if (!changed) {
 -              if (really && assume_unchanged &&
 -                  !(ce->ce_flags & htons(CE_VALID)))
 -                      ; /* mark this one VALID again */
 -              else
 -                      return NULL;
--      }
-       return 1;
 -
 -      if (ce_modified(ce, &st, really))
 -              return ERR_PTR(-EINVAL);
 -
 -      size = ce_size(ce);
 -      updated = xmalloc(size);
 -      memcpy(updated, ce, size);
 -      fill_stat_cache_info(updated, &st);
 -
 -      /* In this case, if really is not set, we should leave
 -       * CE_VALID bit alone.  Otherwise, paths marked with
 -       * --no-assume-unchanged (i.e. things to be edited) will
 -       * reacquire CE_VALID bit automatically, which is not
 -       * really what we want.
 -       */
 -      if (!really && assume_unchanged && !(ce->ce_flags & htons(CE_VALID)))
 -              updated->ce_flags &= ~htons(CE_VALID);
 -
 -      return updated;
--}
--
- static int verify_path(const char *path)
 -static int refresh_cache(int really)
--{
-       char c;
 -      int i;
 -      int has_errors = 0;
--
-       goto inside;
-       for (;;) {
-               if (!c)
-                       return 1;
-               if (c == '/') {
- inside:
-                       c = *path++;
-                       switch (c) {
-                       default:
 -      for (i = 0; i < active_nr; i++) {
 -              struct cache_entry *ce, *new;
 -              ce = active_cache[i];
 -              if (ce_stage(ce)) {
 -                      while ((i < active_nr) &&
 -                             ! strcmp(active_cache[i]->name, ce->name))
 -                              i++;
 -                      i--;
 -                      if (allow_unmerged)
--                              continue;
-                       case '/': case '\0':
-                               break;
-                       case '.':
-                               if (verify_dotfile(path))
-                                       continue;
 -                      printf("%s: needs merge\n", ce->name);
 -                      has_errors = 1;
 -                      continue;
 -              }
 -
 -              new = refresh_entry(ce, really);
 -              if (!new)
 -                      continue;
 -              if (IS_ERR(new)) {
 -                      if (not_new && PTR_ERR(new) == -ENOENT)
 -                              continue;
 -                      if (really && PTR_ERR(new) == -EINVAL) {
 -                              /* If we are doing --really-refresh that
 -                               * means the index is not valid anymore.
 -                               */
 -                              ce->ce_flags &= ~htons(CE_VALID);
 -                              active_cache_changed = 1;
--                      }
-                       return 0;
 -                      if (quiet)
 -                              continue;
 -                      printf("%s: needs update\n", ce->name);
 -                      has_errors = 1;
 -                      continue;
--              }
-               c = *path++;
 -              active_cache_changed = 1;
 -              /* You can NOT just free active_cache[i] here, since it
 -               * might not be necessarily malloc()ed but can also come
 -               * from mmap(). */
 -              active_cache[i] = new;
--      }
 -      return has_errors;
--}
--
  static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
                         const char *path, int stage)
  {