b56542e7234161518a131d3e3edbb8c20c50fbab
   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                for (cp = states, num_attr = 0; *cp; num_attr++) {
 232                        cp = parse_attr(src, lineno, cp,
 233                                pass ? &(res->state[num_attr]) : NULL);
 234                        if (!cp)
 235                                return NULL;
 236                }
 237                if (pass)
 238                        break;
 239                res = xcalloc(1,
 240                              sizeof(*res) +
 241                              sizeof(struct attr_state) * num_attr +
 242                              (is_macro ? 0 : namelen + 1));
 243                if (is_macro)
 244                        res->u.attr = git_attr_internal(name, namelen);
 245                else {
 246                        res->u.pattern = (char *)&(res->state[num_attr]);
 247                        memcpy(res->u.pattern, name, namelen);
 248                        res->u.pattern[namelen] = 0;
 249                }
 250                res->is_macro = is_macro;
 251                res->num_attr = num_attr;
 252        }
 253        return res;
 254}
 255
 256/*
 257 * Like info/exclude and .gitignore, the attribute information can
 258 * come from many places.
 259 *
 260 * (1) .gitattribute file of the same directory;
 261 * (2) .gitattribute file of the parent directory if (1) does not have
 262 *      any match; this goes recursively upwards, just like .gitignore.
 263 * (3) $GIT_DIR/info/attributes, which overrides both of the above.
 264 *
 265 * In the same file, later entries override the earlier match, so in the
 266 * global list, we would have entries from info/attributes the earliest
 267 * (reading the file from top to bottom), .gitattribute of the root
 268 * directory (again, reading the file from top to bottom) down to the
 269 * current directory, and then scan the list backwards to find the first match.
 270 * This is exactly the same as what excluded() does in dir.c to deal with
 271 * .gitignore
 272 */
 273
 274static struct attr_stack {
 275        struct attr_stack *prev;
 276        char *origin;
 277        unsigned num_matches;
 278        unsigned alloc;
 279        struct match_attr **attrs;
 280} *attr_stack;
 281
 282static void free_attr_elem(struct attr_stack *e)
 283{
 284        int i;
 285        free(e->origin);
 286        for (i = 0; i < e->num_matches; i++) {
 287                struct match_attr *a = e->attrs[i];
 288                int j;
 289                for (j = 0; j < a->num_attr; j++) {
 290                        const char *setto = a->state[j].setto;
 291                        if (setto == ATTR__TRUE ||
 292                            setto == ATTR__FALSE ||
 293                            setto == ATTR__UNSET ||
 294                            setto == ATTR__UNKNOWN)
 295                                ;
 296                        else
 297                                free((char *) setto);
 298                }
 299                free(a);
 300        }
 301        free(e);
 302}
 303
 304static const char *builtin_attr[] = {
 305        "[attr]binary -diff -text",
 306        NULL,
 307};
 308
 309static void handle_attr_line(struct attr_stack *res,
 310                             const char *line,
 311                             const char *src,
 312                             int lineno,
 313                             int macro_ok)
 314{
 315        struct match_attr *a;
 316
 317        a = parse_attr_line(line, src, lineno, macro_ok);
 318        if (!a)
 319                return;
 320        if (res->alloc <= res->num_matches) {
 321                res->alloc = alloc_nr(res->num_matches);
 322                res->attrs = xrealloc(res->attrs,
 323                                      sizeof(struct match_attr *) *
 324                                      res->alloc);
 325        }
 326        res->attrs[res->num_matches++] = a;
 327}
 328
 329static struct attr_stack *read_attr_from_array(const char **list)
 330{
 331        struct attr_stack *res;
 332        const char *line;
 333        int lineno = 0;
 334
 335        res = xcalloc(1, sizeof(*res));
 336        while ((line = *(list++)) != NULL)
 337                handle_attr_line(res, line, "[builtin]", ++lineno, 1);
 338        return res;
 339}
 340
 341static enum git_attr_direction direction;
 342static struct index_state *use_index;
 343
 344static struct attr_stack *read_attr_from_file(const char *path, int macro_ok)
 345{
 346        FILE *fp = fopen(path, "r");
 347        struct attr_stack *res;
 348        char buf[2048];
 349        int lineno = 0;
 350
 351        if (!fp)
 352                return NULL;
 353        res = xcalloc(1, sizeof(*res));
 354        while (fgets(buf, sizeof(buf), fp))
 355                handle_attr_line(res, buf, path, ++lineno, macro_ok);
 356        fclose(fp);
 357        return res;
 358}
 359
 360static void *read_index_data(const char *path)
 361{
 362        int pos, len;
 363        unsigned long sz;
 364        enum object_type type;
 365        void *data;
 366        struct index_state *istate = use_index ? use_index : &the_index;
 367
 368        len = strlen(path);
 369        pos = index_name_pos(istate, path, len);
 370        if (pos < 0) {
 371                /*
 372                 * We might be in the middle of a merge, in which
 373                 * case we would read stage #2 (ours).
 374                 */
 375                int i;
 376                for (i = -pos - 1;
 377                     (pos < 0 && i < istate->cache_nr &&
 378                      !strcmp(istate->cache[i]->name, path));
 379                     i++)
 380                        if (ce_stage(istate->cache[i]) == 2)
 381                                pos = i;
 382        }
 383        if (pos < 0)
 384                return NULL;
 385        data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
 386        if (!data || type != OBJ_BLOB) {
 387                free(data);
 388                return NULL;
 389        }
 390        return data;
 391}
 392
 393static struct attr_stack *read_attr_from_index(const char *path, int macro_ok)
 394{
 395        struct attr_stack *res;
 396        char *buf, *sp;
 397        int lineno = 0;
 398
 399        buf = read_index_data(path);
 400        if (!buf)
 401                return NULL;
 402
 403        res = xcalloc(1, sizeof(*res));
 404        for (sp = buf; *sp; ) {
 405                char *ep;
 406                int more;
 407                for (ep = sp; *ep && *ep != '\n'; ep++)
 408                        ;
 409                more = (*ep == '\n');
 410                *ep = '\0';
 411                handle_attr_line(res, sp, path, ++lineno, macro_ok);
 412                sp = ep + more;
 413        }
 414        free(buf);
 415        return res;
 416}
 417
 418static struct attr_stack *read_attr(const char *path, int macro_ok)
 419{
 420        struct attr_stack *res;
 421
 422        if (direction == GIT_ATTR_CHECKOUT) {
 423                res = read_attr_from_index(path, macro_ok);
 424                if (!res)
 425                        res = read_attr_from_file(path, macro_ok);
 426        }
 427        else if (direction == GIT_ATTR_CHECKIN) {
 428                res = read_attr_from_file(path, macro_ok);
 429                if (!res)
 430                        /*
 431                         * There is no checked out .gitattributes file there, but
 432                         * we might have it in the index.  We allow operation in a
 433                         * sparsely checked out work tree, so read from it.
 434                         */
 435                        res = read_attr_from_index(path, macro_ok);
 436        }
 437        else
 438                res = read_attr_from_index(path, macro_ok);
 439        if (!res)
 440                res = xcalloc(1, sizeof(*res));
 441        return res;
 442}
 443
 444#if DEBUG_ATTR
 445static void debug_info(const char *what, struct attr_stack *elem)
 446{
 447        fprintf(stderr, "%s: %s\n", what, elem->origin ? elem->origin : "()");
 448}
 449static void debug_set(const char *what, const char *match, struct git_attr *attr, const void *v)
 450{
 451        const char *value = v;
 452
 453        if (ATTR_TRUE(value))
 454                value = "set";
 455        else if (ATTR_FALSE(value))
 456                value = "unset";
 457        else if (ATTR_UNSET(value))
 458                value = "unspecified";
 459
 460        fprintf(stderr, "%s: %s => %s (%s)\n",
 461                what, attr->name, (char *) value, match);
 462}
 463#define debug_push(a) debug_info("push", (a))
 464#define debug_pop(a) debug_info("pop", (a))
 465#else
 466#define debug_push(a) do { ; } while (0)
 467#define debug_pop(a) do { ; } while (0)
 468#define debug_set(a,b,c,d) do { ; } while (0)
 469#endif
 470
 471static void drop_attr_stack(void)
 472{
 473        while (attr_stack) {
 474                struct attr_stack *elem = attr_stack;
 475                attr_stack = elem->prev;
 476                free_attr_elem(elem);
 477        }
 478}
 479
 480static const char *git_etc_gitattributes(void)
 481{
 482        static const char *system_wide;
 483        if (!system_wide)
 484                system_wide = system_path(ETC_GITATTRIBUTES);
 485        return system_wide;
 486}
 487
 488static int git_attr_system(void)
 489{
 490        return !git_env_bool("GIT_ATTR_NOSYSTEM", 0);
 491}
 492
 493static int git_attr_config(const char *var, const char *value, void *dummy)
 494{
 495        if (!strcmp(var, "core.attributesfile"))
 496                return git_config_pathname(&attributes_file, var, value);
 497
 498        return 0;
 499}
 500
 501static void bootstrap_attr_stack(void)
 502{
 503        if (!attr_stack) {
 504                struct attr_stack *elem;
 505
 506                elem = read_attr_from_array(builtin_attr);
 507                elem->origin = NULL;
 508                elem->prev = attr_stack;
 509                attr_stack = elem;
 510
 511                if (git_attr_system()) {
 512                        elem = read_attr_from_file(git_etc_gitattributes(), 1);
 513                        if (elem) {
 514                                elem->origin = NULL;
 515                                elem->prev = attr_stack;
 516                                attr_stack = elem;
 517                        }
 518                }
 519
 520                git_config(git_attr_config, NULL);
 521                if (attributes_file) {
 522                        elem = read_attr_from_file(attributes_file, 1);
 523                        if (elem) {
 524                                elem->origin = NULL;
 525                                elem->prev = attr_stack;
 526                                attr_stack = elem;
 527                        }
 528                }
 529
 530                if (!is_bare_repository() || direction == GIT_ATTR_INDEX) {
 531                        elem = read_attr(GITATTRIBUTES_FILE, 1);
 532                        elem->origin = strdup("");
 533                        elem->prev = attr_stack;
 534                        attr_stack = elem;
 535                        debug_push(elem);
 536                }
 537
 538                elem = read_attr_from_file(git_path(INFOATTRIBUTES_FILE), 1);
 539                if (!elem)
 540                        elem = xcalloc(1, sizeof(*elem));
 541                elem->origin = NULL;
 542                elem->prev = attr_stack;
 543                attr_stack = elem;
 544        }
 545}
 546
 547static void prepare_attr_stack(const char *path, int dirlen)
 548{
 549        struct attr_stack *elem, *info;
 550        int len;
 551        struct strbuf pathbuf;
 552
 553        strbuf_init(&pathbuf, dirlen+2+strlen(GITATTRIBUTES_FILE));
 554
 555        /*
 556         * At the bottom of the attribute stack is the built-in
 557         * set of attribute definitions, followed by the contents
 558         * of $(prefix)/etc/gitattributes and a file specified by
 559         * core.attributesfile.  Then, contents from
 560         * .gitattribute files from directories closer to the
 561         * root to the ones in deeper directories are pushed
 562         * to the stack.  Finally, at the very top of the stack
 563         * we always keep the contents of $GIT_DIR/info/attributes.
 564         *
 565         * When checking, we use entries from near the top of the
 566         * stack, preferring $GIT_DIR/info/attributes, then
 567         * .gitattributes in deeper directories to shallower ones,
 568         * and finally use the built-in set as the default.
 569         */
 570        if (!attr_stack)
 571                bootstrap_attr_stack();
 572
 573        /*
 574         * Pop the "info" one that is always at the top of the stack.
 575         */
 576        info = attr_stack;
 577        attr_stack = info->prev;
 578
 579        /*
 580         * Pop the ones from directories that are not the prefix of
 581         * the path we are checking.
 582         */
 583        while (attr_stack && attr_stack->origin) {
 584                int namelen = strlen(attr_stack->origin);
 585
 586                elem = attr_stack;
 587                if (namelen <= dirlen &&
 588                    !strncmp(elem->origin, path, namelen))
 589                        break;
 590
 591                debug_pop(elem);
 592                attr_stack = elem->prev;
 593                free_attr_elem(elem);
 594        }
 595
 596        /*
 597         * Read from parent directories and push them down
 598         */
 599        if (!is_bare_repository() || direction == GIT_ATTR_INDEX) {
 600                while (1) {
 601                        char *cp;
 602
 603                        len = strlen(attr_stack->origin);
 604                        if (dirlen <= len)
 605                                break;
 606                        strbuf_reset(&pathbuf);
 607                        strbuf_add(&pathbuf, path, dirlen);
 608                        strbuf_addch(&pathbuf, '/');
 609                        cp = strchr(pathbuf.buf + len + 1, '/');
 610                        strcpy(cp + 1, GITATTRIBUTES_FILE);
 611                        elem = read_attr(pathbuf.buf, 0);
 612                        *cp = '\0';
 613                        elem->origin = strdup(pathbuf.buf);
 614                        elem->prev = attr_stack;
 615                        attr_stack = elem;
 616                        debug_push(elem);
 617                }
 618        }
 619
 620        strbuf_release(&pathbuf);
 621
 622        /*
 623         * Finally push the "info" one at the top of the stack.
 624         */
 625        info->prev = attr_stack;
 626        attr_stack = info;
 627}
 628
 629static int path_matches(const char *pathname, int pathlen,
 630                        const char *pattern,
 631                        const char *base, int baselen)
 632{
 633        if (!strchr(pattern, '/')) {
 634                /* match basename */
 635                const char *basename = strrchr(pathname, '/');
 636                basename = basename ? basename + 1 : pathname;
 637                return (fnmatch(pattern, basename, 0) == 0);
 638        }
 639        /*
 640         * match with FNM_PATHNAME; the pattern has base implicitly
 641         * in front of it.
 642         */
 643        if (*pattern == '/')
 644                pattern++;
 645        if (pathlen < baselen ||
 646            (baselen && pathname[baselen] != '/') ||
 647            strncmp(pathname, base, baselen))
 648                return 0;
 649        if (baselen != 0)
 650                baselen++;
 651        return fnmatch(pattern, pathname + baselen, FNM_PATHNAME) == 0;
 652}
 653
 654static int macroexpand_one(int attr_nr, int rem);
 655
 656static int fill_one(const char *what, struct match_attr *a, int rem)
 657{
 658        struct git_attr_check *check = check_all_attr;
 659        int i;
 660
 661        for (i = a->num_attr - 1; 0 < rem && 0 <= i; i--) {
 662                struct git_attr *attr = a->state[i].attr;
 663                const char **n = &(check[attr->attr_nr].value);
 664                const char *v = a->state[i].setto;
 665
 666                if (*n == ATTR__UNKNOWN) {
 667                        debug_set(what,
 668                                  a->is_macro ? a->u.attr->name : a->u.pattern,
 669                                  attr, v);
 670                        *n = v;
 671                        rem--;
 672                        rem = macroexpand_one(attr->attr_nr, rem);
 673                }
 674        }
 675        return rem;
 676}
 677
 678static int fill(const char *path, int pathlen, struct attr_stack *stk, int rem)
 679{
 680        int i;
 681        const char *base = stk->origin ? stk->origin : "";
 682
 683        for (i = stk->num_matches - 1; 0 < rem && 0 <= i; i--) {
 684                struct match_attr *a = stk->attrs[i];
 685                if (a->is_macro)
 686                        continue;
 687                if (path_matches(path, pathlen,
 688                                 a->u.pattern, base, strlen(base)))
 689                        rem = fill_one("fill", a, rem);
 690        }
 691        return rem;
 692}
 693
 694static int macroexpand_one(int attr_nr, int rem)
 695{
 696        struct attr_stack *stk;
 697        struct match_attr *a = NULL;
 698        int i;
 699
 700        if (check_all_attr[attr_nr].value != ATTR__TRUE)
 701                return rem;
 702
 703        for (stk = attr_stack; !a && stk; stk = stk->prev)
 704                for (i = stk->num_matches - 1; !a && 0 <= i; i--) {
 705                        struct match_attr *ma = stk->attrs[i];
 706                        if (!ma->is_macro)
 707                                continue;
 708                        if (ma->u.attr->attr_nr == attr_nr)
 709                                a = ma;
 710                }
 711
 712        if (a)
 713                rem = fill_one("expand", a, rem);
 714
 715        return rem;
 716}
 717
 718int git_checkattr(const char *path, int num, struct git_attr_check *check)
 719{
 720        struct attr_stack *stk;
 721        const char *cp;
 722        int dirlen, pathlen, i, rem;
 723
 724        bootstrap_attr_stack();
 725        for (i = 0; i < attr_nr; i++)
 726                check_all_attr[i].value = ATTR__UNKNOWN;
 727
 728        pathlen = strlen(path);
 729        cp = strrchr(path, '/');
 730        if (!cp)
 731                dirlen = 0;
 732        else
 733                dirlen = cp - path;
 734        prepare_attr_stack(path, dirlen);
 735        rem = attr_nr;
 736        for (stk = attr_stack; 0 < rem && stk; stk = stk->prev)
 737                rem = fill(path, pathlen, stk, rem);
 738
 739        for (i = 0; i < num; i++) {
 740                const char *value = check_all_attr[check[i].attr->attr_nr].value;
 741                if (value == ATTR__UNKNOWN)
 742                        value = ATTR__UNSET;
 743                check[i].value = value;
 744        }
 745
 746        return 0;
 747}
 748
 749void git_attr_set_direction(enum git_attr_direction new, struct index_state *istate)
 750{
 751        enum git_attr_direction old = direction;
 752
 753        if (is_bare_repository() && new != GIT_ATTR_INDEX)
 754                die("BUG: non-INDEX attr direction in a bare repo");
 755
 756        direction = new;
 757        if (new != old)
 758                drop_attr_stack();
 759        use_index = istate;
 760}