git-tar-tree: no more void pointer arithmetic

[git.git] / builtin-grep.c

diff --git a/builtin-grep.c b/builtin-grep.c
index 3d6e515..9806499 100644 (file)
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -453,13 +453,14 @@ static int external_grep(struct grep_opt *opt, const char **paths, int cached)
 
        len = nr = 0;
        push_arg("grep");
-       push_arg("-H");
        if (opt->fixed)
-               push_arg("-H");
+               push_arg("-F");
        if (opt->linenum)
                push_arg("-n");
        if (opt->regflags & REG_EXTENDED)
                push_arg("-E");
+       if (opt->regflags & REG_ICASE)
+               push_arg("-i");
        if (opt->word_regexp)
                push_arg("-w");
        if (opt->name_only)
@@ -503,17 +504,35 @@ static int external_grep(struct grep_opt *opt, const char **paths, int cached)
                push_arg("-e");
                push_arg(p->pattern);
        }
-       push_arg("--");
+
+       /*
+        * To make sure we get the header printed out when we want it,
+        * add /dev/null to the paths to grep.  This is unnecessary
+        * (and wrong) with "-l" or "-L", which always print out the
+        * name anyway.
+        *
+        * GNU grep has "-H", but this is portable.
+        */
+       if (!opt->name_only && !opt->unmatch_name_only)
+               push_arg("/dev/null");
 
        hit = 0;
        argc = nr;
        for (i = 0; i < active_nr; i++) {
                struct cache_entry *ce = active_cache[i];
+               char *name;
                if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))
                        continue;
                if (!pathspec_matches(paths, ce->name))
                        continue;
-               argv[argc++] = ce->name;
+               name = ce->name;
+               if (name[0] == '-') {
+                       int len = ce_namelen(ce);
+                       name = xmalloc(len + 3);
+                       memcpy(name, "./", 2);
+                       memcpy(name + 2, ce->name, len + 1);
+               }
+               argv[argc++] = name;
                if (argc < MAXARGS)
                        continue;
                hit += exec_grep(argc, argv);
@@ -561,11 +580,9 @@ static int grep_tree(struct grep_opt *opt, const char **paths,
                     struct tree_desc *tree,
                     const char *tree_name, const char *base)
 {
-       unsigned mode;
        int len;
        int hit = 0;
-       const char *path;
-       const unsigned char *sha1;
+       struct name_entry entry;
        char *down;
        char *path_buf = xmalloc(PATH_MAX + strlen(tree_name) + 100);
 
@@ -580,36 +597,32 @@ static int grep_tree(struct grep_opt *opt, const char **paths,
        }
        len = strlen(path_buf);
 
-       while (tree->size) {
-               int pathlen;
-               sha1 = tree_entry_extract(tree, &path, &mode);
-               pathlen = strlen(path);
-               strcpy(path_buf + len, path);
+       while (tree_entry(tree, &entry)) {
+               strcpy(path_buf + len, entry.path);
 
-               if (S_ISDIR(mode))
+               if (S_ISDIR(entry.mode))
                        /* Match "abc/" against pathspec to
                         * decide if we want to descend into "abc"
                         * directory.
                         */
-                       strcpy(path_buf + len + pathlen, "/");
+                       strcpy(path_buf + len + entry.pathlen, "/");
 
                if (!pathspec_matches(paths, down))
                        ;
-               else if (S_ISREG(mode))
-                       hit |= grep_sha1(opt, sha1, path_buf);
-               else if (S_ISDIR(mode)) {
+               else if (S_ISREG(entry.mode))
+                       hit |= grep_sha1(opt, entry.sha1, path_buf);
+               else if (S_ISDIR(entry.mode)) {
                        char type[20];
                        struct tree_desc sub;
                        void *data;
-                       data = read_sha1_file(sha1, type, &sub.size);
+                       data = read_sha1_file(entry.sha1, type, &sub.size);
                        if (!data)
                                die("unable to read tree (%s)",
-                                   sha1_to_hex(sha1));
+                                   sha1_to_hex(entry.sha1));
                        sub.buf = data;
                        hit |= grep_tree(opt, paths, &sub, tree_name, down);
                        free(data);
                }
-               update_tree_entry(tree);
        }
        return hit;
 }
@@ -617,10 +630,9 @@ static int grep_tree(struct grep_opt *opt, const char **paths,
 static int grep_object(struct grep_opt *opt, const char **paths,
                       struct object *obj, const char *name)
 {
-       if (!strcmp(obj->type, blob_type))
+       if (obj->type == TYPE_BLOB)
                return grep_sha1(opt, obj->sha1, name);
-       if (!strcmp(obj->type, commit_type) ||
-           !strcmp(obj->type, tree_type)) {
+       if (obj->type == TYPE_COMMIT || obj->type == TYPE_TREE) {
                struct tree_desc tree;
                void *data;
                int hit;
@@ -633,7 +645,7 @@ static int grep_object(struct grep_opt *opt, const char **paths,
                free(data);
                return hit;
        }
-       die("unable to grep from object of type %s", obj->type);
+       die("unable to grep from object of type %s", typename(obj->type));
 }
 
 static const char builtin_grep_usage[] =