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