send-pack: do not give up when remote has insanely large number of refs.
[gitweb.git] / ls-files.c
index e53d245884ab14f85824fd6c1b891481c8b1f849..90b289f03d987c6c90214fc12d00c30b4e28bb27 100644 (file)
@@ -9,6 +9,7 @@
 #include <fnmatch.h>
 
 #include "cache.h"
+#include "quote.h"
 
 static int show_deleted = 0;
 static int show_cached = 0;
@@ -16,20 +17,26 @@ static int show_others = 0;
 static int show_ignored = 0;
 static int show_stage = 0;
 static int show_unmerged = 0;
+static int show_modified = 0;
 static int show_killed = 0;
+static int show_other_directories = 0;
+static int show_valid_bit = 0;
 static int line_terminator = '\n';
 
 static int prefix_len = 0, prefix_offset = 0;
 static const char *prefix = NULL;
 static const char **pathspec = NULL;
+static int error_unmatch = 0;
+static char *ps_matched = NULL;
 
 static const char *tag_cached = "";
 static const char *tag_unmerged = "";
 static const char *tag_removed = "";
 static const char *tag_other = "";
 static const char *tag_killed = "";
+static const char *tag_modified = "";
 
-static char *exclude_per_dir = NULL;
+static const char *exclude_per_dir = NULL;
 
 /* We maintain three exclude pattern lists:
  * EXC_CMDL lists patterns explicitly given on the command line.
@@ -94,7 +101,7 @@ static int add_excludes_from_file_1(const char *fname,
        for (i = 0; i < size; i++) {
                if (buf[i] == '\n') {
                        if (entry != buf + i && entry[0] != '#') {
-                               buf[i] = 0;
+                               buf[i - (i && buf[i-1] == '\r')] = 0;
                                add_exclude(entry, base, baselen, which);
                        }
                        entry = buf + i + 1;
@@ -166,7 +173,7 @@ static int excluded_1(const char *pathname,
                        }
                        else {
                                /* match with FNM_PATHNAME:
-                                * exclude has base (baselen long) inplicitly
+                                * exclude has base (baselen long) implicitly
                                 * in front of it.
                                 */
                                int baselen = x->baselen;
@@ -205,7 +212,7 @@ static int excluded(const char *pathname)
 
 struct nond_on_fs {
        int len;
-       char name[0];
+       char name[FLEX_ARRAY]; /* more */
 };
 
 static struct nond_on_fs **dir;
@@ -230,6 +237,17 @@ static void add_name(const char *pathname, int len)
        dir[nr_dir++] = ent;
 }
 
+static int dir_exists(const char *dirname, int len)
+{
+       int pos = cache_name_pos(dirname, len);
+       if (pos >= 0)
+               return 1;
+       pos = -pos-1;
+       if (pos >= active_nr) /* can't */
+               return 0;
+       return !strncmp(active_cache[pos]->name, dirname, len);
+}
+
 /*
  * Read a directory tree. We currently ignore anything but
  * directories, regular files and symlinks. That's because git
@@ -278,8 +296,12 @@ static void read_directory(const char *path, const char *base, int baselen)
                                /* fallthrough */
                        case DT_DIR:
                                memcpy(fullname + baselen + len, "/", 2);
+                               len++;
+                               if (show_other_directories &&
+                                   !dir_exists(fullname, baselen + len))
+                                       break;
                                read_directory(fullname, fullname,
-                                              baselen + len + 1);
+                                              baselen + len);
                                continue;
                        case DT_REG:
                        case DT_LNK:
@@ -306,7 +328,8 @@ static int cmp_name(const void *p1, const void *p2)
  * Match a pathspec against a filename. The first "len" characters
  * are the common prefix
  */
-static int match(const char **spec, const char *filename, int len)
+static int match(const char **spec, char *ps_matched,
+                const char *filename, int len)
 {
        const char *m;
 
@@ -314,17 +337,24 @@ static int match(const char **spec, const char *filename, int len)
                int matchlen = strlen(m + len);
 
                if (!matchlen)
-                       return 1;
+                       goto matched;
                if (!strncmp(m + len, filename + len, matchlen)) {
                        if (m[len + matchlen - 1] == '/')
-                               return 1;
+                               goto matched;
                        switch (filename[len + matchlen]) {
                        case '/': case '\0':
-                               return 1;
+                               goto matched;
                        }
                }
                if (!fnmatch(m + len, filename + len, 0))
-                       return 1;
+                       goto matched;
+               if (ps_matched)
+                       ps_matched++;
+               continue;
+       matched:
+               if (ps_matched)
+                       *ps_matched = 1;
+               return 1;
        }
        return 0;
 }
@@ -337,10 +367,35 @@ static void show_dir_entry(const char *tag, struct nond_on_fs *ent)
        if (len >= ent->len)
                die("git-ls-files: internal error - directory entry not superset of prefix");
 
-       if (pathspec && !match(pathspec, ent->name, len))
+       if (pathspec && !match(pathspec, ps_matched, ent->name, len))
                return;
 
-       printf("%s%s%c", tag, ent->name + offset, line_terminator);
+       fputs(tag, stdout);
+       write_name_quoted("", 0, ent->name + offset, line_terminator, stdout);
+       putchar(line_terminator);
+}
+
+static void show_other_files(void)
+{
+       int i;
+       for (i = 0; i < nr_dir; i++) {
+               /* We should not have a matching entry, but we
+                * may have an unmerged entry for this path.
+                */
+               struct nond_on_fs *ent = dir[i];
+               int pos = cache_name_pos(ent->name, ent->len);
+               struct cache_entry *ce;
+               if (0 <= pos)
+                       die("bug in show-other-files");
+               pos = -pos - 1;
+               if (pos < active_nr) { 
+                       ce = active_cache[pos];
+                       if (ce_namelen(ce) == ent->len &&
+                           !memcmp(ce->name, ent->name, ent->len))
+                               continue; /* Yup, this one exists unmerged */
+               }
+               show_dir_entry(tag_other, ent);
+       }
 }
 
 static void show_killed_files(void)
@@ -400,18 +455,42 @@ static void show_ce_entry(const char *tag, struct cache_entry *ce)
        if (len >= ce_namelen(ce))
                die("git-ls-files: internal error - cache entry not superset of prefix");
 
-       if (pathspec && !match(pathspec, ce->name, len))
+       if (pathspec && !match(pathspec, ps_matched, ce->name, len))
                return;
 
-       if (!show_stage)
-               printf("%s%s%c", tag, ce->name + offset, line_terminator);
-       else
-               printf("%s%06o %s %d\t%s%c",
+       if (tag && *tag && show_valid_bit &&
+           (ce->ce_flags & htons(CE_VALID))) {
+               static char alttag[4];
+               memcpy(alttag, tag, 3);
+               if (isalpha(tag[0]))
+                       alttag[0] = tolower(tag[0]);
+               else if (tag[0] == '?')
+                       alttag[0] = '!';
+               else {
+                       alttag[0] = 'v';
+                       alttag[1] = tag[0];
+                       alttag[2] = ' ';
+                       alttag[3] = 0;
+               }
+               tag = alttag;
+       }
+
+       if (!show_stage) {
+               fputs(tag, stdout);
+               write_name_quoted("", 0, ce->name + offset,
+                                 line_terminator, stdout);
+               putchar(line_terminator);
+       }
+       else {
+               printf("%s%06o %s %d\t",
                       tag,
                       ntohl(ce->ce_mode),
                       sha1_to_hex(ce->sha1),
-                      ce_stage(ce),
-                      ce->name + offset, line_terminator); 
+                      ce_stage(ce));
+               write_name_quoted("", 0, ce->name + offset,
+                                 line_terminator, stdout);
+               putchar(line_terminator);
+       }
 }
 
 static void show_files(void)
@@ -423,13 +502,32 @@ static void show_files(void)
                const char *path = ".", *base = "";
                int baselen = prefix_len;
 
-               if (baselen)
+               if (baselen) {
                        path = base = prefix;
+                       if (exclude_per_dir) {
+                               char *p, *pp = xmalloc(baselen+1);
+                               memcpy(pp, prefix, baselen+1);
+                               p = pp;
+                               while (1) {
+                                       char save = *p;
+                                       *p = 0;
+                                       push_exclude_per_directory(pp, p-pp);
+                                       *p++ = save;
+                                       if (!save)
+                                               break;
+                                       p = strchr(p, '/');
+                                       if (p)
+                                               p++;
+                                       else
+                                               p = pp + baselen;
+                               }
+                               free(pp);
+                       }
+               }
                read_directory(path, base, baselen);
                qsort(dir, nr_dir, sizeof(struct nond_on_fs *), cmp_name);
                if (show_others)
-                       for (i = 0; i < nr_dir; i++)
-                               show_dir_entry(tag_other, dir[i]);
+                       show_other_files();
                if (show_killed)
                        show_killed_files();
        }
@@ -443,15 +541,18 @@ static void show_files(void)
                        show_ce_entry(ce_stage(ce) ? tag_unmerged : tag_cached, ce);
                }
        }
-       if (show_deleted) {
+       if (show_deleted | show_modified) {
                for (i = 0; i < active_nr; i++) {
                        struct cache_entry *ce = active_cache[i];
                        struct stat st;
+                       int err;
                        if (excluded(ce->name) != show_ignored)
                                continue;
-                       if (!lstat(ce->name, &st))
-                               continue;
-                       show_ce_entry(tag_removed, ce);
+                       err = lstat(ce->name, &st);
+                       if (show_deleted && err)
+                               show_ce_entry(tag_removed, ce);
+                       if (show_modified && ce_modified(ce, &st, 0))
+                               show_ce_entry(tag_modified, ce);
                }
        }
 }
@@ -523,11 +624,11 @@ static void verify_pathspec(void)
 }
 
 static const char ls_files_usage[] =
-       "git-ls-files [-z] [-t] (--[cached|deleted|others|stage|unmerged|killed])* "
+       "git-ls-files [-z] [-t] [-v] (--[cached|deleted|others|stage|unmerged|killed|modified])* "
        "[ --ignored ] [--exclude=<pattern>] [--exclude-from=<file>] "
-       "[ --exclude-per-directory=<filename> ]";
+       "[ --exclude-per-directory=<filename> ] [--full-name] [--] [<file>]*";
 
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
 {
        int i;
        int exc_given = 0;
@@ -535,20 +636,28 @@ int main(int argc, char **argv)
        prefix = setup_git_directory();
        if (prefix)
                prefix_offset = strlen(prefix);
+       git_config(git_default_config);
 
        for (i = 1; i < argc; i++) {
-               char *arg = argv[i];
+               const char *arg = argv[i];
 
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       break;
+               }
                if (!strcmp(arg, "-z")) {
                        line_terminator = 0;
                        continue;
                }
-               if (!strcmp(arg, "-t")) {
+               if (!strcmp(arg, "-t") || !strcmp(arg, "-v")) {
                        tag_cached = "H ";
                        tag_unmerged = "M ";
                        tag_removed = "R ";
+                       tag_modified = "C ";
                        tag_other = "? ";
                        tag_killed = "K ";
+                       if (arg[1] == 'v')
+                               show_valid_bit = 1;
                        continue;
                }
                if (!strcmp(arg, "-c") || !strcmp(arg, "--cached")) {
@@ -559,6 +668,10 @@ int main(int argc, char **argv)
                        show_deleted = 1;
                        continue;
                }
+               if (!strcmp(arg, "-m") || !strcmp(arg, "--modified")) {
+                       show_modified = 1;
+                       continue;
+               }
                if (!strcmp(arg, "-o") || !strcmp(arg, "--others")) {
                        show_others = 1;
                        continue;
@@ -575,6 +688,10 @@ int main(int argc, char **argv)
                        show_killed = 1;
                        continue;
                }
+               if (!strcmp(arg, "--directory")) {
+                       show_other_directories = 1;
+                       continue;
+               }
                if (!strcmp(arg, "-u") || !strcmp(arg, "--unmerged")) {
                        /* There's no point in showing unmerged unless
                         * you also show the stage information.
@@ -612,6 +729,10 @@ int main(int argc, char **argv)
                        prefix_offset = 0;
                        continue;
                }
+               if (!strcmp(arg, "--error-unmatch")) {
+                       error_unmatch = 1;
+                       continue;
+               }
                if (*arg == '-')
                        usage(ls_files_usage);
                break;
@@ -623,6 +744,14 @@ int main(int argc, char **argv)
        if (pathspec)
                verify_pathspec();
 
+       /* Treat unmatching pathspec elements as errors */
+       if (pathspec && error_unmatch) {
+               int num;
+               for (num = 0; pathspec[num]; num++)
+                       ;
+               ps_matched = xcalloc(1, num);
+       }
+
        if (show_ignored && !exc_given) {
                fprintf(stderr, "%s: --ignored needs some exclude pattern\n",
                        argv[0]);
@@ -630,12 +759,29 @@ int main(int argc, char **argv)
        }
 
        /* With no flags, we default to showing the cached files */
-       if (!(show_stage | show_deleted | show_others | show_unmerged | show_killed))
+       if (!(show_stage | show_deleted | show_others | show_unmerged |
+             show_killed | show_modified))
                show_cached = 1;
 
        read_cache();
        if (prefix)
                prune_cache();
        show_files();
+
+       if (ps_matched) {
+               /* We need to make sure all pathspec matched otherwise
+                * it is an error.
+                */
+               int num, errors = 0;
+               for (num = 0; pathspec[num]; num++) {
+                       if (ps_matched[num])
+                               continue;
+                       error("pathspec '%s' did not match any.",
+                             pathspec[num] + prefix_offset);
+                       errors++;
+               }
+               return errors ? 1 : 0;
+       }
+
        return 0;
 }