builtin-grep.con commit upload-pack: add a trigger for post-upload-pack hook (a8563ec)
   1/*
   2 * Builtin "git grep"
   3 *
   4 * Copyright (c) 2006 Junio C Hamano
   5 */
   6#include "cache.h"
   7#include "blob.h"
   8#include "tree.h"
   9#include "commit.h"
  10#include "tag.h"
  11#include "tree-walk.h"
  12#include "builtin.h"
  13#include "parse-options.h"
  14#include "userdiff.h"
  15#include "grep.h"
  16
  17#ifndef NO_EXTERNAL_GREP
  18#ifdef __unix__
  19#define NO_EXTERNAL_GREP 0
  20#else
  21#define NO_EXTERNAL_GREP 1
  22#endif
  23#endif
  24
  25static char const * const grep_usage[] = {
  26        "git grep [options] [-e] <pattern> [<rev>...] [[--] path...]",
  27        NULL
  28};
  29
  30static int grep_config(const char *var, const char *value, void *cb)
  31{
  32        struct grep_opt *opt = cb;
  33
  34        switch (userdiff_config(var, value)) {
  35        case 0: break;
  36        case -1: return -1;
  37        default: return 0;
  38        }
  39
  40        if (!strcmp(var, "color.grep")) {
  41                opt->color = git_config_colorbool(var, value, -1);
  42                return 0;
  43        }
  44        if (!strcmp(var, "color.grep.external"))
  45                return git_config_string(&(opt->color_external), var, value);
  46        if (!strcmp(var, "color.grep.match")) {
  47                if (!value)
  48                        return config_error_nonbool(var);
  49                color_parse(value, var, opt->color_match);
  50                return 0;
  51        }
  52        return git_color_default_config(var, value, cb);
  53}
  54
  55/*
  56 * Return non-zero if max_depth is negative or path has no more then max_depth
  57 * slashes.
  58 */
  59static int accept_subdir(const char *path, int max_depth)
  60{
  61        if (max_depth < 0)
  62                return 1;
  63
  64        while ((path = strchr(path, '/')) != NULL) {
  65                max_depth--;
  66                if (max_depth < 0)
  67                        return 0;
  68                path++;
  69        }
  70        return 1;
  71}
  72
  73/*
  74 * Return non-zero if name is a subdirectory of match and is not too deep.
  75 */
  76static int is_subdir(const char *name, int namelen,
  77                const char *match, int matchlen, int max_depth)
  78{
  79        if (matchlen > namelen || strncmp(name, match, matchlen))
  80                return 0;
  81
  82        if (name[matchlen] == '\0') /* exact match */
  83                return 1;
  84
  85        if (!matchlen || match[matchlen-1] == '/' || name[matchlen] == '/')
  86                return accept_subdir(name + matchlen + 1, max_depth);
  87
  88        return 0;
  89}
  90
  91/*
  92 * git grep pathspecs are somewhat different from diff-tree pathspecs;
  93 * pathname wildcards are allowed.
  94 */
  95static int pathspec_matches(const char **paths, const char *name, int max_depth)
  96{
  97        int namelen, i;
  98        if (!paths || !*paths)
  99                return accept_subdir(name, max_depth);
 100        namelen = strlen(name);
 101        for (i = 0; paths[i]; i++) {
 102                const char *match = paths[i];
 103                int matchlen = strlen(match);
 104                const char *cp, *meta;
 105
 106                if (is_subdir(name, namelen, match, matchlen, max_depth))
 107                        return 1;
 108                if (!fnmatch(match, name, 0))
 109                        return 1;
 110                if (name[namelen-1] != '/')
 111                        continue;
 112
 113                /* We are being asked if the directory ("name") is worth
 114                 * descending into.
 115                 *
 116                 * Find the longest leading directory name that does
 117                 * not have metacharacter in the pathspec; the name
 118                 * we are looking at must overlap with that directory.
 119                 */
 120                for (cp = match, meta = NULL; cp - match < matchlen; cp++) {
 121                        char ch = *cp;
 122                        if (ch == '*' || ch == '[' || ch == '?') {
 123                                meta = cp;
 124                                break;
 125                        }
 126                }
 127                if (!meta)
 128                        meta = cp; /* fully literal */
 129
 130                if (namelen <= meta - match) {
 131                        /* Looking at "Documentation/" and
 132                         * the pattern says "Documentation/howto/", or
 133                         * "Documentation/diff*.txt".  The name we
 134                         * have should match prefix.
 135                         */
 136                        if (!memcmp(match, name, namelen))
 137                                return 1;
 138                        continue;
 139                }
 140
 141                if (meta - match < namelen) {
 142                        /* Looking at "Documentation/howto/" and
 143                         * the pattern says "Documentation/h*";
 144                         * match up to "Do.../h"; this avoids descending
 145                         * into "Documentation/technical/".
 146                         */
 147                        if (!memcmp(match, name, meta - match))
 148                                return 1;
 149                        continue;
 150                }
 151        }
 152        return 0;
 153}
 154
 155static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1, const char *name, int tree_name_len)
 156{
 157        unsigned long size;
 158        char *data;
 159        enum object_type type;
 160        char *to_free = NULL;
 161        int hit;
 162
 163        data = read_sha1_file(sha1, &type, &size);
 164        if (!data) {
 165                error("'%s': unable to read %s", name, sha1_to_hex(sha1));
 166                return 0;
 167        }
 168        if (opt->relative && opt->prefix_length) {
 169                static char name_buf[PATH_MAX];
 170                char *cp;
 171                int name_len = strlen(name) - opt->prefix_length + 1;
 172
 173                if (!tree_name_len)
 174                        name += opt->prefix_length;
 175                else {
 176                        if (ARRAY_SIZE(name_buf) <= name_len)
 177                                cp = to_free = xmalloc(name_len);
 178                        else
 179                                cp = name_buf;
 180                        memcpy(cp, name, tree_name_len);
 181                        strcpy(cp + tree_name_len,
 182                               name + tree_name_len + opt->prefix_length);
 183                        name = cp;
 184                }
 185        }
 186        hit = grep_buffer(opt, name, data, size);
 187        free(data);
 188        free(to_free);
 189        return hit;
 190}
 191
 192static int grep_file(struct grep_opt *opt, const char *filename)
 193{
 194        struct stat st;
 195        int i;
 196        char *data;
 197        size_t sz;
 198
 199        if (lstat(filename, &st) < 0) {
 200        err_ret:
 201                if (errno != ENOENT)
 202                        error("'%s': %s", filename, strerror(errno));
 203                return 0;
 204        }
 205        if (!st.st_size)
 206                return 0; /* empty file -- no grep hit */
 207        if (!S_ISREG(st.st_mode))
 208                return 0;
 209        sz = xsize_t(st.st_size);
 210        i = open(filename, O_RDONLY);
 211        if (i < 0)
 212                goto err_ret;
 213        data = xmalloc(sz + 1);
 214        if (st.st_size != read_in_full(i, data, sz)) {
 215                error("'%s': short read %s", filename, strerror(errno));
 216                close(i);
 217                free(data);
 218                return 0;
 219        }
 220        close(i);
 221        if (opt->relative && opt->prefix_length)
 222                filename += opt->prefix_length;
 223        i = grep_buffer(opt, filename, data, sz);
 224        free(data);
 225        return i;
 226}
 227
 228#if !NO_EXTERNAL_GREP
 229static int exec_grep(int argc, const char **argv)
 230{
 231        pid_t pid;
 232        int status;
 233
 234        argv[argc] = NULL;
 235        pid = fork();
 236        if (pid < 0)
 237                return pid;
 238        if (!pid) {
 239                execvp("grep", (char **) argv);
 240                exit(255);
 241        }
 242        while (waitpid(pid, &status, 0) < 0) {
 243                if (errno == EINTR)
 244                        continue;
 245                return -1;
 246        }
 247        if (WIFEXITED(status)) {
 248                if (!WEXITSTATUS(status))
 249                        return 1;
 250                return 0;
 251        }
 252        return -1;
 253}
 254
 255#define MAXARGS 1000
 256#define ARGBUF 4096
 257#define push_arg(a) do { \
 258        if (nr < MAXARGS) argv[nr++] = (a); \
 259        else die("maximum number of args exceeded"); \
 260        } while (0)
 261
 262/*
 263 * If you send a singleton filename to grep, it does not give
 264 * the name of the file.  GNU grep has "-H" but we would want
 265 * that behaviour in a portable way.
 266 *
 267 * So we keep two pathnames in argv buffer unsent to grep in
 268 * the main loop if we need to do more than one grep.
 269 */
 270static int flush_grep(struct grep_opt *opt,
 271                      int argc, int arg0, const char **argv, int *kept)
 272{
 273        int status;
 274        int count = argc - arg0;
 275        const char *kept_0 = NULL;
 276
 277        if (count <= 2) {
 278                /*
 279                 * Because we keep at least 2 paths in the call from
 280                 * the main loop (i.e. kept != NULL), and MAXARGS is
 281                 * far greater than 2, this usually is a call to
 282                 * conclude the grep.  However, the user could attempt
 283                 * to overflow the argv buffer by giving too many
 284                 * options to leave very small number of real
 285                 * arguments even for the call in the main loop.
 286                 */
 287                if (kept)
 288                        die("insanely many options to grep");
 289
 290                /*
 291                 * If we have two or more paths, we do not have to do
 292                 * anything special, but we need to push /dev/null to
 293                 * get "-H" behaviour of GNU grep portably but when we
 294                 * are not doing "-l" nor "-L" nor "-c".
 295                 */
 296                if (count == 1 &&
 297                    !opt->name_only &&
 298                    !opt->unmatch_name_only &&
 299                    !opt->count) {
 300                        argv[argc++] = "/dev/null";
 301                        argv[argc] = NULL;
 302                }
 303        }
 304
 305        else if (kept) {
 306                /*
 307                 * Called because we found many paths and haven't finished
 308                 * iterating over the cache yet.  We keep two paths
 309                 * for the concluding call.  argv[argc-2] and argv[argc-1]
 310                 * has the last two paths, so save the first one away,
 311                 * replace it with NULL while sending the list to grep,
 312                 * and recover them after we are done.
 313                 */
 314                *kept = 2;
 315                kept_0 = argv[argc-2];
 316                argv[argc-2] = NULL;
 317                argc -= 2;
 318        }
 319
 320        if (opt->pre_context || opt->post_context) {
 321                /*
 322                 * grep handles hunk marks between files, but we need to
 323                 * do that ourselves between multiple calls.
 324                 */
 325                if (opt->show_hunk_mark)
 326                        write_or_die(1, "--\n", 3);
 327                else
 328                        opt->show_hunk_mark = 1;
 329        }
 330
 331        status = exec_grep(argc, argv);
 332
 333        if (kept_0) {
 334                /*
 335                 * Then recover them.  Now the last arg is beyond the
 336                 * terminating NULL which is at argc, and the second
 337                 * from the last is what we saved away in kept_0
 338                 */
 339                argv[arg0++] = kept_0;
 340                argv[arg0] = argv[argc+1];
 341        }
 342        return status;
 343}
 344
 345static void grep_add_color(struct strbuf *sb, const char *escape_seq)
 346{
 347        size_t orig_len = sb->len;
 348
 349        while (*escape_seq) {
 350                if (*escape_seq == 'm')
 351                        strbuf_addch(sb, ';');
 352                else if (*escape_seq != '\033' && *escape_seq  != '[')
 353                        strbuf_addch(sb, *escape_seq);
 354                escape_seq++;
 355        }
 356        if (sb->len > orig_len && sb->buf[sb->len - 1] == ';')
 357                strbuf_setlen(sb, sb->len - 1);
 358}
 359
 360static int external_grep(struct grep_opt *opt, const char **paths, int cached)
 361{
 362        int i, nr, argc, hit, len, status;
 363        const char *argv[MAXARGS+1];
 364        char randarg[ARGBUF];
 365        char *argptr = randarg;
 366        struct grep_pat *p;
 367
 368        if (opt->extended || (opt->relative && opt->prefix_length))
 369                return -1;
 370        len = nr = 0;
 371        push_arg("grep");
 372        if (opt->fixed)
 373                push_arg("-F");
 374        if (opt->linenum)
 375                push_arg("-n");
 376        if (!opt->pathname)
 377                push_arg("-h");
 378        if (opt->regflags & REG_EXTENDED)
 379                push_arg("-E");
 380        if (opt->regflags & REG_ICASE)
 381                push_arg("-i");
 382        if (opt->binary == GREP_BINARY_NOMATCH)
 383                push_arg("-I");
 384        if (opt->word_regexp)
 385                push_arg("-w");
 386        if (opt->name_only)
 387                push_arg("-l");
 388        if (opt->unmatch_name_only)
 389                push_arg("-L");
 390        if (opt->null_following_name)
 391                /* in GNU grep git's "-z" translates to "-Z" */
 392                push_arg("-Z");
 393        if (opt->count)
 394                push_arg("-c");
 395        if (opt->post_context || opt->pre_context) {
 396                if (opt->post_context != opt->pre_context) {
 397                        if (opt->pre_context) {
 398                                push_arg("-B");
 399                                len += snprintf(argptr, sizeof(randarg)-len,
 400                                                "%u", opt->pre_context) + 1;
 401                                if (sizeof(randarg) <= len)
 402                                        die("maximum length of args exceeded");
 403                                push_arg(argptr);
 404                                argptr += len;
 405                        }
 406                        if (opt->post_context) {
 407                                push_arg("-A");
 408                                len += snprintf(argptr, sizeof(randarg)-len,
 409                                                "%u", opt->post_context) + 1;
 410                                if (sizeof(randarg) <= len)
 411                                        die("maximum length of args exceeded");
 412                                push_arg(argptr);
 413                                argptr += len;
 414                        }
 415                }
 416                else {
 417                        push_arg("-C");
 418                        len += snprintf(argptr, sizeof(randarg)-len,
 419                                        "%u", opt->post_context) + 1;
 420                        if (sizeof(randarg) <= len)
 421                                die("maximum length of args exceeded");
 422                        push_arg(argptr);
 423                        argptr += len;
 424                }
 425        }
 426        for (p = opt->pattern_list; p; p = p->next) {
 427                push_arg("-e");
 428                push_arg(p->pattern);
 429        }
 430        if (opt->color) {
 431                struct strbuf sb = STRBUF_INIT;
 432
 433                grep_add_color(&sb, opt->color_match);
 434                setenv("GREP_COLOR", sb.buf, 1);
 435
 436                strbuf_reset(&sb);
 437                strbuf_addstr(&sb, "mt=");
 438                grep_add_color(&sb, opt->color_match);
 439                strbuf_addstr(&sb, ":sl=:cx=:fn=:ln=:bn=:se=");
 440                setenv("GREP_COLORS", sb.buf, 1);
 441
 442                strbuf_release(&sb);
 443
 444                if (opt->color_external && strlen(opt->color_external) > 0)
 445                        push_arg(opt->color_external);
 446        }
 447
 448        hit = 0;
 449        argc = nr;
 450        for (i = 0; i < active_nr; i++) {
 451                struct cache_entry *ce = active_cache[i];
 452                char *name;
 453                int kept;
 454                if (!S_ISREG(ce->ce_mode))
 455                        continue;
 456                if (!pathspec_matches(paths, ce->name, opt->max_depth))
 457                        continue;
 458                name = ce->name;
 459                if (name[0] == '-') {
 460                        int len = ce_namelen(ce);
 461                        name = xmalloc(len + 3);
 462                        memcpy(name, "./", 2);
 463                        memcpy(name + 2, ce->name, len + 1);
 464                }
 465                argv[argc++] = name;
 466                if (MAXARGS <= argc) {
 467                        status = flush_grep(opt, argc, nr, argv, &kept);
 468                        if (0 < status)
 469                                hit = 1;
 470                        argc = nr + kept;
 471                }
 472                if (ce_stage(ce)) {
 473                        do {
 474                                i++;
 475                        } while (i < active_nr &&
 476                                 !strcmp(ce->name, active_cache[i]->name));
 477                        i--; /* compensate for loop control */
 478                }
 479        }
 480        if (argc > nr) {
 481                status = flush_grep(opt, argc, nr, argv, NULL);
 482                if (0 < status)
 483                        hit = 1;
 484        }
 485        return hit;
 486}
 487#endif
 488
 489static int grep_cache(struct grep_opt *opt, const char **paths, int cached,
 490                      int external_grep_allowed)
 491{
 492        int hit = 0;
 493        int nr;
 494        read_cache();
 495
 496#if !NO_EXTERNAL_GREP
 497        /*
 498         * Use the external "grep" command for the case where
 499         * we grep through the checked-out files. It tends to
 500         * be a lot more optimized
 501         */
 502        if (!cached && external_grep_allowed) {
 503                hit = external_grep(opt, paths, cached);
 504                if (hit >= 0)
 505                        return hit;
 506        }
 507#endif
 508
 509        for (nr = 0; nr < active_nr; nr++) {
 510                struct cache_entry *ce = active_cache[nr];
 511                if (!S_ISREG(ce->ce_mode))
 512                        continue;
 513                if (!pathspec_matches(paths, ce->name, opt->max_depth))
 514                        continue;
 515                /*
 516                 * If CE_VALID is on, we assume worktree file and its cache entry
 517                 * are identical, even if worktree file has been modified, so use
 518                 * cache version instead
 519                 */
 520                if (cached || (ce->ce_flags & CE_VALID)) {
 521                        if (ce_stage(ce))
 522                                continue;
 523                        hit |= grep_sha1(opt, ce->sha1, ce->name, 0);
 524                }
 525                else
 526                        hit |= grep_file(opt, ce->name);
 527                if (ce_stage(ce)) {
 528                        do {
 529                                nr++;
 530                        } while (nr < active_nr &&
 531                                 !strcmp(ce->name, active_cache[nr]->name));
 532                        nr--; /* compensate for loop control */
 533                }
 534        }
 535        free_grep_patterns(opt);
 536        return hit;
 537}
 538
 539static int grep_tree(struct grep_opt *opt, const char **paths,
 540                     struct tree_desc *tree,
 541                     const char *tree_name, const char *base)
 542{
 543        int len;
 544        int hit = 0;
 545        struct name_entry entry;
 546        char *down;
 547        int tn_len = strlen(tree_name);
 548        struct strbuf pathbuf;
 549
 550        strbuf_init(&pathbuf, PATH_MAX + tn_len);
 551
 552        if (tn_len) {
 553                strbuf_add(&pathbuf, tree_name, tn_len);
 554                strbuf_addch(&pathbuf, ':');
 555                tn_len = pathbuf.len;
 556        }
 557        strbuf_addstr(&pathbuf, base);
 558        len = pathbuf.len;
 559
 560        while (tree_entry(tree, &entry)) {
 561                int te_len = tree_entry_len(entry.path, entry.sha1);
 562                pathbuf.len = len;
 563                strbuf_add(&pathbuf, entry.path, te_len);
 564
 565                if (S_ISDIR(entry.mode))
 566                        /* Match "abc/" against pathspec to
 567                         * decide if we want to descend into "abc"
 568                         * directory.
 569                         */
 570                        strbuf_addch(&pathbuf, '/');
 571
 572                down = pathbuf.buf + tn_len;
 573                if (!pathspec_matches(paths, down, opt->max_depth))
 574                        ;
 575                else if (S_ISREG(entry.mode))
 576                        hit |= grep_sha1(opt, entry.sha1, pathbuf.buf, tn_len);
 577                else if (S_ISDIR(entry.mode)) {
 578                        enum object_type type;
 579                        struct tree_desc sub;
 580                        void *data;
 581                        unsigned long size;
 582
 583                        data = read_sha1_file(entry.sha1, &type, &size);
 584                        if (!data)
 585                                die("unable to read tree (%s)",
 586                                    sha1_to_hex(entry.sha1));
 587                        init_tree_desc(&sub, data, size);
 588                        hit |= grep_tree(opt, paths, &sub, tree_name, down);
 589                        free(data);
 590                }
 591        }
 592        strbuf_release(&pathbuf);
 593        return hit;
 594}
 595
 596static int grep_object(struct grep_opt *opt, const char **paths,
 597                       struct object *obj, const char *name)
 598{
 599        if (obj->type == OBJ_BLOB)
 600                return grep_sha1(opt, obj->sha1, name, 0);
 601        if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
 602                struct tree_desc tree;
 603                void *data;
 604                unsigned long size;
 605                int hit;
 606                data = read_object_with_reference(obj->sha1, tree_type,
 607                                                  &size, NULL);
 608                if (!data)
 609                        die("unable to read tree (%s)", sha1_to_hex(obj->sha1));
 610                init_tree_desc(&tree, data, size);
 611                hit = grep_tree(opt, paths, &tree, name, "");
 612                free(data);
 613                return hit;
 614        }
 615        die("unable to grep from object of type %s", typename(obj->type));
 616}
 617
 618static int context_callback(const struct option *opt, const char *arg,
 619                            int unset)
 620{
 621        struct grep_opt *grep_opt = opt->value;
 622        int value;
 623        const char *endp;
 624
 625        if (unset) {
 626                grep_opt->pre_context = grep_opt->post_context = 0;
 627                return 0;
 628        }
 629        value = strtol(arg, (char **)&endp, 10);
 630        if (*endp) {
 631                return error("switch `%c' expects a numerical value",
 632                             opt->short_name);
 633        }
 634        grep_opt->pre_context = grep_opt->post_context = value;
 635        return 0;
 636}
 637
 638static int file_callback(const struct option *opt, const char *arg, int unset)
 639{
 640        struct grep_opt *grep_opt = opt->value;
 641        FILE *patterns;
 642        int lno = 0;
 643        struct strbuf sb;
 644
 645        patterns = fopen(arg, "r");
 646        if (!patterns)
 647                die_errno("cannot open '%s'", arg);
 648        while (strbuf_getline(&sb, patterns, '\n') == 0) {
 649                /* ignore empty line like grep does */
 650                if (sb.len == 0)
 651                        continue;
 652                append_grep_pattern(grep_opt, strbuf_detach(&sb, NULL), arg,
 653                                    ++lno, GREP_PATTERN);
 654        }
 655        fclose(patterns);
 656        strbuf_release(&sb);
 657        return 0;
 658}
 659
 660static int not_callback(const struct option *opt, const char *arg, int unset)
 661{
 662        struct grep_opt *grep_opt = opt->value;
 663        append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
 664        return 0;
 665}
 666
 667static int and_callback(const struct option *opt, const char *arg, int unset)
 668{
 669        struct grep_opt *grep_opt = opt->value;
 670        append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
 671        return 0;
 672}
 673
 674static int open_callback(const struct option *opt, const char *arg, int unset)
 675{
 676        struct grep_opt *grep_opt = opt->value;
 677        append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
 678        return 0;
 679}
 680
 681static int close_callback(const struct option *opt, const char *arg, int unset)
 682{
 683        struct grep_opt *grep_opt = opt->value;
 684        append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
 685        return 0;
 686}
 687
 688static int pattern_callback(const struct option *opt, const char *arg,
 689                            int unset)
 690{
 691        struct grep_opt *grep_opt = opt->value;
 692        append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
 693        return 0;
 694}
 695
 696static int help_callback(const struct option *opt, const char *arg, int unset)
 697{
 698        return -1;
 699}
 700
 701int cmd_grep(int argc, const char **argv, const char *prefix)
 702{
 703        int hit = 0;
 704        int cached = 0;
 705        int external_grep_allowed = 1;
 706        int seen_dashdash = 0;
 707        struct grep_opt opt;
 708        struct object_array list = { 0, 0, NULL };
 709        const char **paths = NULL;
 710        int i;
 711        int dummy;
 712        struct option options[] = {
 713                OPT_BOOLEAN(0, "cached", &cached,
 714                        "search in index instead of in the work tree"),
 715                OPT_GROUP(""),
 716                OPT_BOOLEAN('v', "invert-match", &opt.invert,
 717                        "show non-matching lines"),
 718                OPT_BIT('i', "ignore-case", &opt.regflags,
 719                        "case insensitive matching", REG_ICASE),
 720                OPT_BOOLEAN('w', "word-regexp", &opt.word_regexp,
 721                        "match patterns only at word boundaries"),
 722                OPT_SET_INT('a', "text", &opt.binary,
 723                        "process binary files as text", GREP_BINARY_TEXT),
 724                OPT_SET_INT('I', NULL, &opt.binary,
 725                        "don't match patterns in binary files",
 726                        GREP_BINARY_NOMATCH),
 727                { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, "depth",
 728                        "descend at most <depth> levels", PARSE_OPT_NONEG,
 729                        NULL, 1 },
 730                OPT_GROUP(""),
 731                OPT_BIT('E', "extended-regexp", &opt.regflags,
 732                        "use extended POSIX regular expressions", REG_EXTENDED),
 733                OPT_NEGBIT('G', "basic-regexp", &opt.regflags,
 734                        "use basic POSIX regular expressions (default)",
 735                        REG_EXTENDED),
 736                OPT_BOOLEAN('F', "fixed-strings", &opt.fixed,
 737                        "interpret patterns as fixed strings"),
 738                OPT_GROUP(""),
 739                OPT_BOOLEAN('n', NULL, &opt.linenum, "show line numbers"),
 740                OPT_NEGBIT('h', NULL, &opt.pathname, "don't show filenames", 1),
 741                OPT_BIT('H', NULL, &opt.pathname, "show filenames", 1),
 742                OPT_NEGBIT(0, "full-name", &opt.relative,
 743                        "show filenames relative to top directory", 1),
 744                OPT_BOOLEAN('l', "files-with-matches", &opt.name_only,
 745                        "show only filenames instead of matching lines"),
 746                OPT_BOOLEAN(0, "name-only", &opt.name_only,
 747                        "synonym for --files-with-matches"),
 748                OPT_BOOLEAN('L', "files-without-match",
 749                        &opt.unmatch_name_only,
 750                        "show only the names of files without match"),
 751                OPT_BOOLEAN('z', "null", &opt.null_following_name,
 752                        "print NUL after filenames"),
 753                OPT_BOOLEAN('c', "count", &opt.count,
 754                        "show the number of matches instead of matching lines"),
 755                OPT_SET_INT(0, "color", &opt.color, "highlight matches", 1),
 756                OPT_GROUP(""),
 757                OPT_CALLBACK('C', NULL, &opt, "n",
 758                        "show <n> context lines before and after matches",
 759                        context_callback),
 760                OPT_INTEGER('B', NULL, &opt.pre_context,
 761                        "show <n> context lines before matches"),
 762                OPT_INTEGER('A', NULL, &opt.post_context,
 763                        "show <n> context lines after matches"),
 764                OPT_NUMBER_CALLBACK(&opt, "shortcut for -C NUM",
 765                        context_callback),
 766                OPT_BOOLEAN('p', "show-function", &opt.funcname,
 767                        "show a line with the function name before matches"),
 768                OPT_GROUP(""),
 769                OPT_CALLBACK('f', NULL, &opt, "file",
 770                        "read patterns from file", file_callback),
 771                { OPTION_CALLBACK, 'e', NULL, &opt, "pattern",
 772                        "match <pattern>", PARSE_OPT_NONEG, pattern_callback },
 773                { OPTION_CALLBACK, 0, "and", &opt, NULL,
 774                  "combine patterns specified with -e",
 775                  PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback },
 776                OPT_BOOLEAN(0, "or", &dummy, ""),
 777                { OPTION_CALLBACK, 0, "not", &opt, NULL, "",
 778                  PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback },
 779                { OPTION_CALLBACK, '(', NULL, &opt, NULL, "",
 780                  PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
 781                  open_callback },
 782                { OPTION_CALLBACK, ')', NULL, &opt, NULL, "",
 783                  PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
 784                  close_callback },
 785                OPT_BOOLEAN(0, "all-match", &opt.all_match,
 786                        "show only matches from files that match all patterns"),
 787                OPT_GROUP(""),
 788#if NO_EXTERNAL_GREP
 789                OPT_BOOLEAN(0, "ext-grep", &external_grep_allowed,
 790                        "allow calling of grep(1) (ignored by this build)"),
 791#else
 792                OPT_BOOLEAN(0, "ext-grep", &external_grep_allowed,
 793                        "allow calling of grep(1) (default)"),
 794#endif
 795                { OPTION_CALLBACK, 0, "help-all", &options, NULL, "show usage",
 796                  PARSE_OPT_HIDDEN | PARSE_OPT_NOARG, help_callback },
 797                OPT_END()
 798        };
 799
 800        memset(&opt, 0, sizeof(opt));
 801        opt.prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
 802        opt.relative = 1;
 803        opt.pathname = 1;
 804        opt.pattern_tail = &opt.pattern_list;
 805        opt.regflags = REG_NEWLINE;
 806        opt.max_depth = -1;
 807
 808        strcpy(opt.color_match, GIT_COLOR_RED GIT_COLOR_BOLD);
 809        opt.color = -1;
 810        git_config(grep_config, &opt);
 811        if (opt.color == -1)
 812                opt.color = git_use_color_default;
 813
 814        /*
 815         * If there is no -- then the paths must exist in the working
 816         * tree.  If there is no explicit pattern specified with -e or
 817         * -f, we take the first unrecognized non option to be the
 818         * pattern, but then what follows it must be zero or more
 819         * valid refs up to the -- (if exists), and then existing
 820         * paths.  If there is an explicit pattern, then the first
 821         * unrecognized non option is the beginning of the refs list
 822         * that continues up to the -- (if exists), and then paths.
 823         */
 824        argc = parse_options(argc, argv, prefix, options, grep_usage,
 825                             PARSE_OPT_KEEP_DASHDASH |
 826                             PARSE_OPT_STOP_AT_NON_OPTION |
 827                             PARSE_OPT_NO_INTERNAL_HELP);
 828
 829        /* First unrecognized non-option token */
 830        if (argc > 0 && !opt.pattern_list) {
 831                append_grep_pattern(&opt, argv[0], "command line", 0,
 832                                    GREP_PATTERN);
 833                argv++;
 834                argc--;
 835        }
 836
 837        if ((opt.color && !opt.color_external) || opt.funcname)
 838                external_grep_allowed = 0;
 839        if (!opt.pattern_list)
 840                die("no pattern given.");
 841        if ((opt.regflags != REG_NEWLINE) && opt.fixed)
 842                die("cannot mix --fixed-strings and regexp");
 843        compile_grep_patterns(&opt);
 844
 845        /* Check revs and then paths */
 846        for (i = 0; i < argc; i++) {
 847                const char *arg = argv[i];
 848                unsigned char sha1[20];
 849                /* Is it a rev? */
 850                if (!get_sha1(arg, sha1)) {
 851                        struct object *object = parse_object(sha1);
 852                        if (!object)
 853                                die("bad object %s", arg);
 854                        add_object_array(object, arg, &list);
 855                        continue;
 856                }
 857                if (!strcmp(arg, "--")) {
 858                        i++;
 859                        seen_dashdash = 1;
 860                }
 861                break;
 862        }
 863
 864        /* The rest are paths */
 865        if (!seen_dashdash) {
 866                int j;
 867                for (j = i; j < argc; j++)
 868                        verify_filename(prefix, argv[j]);
 869        }
 870
 871        if (i < argc) {
 872                paths = get_pathspec(prefix, argv + i);
 873                if (opt.prefix_length && opt.relative) {
 874                        /* Make sure we do not get outside of paths */
 875                        for (i = 0; paths[i]; i++)
 876                                if (strncmp(prefix, paths[i], opt.prefix_length))
 877                                        die("git grep: cannot generate relative filenames containing '..'");
 878                }
 879        }
 880        else if (prefix) {
 881                paths = xcalloc(2, sizeof(const char *));
 882                paths[0] = prefix;
 883                paths[1] = NULL;
 884        }
 885
 886        if (!list.nr) {
 887                if (!cached)
 888                        setup_work_tree();
 889                return !grep_cache(&opt, paths, cached, external_grep_allowed);
 890        }
 891
 892        if (cached)
 893                die("both --cached and trees are given.");
 894
 895        for (i = 0; i < list.nr; i++) {
 896                struct object *real_obj;
 897                real_obj = deref_tag(list.objects[i].item, NULL, 0);
 898                if (grep_object(&opt, paths, real_obj, list.objects[i].name))
 899                        hit = 1;
 900        }
 901        free_grep_patterns(&opt);
 902        return !hit;
 903}