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