attr.con commit Git 2.8-rc4 (808ecd4)
   1/*
   2 * Handle git attributes.  See gitattributes(5) for a description of
   3 * the file syntax, and Documentation/technical/api-gitattributes.txt
   4 * for a description of the API.
   5 *
   6 * One basic design decision here is that we are not going to support
   7 * an insanely large number of attributes.
   8 */
   9
  10#define NO_THE_INDEX_COMPATIBILITY_MACROS
  11#include "cache.h"
  12#include "exec_cmd.h"
  13#include "attr.h"
  14#include "dir.h"
  15#include "utf8.h"
  16
  17const char git_attr__true[] = "(builtin)true";
  18const char git_attr__false[] = "\0(builtin)false";
  19static const char git_attr__unknown[] = "(builtin)unknown";
  20#define ATTR__TRUE git_attr__true
  21#define ATTR__FALSE git_attr__false
  22#define ATTR__UNSET NULL
  23#define ATTR__UNKNOWN git_attr__unknown
  24
  25/* This is a randomly chosen prime. */
  26#define HASHSIZE 257
  27
  28#ifndef DEBUG_ATTR
  29#define DEBUG_ATTR 0
  30#endif
  31
  32struct git_attr {
  33        struct git_attr *next;
  34        unsigned h;
  35        int attr_nr;
  36        int maybe_macro;
  37        int maybe_real;
  38        char name[FLEX_ARRAY];
  39};
  40static int attr_nr;
  41static int cannot_trust_maybe_real;
  42
  43static struct git_attr_check *check_all_attr;
  44static struct git_attr *(git_attr_hash[HASHSIZE]);
  45
  46char *git_attr_name(struct git_attr *attr)
  47{
  48        return attr->name;
  49}
  50
  51static unsigned hash_name(const char *name, int namelen)
  52{
  53        unsigned val = 0, c;
  54
  55        while (namelen--) {
  56                c = *name++;
  57                val = ((val << 7) | (val >> 22)) ^ c;
  58        }
  59        return val;
  60}
  61
  62static int invalid_attr_name(const char *name, int namelen)
  63{
  64        /*
  65         * Attribute name cannot begin with '-' and must consist of
  66         * characters from [-A-Za-z0-9_.].
  67         */
  68        if (namelen <= 0 || *name == '-')
  69                return -1;
  70        while (namelen--) {
  71                char ch = *name++;
  72                if (! (ch == '-' || ch == '.' || ch == '_' ||
  73                       ('0' <= ch && ch <= '9') ||
  74                       ('a' <= ch && ch <= 'z') ||
  75                       ('A' <= ch && ch <= 'Z')) )
  76                        return -1;
  77        }
  78        return 0;
  79}
  80
  81static struct git_attr *git_attr_internal(const char *name, int len)
  82{
  83        unsigned hval = hash_name(name, len);
  84        unsigned pos = hval % HASHSIZE;
  85        struct git_attr *a;
  86
  87        for (a = git_attr_hash[pos]; a; a = a->next) {
  88                if (a->h == hval &&
  89                    !memcmp(a->name, name, len) && !a->name[len])
  90                        return a;
  91        }
  92
  93        if (invalid_attr_name(name, len))
  94                return NULL;
  95
  96        FLEX_ALLOC_MEM(a, name, name, len);
  97        a->h = hval;
  98        a->next = git_attr_hash[pos];
  99        a->attr_nr = attr_nr++;
 100        a->maybe_macro = 0;
 101        a->maybe_real = 0;
 102        git_attr_hash[pos] = a;
 103
 104        REALLOC_ARRAY(check_all_attr, attr_nr);
 105        check_all_attr[a->attr_nr].attr = a;
 106        check_all_attr[a->attr_nr].value = ATTR__UNKNOWN;
 107        return a;
 108}
 109
 110struct git_attr *git_attr(const char *name)
 111{
 112        return git_attr_internal(name, strlen(name));
 113}
 114
 115/* What does a matched pattern decide? */
 116struct attr_state {
 117        struct git_attr *attr;
 118        const char *setto;
 119};
 120
 121struct pattern {
 122        const char *pattern;
 123        int patternlen;
 124        int nowildcardlen;
 125        int flags;              /* EXC_FLAG_* */
 126};
 127
 128/*
 129 * One rule, as from a .gitattributes file.
 130 *
 131 * If is_macro is true, then u.attr is a pointer to the git_attr being
 132 * defined.
 133 *
 134 * If is_macro is false, then u.pattern points at the filename pattern
 135 * to which the rule applies.  (The memory pointed to is part of the
 136 * memory block allocated for the match_attr instance.)
 137 *
 138 * In either case, num_attr is the number of attributes affected by
 139 * this rule, and state is an array listing them.  The attributes are
 140 * listed as they appear in the file (macros unexpanded).
 141 */
 142struct match_attr {
 143        union {
 144                struct pattern pat;
 145                struct git_attr *attr;
 146        } u;
 147        char is_macro;
 148        unsigned num_attr;
 149        struct attr_state state[FLEX_ARRAY];
 150};
 151
 152static const char blank[] = " \t\r\n";
 153
 154/*
 155 * Parse a whitespace-delimited attribute state (i.e., "attr",
 156 * "-attr", "!attr", or "attr=value") from the string starting at src.
 157 * If e is not NULL, write the results to *e.  Return a pointer to the
 158 * remainder of the string (with leading whitespace removed), or NULL
 159 * if there was an error.
 160 */
 161static const char *parse_attr(const char *src, int lineno, const char *cp,
 162                              struct attr_state *e)
 163{
 164        const char *ep, *equals;
 165        int len;
 166
 167        ep = cp + strcspn(cp, blank);
 168        equals = strchr(cp, '=');
 169        if (equals && ep < equals)
 170                equals = NULL;
 171        if (equals)
 172                len = equals - cp;
 173        else
 174                len = ep - cp;
 175        if (!e) {
 176                if (*cp == '-' || *cp == '!') {
 177                        cp++;
 178                        len--;
 179                }
 180                if (invalid_attr_name(cp, len)) {
 181                        fprintf(stderr,
 182                                "%.*s is not a valid attribute name: %s:%d\n",
 183                                len, cp, src, lineno);
 184                        return NULL;
 185                }
 186        } else {
 187                if (*cp == '-' || *cp == '!') {
 188                        e->setto = (*cp == '-') ? ATTR__FALSE : ATTR__UNSET;
 189                        cp++;
 190                        len--;
 191                }
 192                else if (!equals)
 193                        e->setto = ATTR__TRUE;
 194                else {
 195                        e->setto = xmemdupz(equals + 1, ep - equals - 1);
 196                }
 197                e->attr = git_attr_internal(cp, len);
 198        }
 199        return ep + strspn(ep, blank);
 200}
 201
 202static struct match_attr *parse_attr_line(const char *line, const char *src,
 203                                          int lineno, int macro_ok)
 204{
 205        int namelen;
 206        int num_attr, i;
 207        const char *cp, *name, *states;
 208        struct match_attr *res = NULL;
 209        int is_macro;
 210
 211        cp = line + strspn(line, blank);
 212        if (!*cp || *cp == '#')
 213                return NULL;
 214        name = cp;
 215        namelen = strcspn(name, blank);
 216        if (strlen(ATTRIBUTE_MACRO_PREFIX) < namelen &&
 217            starts_with(name, ATTRIBUTE_MACRO_PREFIX)) {
 218                if (!macro_ok) {
 219                        fprintf(stderr, "%s not allowed: %s:%d\n",
 220                                name, src, lineno);
 221                        return NULL;
 222                }
 223                is_macro = 1;
 224                name += strlen(ATTRIBUTE_MACRO_PREFIX);
 225                name += strspn(name, blank);
 226                namelen = strcspn(name, blank);
 227                if (invalid_attr_name(name, namelen)) {
 228                        fprintf(stderr,
 229                                "%.*s is not a valid attribute name: %s:%d\n",
 230                                namelen, name, src, lineno);
 231                        return NULL;
 232                }
 233        }
 234        else
 235                is_macro = 0;
 236
 237        states = name + namelen;
 238        states += strspn(states, blank);
 239
 240        /* First pass to count the attr_states */
 241        for (cp = states, num_attr = 0; *cp; num_attr++) {
 242                cp = parse_attr(src, lineno, cp, NULL);
 243                if (!cp)
 244                        return NULL;
 245        }
 246
 247        res = xcalloc(1,
 248                      sizeof(*res) +
 249                      sizeof(struct attr_state) * num_attr +
 250                      (is_macro ? 0 : namelen + 1));
 251        if (is_macro) {
 252                res->u.attr = git_attr_internal(name, namelen);
 253                res->u.attr->maybe_macro = 1;
 254        } else {
 255                char *p = (char *)&(res->state[num_attr]);
 256                memcpy(p, name, namelen);
 257                res->u.pat.pattern = p;
 258                parse_exclude_pattern(&res->u.pat.pattern,
 259                                      &res->u.pat.patternlen,
 260                                      &res->u.pat.flags,
 261                                      &res->u.pat.nowildcardlen);
 262                if (res->u.pat.flags & EXC_FLAG_NEGATIVE) {
 263                        warning(_("Negative patterns are ignored in git attributes\n"
 264                                  "Use '\\!' for literal leading exclamation."));
 265                        return NULL;
 266                }
 267        }
 268        res->is_macro = is_macro;
 269        res->num_attr = num_attr;
 270
 271        /* Second pass to fill the attr_states */
 272        for (cp = states, i = 0; *cp; i++) {
 273                cp = parse_attr(src, lineno, cp, &(res->state[i]));
 274                if (!is_macro)
 275                        res->state[i].attr->maybe_real = 1;
 276                if (res->state[i].attr->maybe_macro)
 277                        cannot_trust_maybe_real = 1;
 278        }
 279
 280        return res;
 281}
 282
 283/*
 284 * Like info/exclude and .gitignore, the attribute information can
 285 * come from many places.
 286 *
 287 * (1) .gitattribute file of the same directory;
 288 * (2) .gitattribute file of the parent directory if (1) does not have
 289 *      any match; this goes recursively upwards, just like .gitignore.
 290 * (3) $GIT_DIR/info/attributes, which overrides both of the above.
 291 *
 292 * In the same file, later entries override the earlier match, so in the
 293 * global list, we would have entries from info/attributes the earliest
 294 * (reading the file from top to bottom), .gitattribute of the root
 295 * directory (again, reading the file from top to bottom) down to the
 296 * current directory, and then scan the list backwards to find the first match.
 297 * This is exactly the same as what is_excluded() does in dir.c to deal with
 298 * .gitignore
 299 */
 300
 301static struct attr_stack {
 302        struct attr_stack *prev;
 303        char *origin;
 304        size_t originlen;
 305        unsigned num_matches;
 306        unsigned alloc;
 307        struct match_attr **attrs;
 308} *attr_stack;
 309
 310static void free_attr_elem(struct attr_stack *e)
 311{
 312        int i;
 313        free(e->origin);
 314        for (i = 0; i < e->num_matches; i++) {
 315                struct match_attr *a = e->attrs[i];
 316                int j;
 317                for (j = 0; j < a->num_attr; j++) {
 318                        const char *setto = a->state[j].setto;
 319                        if (setto == ATTR__TRUE ||
 320                            setto == ATTR__FALSE ||
 321                            setto == ATTR__UNSET ||
 322                            setto == ATTR__UNKNOWN)
 323                                ;
 324                        else
 325                                free((char *) setto);
 326                }
 327                free(a);
 328        }
 329        free(e->attrs);
 330        free(e);
 331}
 332
 333static const char *builtin_attr[] = {
 334        "[attr]binary -diff -merge -text",
 335        NULL,
 336};
 337
 338static void handle_attr_line(struct attr_stack *res,
 339                             const char *line,
 340                             const char *src,
 341                             int lineno,
 342                             int macro_ok)
 343{
 344        struct match_attr *a;
 345
 346        a = parse_attr_line(line, src, lineno, macro_ok);
 347        if (!a)
 348                return;
 349        ALLOC_GROW(res->attrs, res->num_matches + 1, res->alloc);
 350        res->attrs[res->num_matches++] = a;
 351}
 352
 353static struct attr_stack *read_attr_from_array(const char **list)
 354{
 355        struct attr_stack *res;
 356        const char *line;
 357        int lineno = 0;
 358
 359        res = xcalloc(1, sizeof(*res));
 360        while ((line = *(list++)) != NULL)
 361                handle_attr_line(res, line, "[builtin]", ++lineno, 1);
 362        return res;
 363}
 364
 365static enum git_attr_direction direction;
 366static struct index_state *use_index;
 367
 368static struct attr_stack *read_attr_from_file(const char *path, int macro_ok)
 369{
 370        FILE *fp = fopen(path, "r");
 371        struct attr_stack *res;
 372        char buf[2048];
 373        int lineno = 0;
 374
 375        if (!fp) {
 376                if (errno != ENOENT && errno != ENOTDIR)
 377                        warn_on_inaccessible(path);
 378                return NULL;
 379        }
 380        res = xcalloc(1, sizeof(*res));
 381        while (fgets(buf, sizeof(buf), fp)) {
 382                char *bufp = buf;
 383                if (!lineno)
 384                        skip_utf8_bom(&bufp, strlen(bufp));
 385                handle_attr_line(res, bufp, path, ++lineno, macro_ok);
 386        }
 387        fclose(fp);
 388        return res;
 389}
 390
 391static struct attr_stack *read_attr_from_index(const char *path, int macro_ok)
 392{
 393        struct attr_stack *res;
 394        char *buf, *sp;
 395        int lineno = 0;
 396
 397        buf = read_blob_data_from_index(use_index ? use_index : &the_index, path, NULL);
 398        if (!buf)
 399                return NULL;
 400
 401        res = xcalloc(1, sizeof(*res));
 402        for (sp = buf; *sp; ) {
 403                char *ep;
 404                int more;
 405                for (ep = sp; *ep && *ep != '\n'; ep++)
 406                        ;
 407                more = (*ep == '\n');
 408                *ep = '\0';
 409                handle_attr_line(res, sp, path, ++lineno, macro_ok);
 410                sp = ep + more;
 411        }
 412        free(buf);
 413        return res;
 414}
 415
 416static struct attr_stack *read_attr(const char *path, int macro_ok)
 417{
 418        struct attr_stack *res;
 419
 420        if (direction == GIT_ATTR_CHECKOUT) {
 421                res = read_attr_from_index(path, macro_ok);
 422                if (!res)
 423                        res = read_attr_from_file(path, macro_ok);
 424        }
 425        else if (direction == GIT_ATTR_CHECKIN) {
 426                res = read_attr_from_file(path, macro_ok);
 427                if (!res)
 428                        /*
 429                         * There is no checked out .gitattributes file there, but
 430                         * we might have it in the index.  We allow operation in a
 431                         * sparsely checked out work tree, so read from it.
 432                         */
 433                        res = read_attr_from_index(path, macro_ok);
 434        }
 435        else
 436                res = read_attr_from_index(path, macro_ok);
 437        if (!res)
 438                res = xcalloc(1, sizeof(*res));
 439        return res;
 440}
 441
 442#if DEBUG_ATTR
 443static void debug_info(const char *what, struct attr_stack *elem)
 444{
 445        fprintf(stderr, "%s: %s\n", what, elem->origin ? elem->origin : "()");
 446}
 447static void debug_set(const char *what, const char *match, struct git_attr *attr, const void *v)
 448{
 449        const char *value = v;
 450
 451        if (ATTR_TRUE(value))
 452                value = "set";
 453        else if (ATTR_FALSE(value))
 454                value = "unset";
 455        else if (ATTR_UNSET(value))
 456                value = "unspecified";
 457
 458        fprintf(stderr, "%s: %s => %s (%s)\n",
 459                what, attr->name, (char *) value, match);
 460}
 461#define debug_push(a) debug_info("push", (a))
 462#define debug_pop(a) debug_info("pop", (a))
 463#else
 464#define debug_push(a) do { ; } while (0)
 465#define debug_pop(a) do { ; } while (0)
 466#define debug_set(a,b,c,d) do { ; } while (0)
 467#endif
 468
 469static void drop_attr_stack(void)
 470{
 471        while (attr_stack) {
 472                struct attr_stack *elem = attr_stack;
 473                attr_stack = elem->prev;
 474                free_attr_elem(elem);
 475        }
 476}
 477
 478static const char *git_etc_gitattributes(void)
 479{
 480        static const char *system_wide;
 481        if (!system_wide)
 482                system_wide = system_path(ETC_GITATTRIBUTES);
 483        return system_wide;
 484}
 485
 486static int git_attr_system(void)
 487{
 488        return !git_env_bool("GIT_ATTR_NOSYSTEM", 0);
 489}
 490
 491static GIT_PATH_FUNC(git_path_info_attributes, INFOATTRIBUTES_FILE)
 492
 493static void bootstrap_attr_stack(void)
 494{
 495        struct attr_stack *elem;
 496
 497        if (attr_stack)
 498                return;
 499
 500        elem = read_attr_from_array(builtin_attr);
 501        elem->origin = NULL;
 502        elem->prev = attr_stack;
 503        attr_stack = elem;
 504
 505        if (git_attr_system()) {
 506                elem = read_attr_from_file(git_etc_gitattributes(), 1);
 507                if (elem) {
 508                        elem->origin = NULL;
 509                        elem->prev = attr_stack;
 510                        attr_stack = elem;
 511                }
 512        }
 513
 514        if (!git_attributes_file)
 515                git_attributes_file = xdg_config_home("attributes");
 516        if (git_attributes_file) {
 517                elem = read_attr_from_file(git_attributes_file, 1);
 518                if (elem) {
 519                        elem->origin = NULL;
 520                        elem->prev = attr_stack;
 521                        attr_stack = elem;
 522                }
 523        }
 524
 525        if (!is_bare_repository() || direction == GIT_ATTR_INDEX) {
 526                elem = read_attr(GITATTRIBUTES_FILE, 1);
 527                elem->origin = xstrdup("");
 528                elem->originlen = 0;
 529                elem->prev = attr_stack;
 530                attr_stack = elem;
 531                debug_push(elem);
 532        }
 533
 534        elem = read_attr_from_file(git_path_info_attributes(), 1);
 535        if (!elem)
 536                elem = xcalloc(1, sizeof(*elem));
 537        elem->origin = NULL;
 538        elem->prev = attr_stack;
 539        attr_stack = elem;
 540}
 541
 542static void prepare_attr_stack(const char *path, int dirlen)
 543{
 544        struct attr_stack *elem, *info;
 545        int len;
 546        const char *cp;
 547
 548        /*
 549         * At the bottom of the attribute stack is the built-in
 550         * set of attribute definitions, followed by the contents
 551         * of $(prefix)/etc/gitattributes and a file specified by
 552         * core.attributesfile.  Then, contents from
 553         * .gitattribute files from directories closer to the
 554         * root to the ones in deeper directories are pushed
 555         * to the stack.  Finally, at the very top of the stack
 556         * we always keep the contents of $GIT_DIR/info/attributes.
 557         *
 558         * When checking, we use entries from near the top of the
 559         * stack, preferring $GIT_DIR/info/attributes, then
 560         * .gitattributes in deeper directories to shallower ones,
 561         * and finally use the built-in set as the default.
 562         */
 563        bootstrap_attr_stack();
 564
 565        /*
 566         * Pop the "info" one that is always at the top of the stack.
 567         */
 568        info = attr_stack;
 569        attr_stack = info->prev;
 570
 571        /*
 572         * Pop the ones from directories that are not the prefix of
 573         * the path we are checking. Break out of the loop when we see
 574         * the root one (whose origin is an empty string "") or the builtin
 575         * one (whose origin is NULL) without popping it.
 576         */
 577        while (attr_stack->origin) {
 578                int namelen = strlen(attr_stack->origin);
 579
 580                elem = attr_stack;
 581                if (namelen <= dirlen &&
 582                    !strncmp(elem->origin, path, namelen) &&
 583                    (!namelen || path[namelen] == '/'))
 584                        break;
 585
 586                debug_pop(elem);
 587                attr_stack = elem->prev;
 588                free_attr_elem(elem);
 589        }
 590
 591        /*
 592         * Read from parent directories and push them down
 593         */
 594        if (!is_bare_repository() || direction == GIT_ATTR_INDEX) {
 595                /*
 596                 * bootstrap_attr_stack() should have added, and the
 597                 * above loop should have stopped before popping, the
 598                 * root element whose attr_stack->origin is set to an
 599                 * empty string.
 600                 */
 601                struct strbuf pathbuf = STRBUF_INIT;
 602
 603                assert(attr_stack->origin);
 604                while (1) {
 605                        len = strlen(attr_stack->origin);
 606                        if (dirlen <= len)
 607                                break;
 608                        cp = memchr(path + len + 1, '/', dirlen - len - 1);
 609                        if (!cp)
 610                                cp = path + dirlen;
 611                        strbuf_add(&pathbuf, path, cp - path);
 612                        strbuf_addch(&pathbuf, '/');
 613                        strbuf_addstr(&pathbuf, GITATTRIBUTES_FILE);
 614                        elem = read_attr(pathbuf.buf, 0);
 615                        strbuf_setlen(&pathbuf, cp - path);
 616                        elem->origin = strbuf_detach(&pathbuf, &elem->originlen);
 617                        elem->prev = attr_stack;
 618                        attr_stack = elem;
 619                        debug_push(elem);
 620                }
 621
 622                strbuf_release(&pathbuf);
 623        }
 624
 625        /*
 626         * Finally push the "info" one at the top of the stack.
 627         */
 628        info->prev = attr_stack;
 629        attr_stack = info;
 630}
 631
 632static int path_matches(const char *pathname, int pathlen,
 633                        int basename_offset,
 634                        const struct pattern *pat,
 635                        const char *base, int baselen)
 636{
 637        const char *pattern = pat->pattern;
 638        int prefix = pat->nowildcardlen;
 639        int isdir = (pathlen && pathname[pathlen - 1] == '/');
 640
 641        if ((pat->flags & EXC_FLAG_MUSTBEDIR) && !isdir)
 642                return 0;
 643
 644        if (pat->flags & EXC_FLAG_NODIR) {
 645                return match_basename(pathname + basename_offset,
 646                                      pathlen - basename_offset - isdir,
 647                                      pattern, prefix,
 648                                      pat->patternlen, pat->flags);
 649        }
 650        return match_pathname(pathname, pathlen - isdir,
 651                              base, baselen,
 652                              pattern, prefix, pat->patternlen, pat->flags);
 653}
 654
 655static int macroexpand_one(int attr_nr, int rem);
 656
 657static int fill_one(const char *what, struct match_attr *a, int rem)
 658{
 659        struct git_attr_check *check = check_all_attr;
 660        int i;
 661
 662        for (i = a->num_attr - 1; 0 < rem && 0 <= i; i--) {
 663                struct git_attr *attr = a->state[i].attr;
 664                const char **n = &(check[attr->attr_nr].value);
 665                const char *v = a->state[i].setto;
 666
 667                if (*n == ATTR__UNKNOWN) {
 668                        debug_set(what,
 669                                  a->is_macro ? a->u.attr->name : a->u.pat.pattern,
 670                                  attr, v);
 671                        *n = v;
 672                        rem--;
 673                        rem = macroexpand_one(attr->attr_nr, rem);
 674                }
 675        }
 676        return rem;
 677}
 678
 679static int fill(const char *path, int pathlen, int basename_offset,
 680                struct attr_stack *stk, int rem)
 681{
 682        int i;
 683        const char *base = stk->origin ? stk->origin : "";
 684
 685        for (i = stk->num_matches - 1; 0 < rem && 0 <= i; i--) {
 686                struct match_attr *a = stk->attrs[i];
 687                if (a->is_macro)
 688                        continue;
 689                if (path_matches(path, pathlen, basename_offset,
 690                                 &a->u.pat, base, stk->originlen))
 691                        rem = fill_one("fill", a, rem);
 692        }
 693        return rem;
 694}
 695
 696static int macroexpand_one(int nr, int rem)
 697{
 698        struct attr_stack *stk;
 699        struct match_attr *a = NULL;
 700        int i;
 701
 702        if (check_all_attr[nr].value != ATTR__TRUE ||
 703            !check_all_attr[nr].attr->maybe_macro)
 704                return rem;
 705
 706        for (stk = attr_stack; !a && stk; stk = stk->prev)
 707                for (i = stk->num_matches - 1; !a && 0 <= i; i--) {
 708                        struct match_attr *ma = stk->attrs[i];
 709                        if (!ma->is_macro)
 710                                continue;
 711                        if (ma->u.attr->attr_nr == nr)
 712                                a = ma;
 713                }
 714
 715        if (a)
 716                rem = fill_one("expand", a, rem);
 717
 718        return rem;
 719}
 720
 721/*
 722 * Collect attributes for path into the array pointed to by
 723 * check_all_attr. If num is non-zero, only attributes in check[] are
 724 * collected. Otherwise all attributes are collected.
 725 */
 726static void collect_some_attrs(const char *path, int num,
 727                               struct git_attr_check *check)
 728
 729{
 730        struct attr_stack *stk;
 731        int i, pathlen, rem, dirlen;
 732        const char *cp, *last_slash = NULL;
 733        int basename_offset;
 734
 735        for (cp = path; *cp; cp++) {
 736                if (*cp == '/' && cp[1])
 737                        last_slash = cp;
 738        }
 739        pathlen = cp - path;
 740        if (last_slash) {
 741                basename_offset = last_slash + 1 - path;
 742                dirlen = last_slash - path;
 743        } else {
 744                basename_offset = 0;
 745                dirlen = 0;
 746        }
 747
 748        prepare_attr_stack(path, dirlen);
 749        for (i = 0; i < attr_nr; i++)
 750                check_all_attr[i].value = ATTR__UNKNOWN;
 751        if (num && !cannot_trust_maybe_real) {
 752                rem = 0;
 753                for (i = 0; i < num; i++) {
 754                        if (!check[i].attr->maybe_real) {
 755                                struct git_attr_check *c;
 756                                c = check_all_attr + check[i].attr->attr_nr;
 757                                c->value = ATTR__UNSET;
 758                                rem++;
 759                        }
 760                }
 761                if (rem == num)
 762                        return;
 763        }
 764
 765        rem = attr_nr;
 766        for (stk = attr_stack; 0 < rem && stk; stk = stk->prev)
 767                rem = fill(path, pathlen, basename_offset, stk, rem);
 768}
 769
 770int git_check_attr(const char *path, int num, struct git_attr_check *check)
 771{
 772        int i;
 773
 774        collect_some_attrs(path, num, check);
 775
 776        for (i = 0; i < num; i++) {
 777                const char *value = check_all_attr[check[i].attr->attr_nr].value;
 778                if (value == ATTR__UNKNOWN)
 779                        value = ATTR__UNSET;
 780                check[i].value = value;
 781        }
 782
 783        return 0;
 784}
 785
 786int git_all_attrs(const char *path, int *num, struct git_attr_check **check)
 787{
 788        int i, count, j;
 789
 790        collect_some_attrs(path, 0, NULL);
 791
 792        /* Count the number of attributes that are set. */
 793        count = 0;
 794        for (i = 0; i < attr_nr; i++) {
 795                const char *value = check_all_attr[i].value;
 796                if (value != ATTR__UNSET && value != ATTR__UNKNOWN)
 797                        ++count;
 798        }
 799        *num = count;
 800        ALLOC_ARRAY(*check, count);
 801        j = 0;
 802        for (i = 0; i < attr_nr; i++) {
 803                const char *value = check_all_attr[i].value;
 804                if (value != ATTR__UNSET && value != ATTR__UNKNOWN) {
 805                        (*check)[j].attr = check_all_attr[i].attr;
 806                        (*check)[j].value = value;
 807                        ++j;
 808                }
 809        }
 810
 811        return 0;
 812}
 813
 814void git_attr_set_direction(enum git_attr_direction new, struct index_state *istate)
 815{
 816        enum git_attr_direction old = direction;
 817
 818        if (is_bare_repository() && new != GIT_ATTR_INDEX)
 819                die("BUG: non-INDEX attr direction in a bare repo");
 820
 821        direction = new;
 822        if (new != old)
 823                drop_attr_stack();
 824        use_index = istate;
 825}