Merge branch 'jc/grep' into next
[gitweb.git] / builtin-grep.c
index c89ee33a1ede4e032cae850315ee2b2185a64457..26a3fc387ff0def55ce29494840b4e3437f6bbc2 100644 (file)
@@ -82,6 +82,8 @@ static int pathspec_matches(const char **paths, const char *name)
 
 struct grep_pat {
        struct grep_pat *next;
+       const char *origin;
+       int no;
        const char *pattern;
        regex_t regexp;
 };
@@ -105,10 +107,13 @@ struct grep_opt {
        unsigned post_context;
 };
 
-static void add_pattern(struct grep_opt *opt, const char *pat)
+static void add_pattern(struct grep_opt *opt, const char *pat,
+                       const char *origin, int no)
 {
        struct grep_pat *p = xcalloc(1, sizeof(*p));
        p->pattern = pat;
+       p->origin = origin;
+       p->no = no;
        *opt->pattern_tail = p;
        opt->pattern_tail = &p->next;
        p->next = NULL;
@@ -121,9 +126,17 @@ static void compile_patterns(struct grep_opt *opt)
                int err = regcomp(&p->regexp, p->pattern, opt->regflags);
                if (err) {
                        char errbuf[1024];
+                       char where[1024];
+                       if (p->no)
+                               sprintf(where, "In '%s' at %d, ",
+                                       p->origin, p->no);
+                       else if (p->origin)
+                               sprintf(where, "%s, ", p->origin);
+                       else
+                               where[0] = 0;
                        regerror(err, &p->regexp, errbuf, 1024);
                        regfree(&p->regexp);
-                       die("'%s': %s", p->pattern, errbuf);
+                       die("%s'%s': %s", where, p->pattern, errbuf);
                }
        }
 }
@@ -481,21 +494,30 @@ static const char builtin_grep_usage[] =
 int cmd_grep(int argc, const char **argv, char **envp)
 {
        int hit = 0;
-       int no_more_flags = 0;
-       int seen_noncommit = 0;
        int cached = 0;
+       int seen_dashdash = 0;
        struct grep_opt opt;
        struct object_list *list, **tail, *object_list = NULL;
        const char *prefix = setup_git_directory();
        const char **paths = NULL;
+       int i;
 
        memset(&opt, 0, sizeof(opt));
        opt.pattern_tail = &opt.pattern_list;
        opt.regflags = REG_NEWLINE;
 
        /*
-        * No point using rev_info, really.
+        * If there is no -- then the paths must exist in the working
+        * tree.  If there is no explicit pattern specified with -e or
+        * -f, we take the first unrecognized non option to be the
+        * pattern, but then what follows it must be zero or more
+        * valid refs up to the -- (if exists), and then existing
+        * paths.  If there is an explicit pattern, then the first
+        * unrecocnized non option is the beginning of the refs list
+        * that continues up to the -- (if exists), and then paths.
         */
+
+       tail = &object_list;
        while (1 < argc) {
                const char *arg = argv[1];
                argc--; argv++;
@@ -598,56 +620,93 @@ int cmd_grep(int argc, const char **argv, char **envp)
                        }
                        continue;
                }
+               if (!strcmp("-f", arg)) {
+                       FILE *patterns;
+                       int lno = 0;
+                       char buf[1024];
+                       if (argc <= 1)
+                               usage(builtin_grep_usage);
+                       patterns = fopen(argv[1], "r");
+                       if (!patterns)
+                               die("'%s': %s", argv[1], strerror(errno));
+                       while (fgets(buf, sizeof(buf), patterns)) {
+                               int len = strlen(buf);
+                               if (buf[len-1] == '\n')
+                                       buf[len-1] = 0;
+                               /* ignore empty line like grep does */
+                               if (!buf[0])
+                                       continue;
+                               add_pattern(&opt, strdup(buf), argv[1], ++lno);
+                       }
+                       fclose(patterns);
+                       argv++;
+                       argc--;
+                       continue;
+               }
                if (!strcmp("-e", arg)) {
                        if (1 < argc) {
-                               add_pattern(&opt, argv[1]);
+                               add_pattern(&opt, argv[1], "-e option", 0);
                                argv++;
                                argc--;
                                continue;
                        }
                        usage(builtin_grep_usage);
                }
-               if (!strcmp("--", arg)) {
-                       no_more_flags = 1;
-                       continue;
-               }
-               /* Either unrecognized option or a single pattern */
-               if (!no_more_flags && *arg == '-')
+               if (!strcmp("--", arg))
+                       break;
+               if (*arg == '-')
                        usage(builtin_grep_usage);
+
+               /* First unrecognized non-option token */
                if (!opt.pattern_list) {
-                       add_pattern(&opt, arg);
+                       add_pattern(&opt, arg, "command line", 0);
                        break;
                }
                else {
                        /* We are looking at the first path or rev;
-                        * it is found at argv[0] after leaving the
+                        * it is found at argv[1] after leaving the
                         * loop.
                         */
                        argc++; argv--;
                        break;
                }
        }
+
        if (!opt.pattern_list)
                die("no pattern given.");
        compile_patterns(&opt);
-       tail = &object_list;
-       while (1 < argc) {
-               struct object *object;
-               struct object_list *elem;
-               const char *arg = argv[1];
+
+       /* Check revs and then paths */
+       for (i = 1; i < argc; i++) {
+               const char *arg = argv[i];
                unsigned char sha1[20];
-               if (get_sha1(arg, sha1) < 0)
-                       break;
-               object = parse_object(sha1);
-               if (!object)
-                       die("bad object %s", arg);
-               elem = object_list_insert(object, tail);
-               elem->name = arg;
-               tail = &elem->next;
-               argc--; argv++;
+               /* Is it a rev? */
+               if (!get_sha1(arg, sha1)) {
+                       struct object *object = parse_object(sha1);
+                       struct object_list *elem;
+                       if (!object)
+                               die("bad object %s", arg);
+                       elem = object_list_insert(object, tail);
+                       elem->name = arg;
+                       tail = &elem->next;
+                       continue;
+               }
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       seen_dashdash = 1;
+               }
+               break;
+       }
+
+       /* The rest are paths */
+       if (!seen_dashdash) {
+               int j;
+               for (j = i; j < argc; i++)
+                       verify_filename(prefix, argv[j]);
        }
-       if (1 < argc)
-               paths = get_pathspec(prefix, argv + 1);
+
+       if (i < argc)
+               paths = get_pathspec(prefix, argv + i);
        else if (prefix) {
                paths = xcalloc(2, sizeof(const char *));
                paths[0] = prefix;
@@ -656,21 +715,9 @@ int cmd_grep(int argc, const char **argv, char **envp)
 
        if (!object_list)
                return !grep_cache(&opt, paths, cached);
-       /*
-        * Do not walk "grep -e foo master next pu -- Documentation/"
-        * but do walk "grep -e foo master..next -- Documentation/".
-        * Ranged request mixed with a blob or tree object, like
-        * "grep -e foo v1.0.0:Documentation/ master..next"
-        * so detect that and complain.
-        */
-       for (list = object_list; list; list = list->next) {
-               struct object *real_obj;
-               real_obj = deref_tag(list->item, NULL, 0);
-               if (strcmp(real_obj->type, commit_type))
-                       seen_noncommit = 1;
-       }
+
        if (cached)
-               die("both --cached and revisions given.");
+               die("both --cached and trees are given.");
 
        for (list = object_list; list; list = list->next) {
                struct object *real_obj;