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