6b53ea2eeb7cd62790aaba8c72afa4afe00e23c6
   1#include "cache.h"
   2#include "config.h"
   3#include "tag.h"
   4#include "commit.h"
   5#include "tree.h"
   6#include "blob.h"
   7#include "tree-walk.h"
   8#include "refs.h"
   9#include "remote.h"
  10#include "dir.h"
  11#include "sha1-array.h"
  12#include "packfile.h"
  13#include "object-store.h"
  14#include "repository.h"
  15#include "midx.h"
  16#include "commit-reach.h"
  17
  18static int get_oid_oneline(struct repository *r, const char *, struct object_id *, struct commit_list *);
  19
  20typedef int (*disambiguate_hint_fn)(struct repository *, const struct object_id *, void *);
  21
  22struct disambiguate_state {
  23        int len; /* length of prefix in hex chars */
  24        char hex_pfx[GIT_MAX_HEXSZ + 1];
  25        struct object_id bin_pfx;
  26
  27        struct repository *repo;
  28        disambiguate_hint_fn fn;
  29        void *cb_data;
  30        struct object_id candidate;
  31        unsigned candidate_exists:1;
  32        unsigned candidate_checked:1;
  33        unsigned candidate_ok:1;
  34        unsigned disambiguate_fn_used:1;
  35        unsigned ambiguous:1;
  36        unsigned always_call_fn:1;
  37};
  38
  39static void update_candidates(struct disambiguate_state *ds, const struct object_id *current)
  40{
  41        if (ds->always_call_fn) {
  42                ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0;
  43                return;
  44        }
  45        if (!ds->candidate_exists) {
  46                /* this is the first candidate */
  47                oidcpy(&ds->candidate, current);
  48                ds->candidate_exists = 1;
  49                return;
  50        } else if (oideq(&ds->candidate, current)) {
  51                /* the same as what we already have seen */
  52                return;
  53        }
  54
  55        if (!ds->fn) {
  56                /* cannot disambiguate between ds->candidate and current */
  57                ds->ambiguous = 1;
  58                return;
  59        }
  60
  61        if (!ds->candidate_checked) {
  62                ds->candidate_ok = ds->fn(ds->repo, &ds->candidate, ds->cb_data);
  63                ds->disambiguate_fn_used = 1;
  64                ds->candidate_checked = 1;
  65        }
  66
  67        if (!ds->candidate_ok) {
  68                /* discard the candidate; we know it does not satisfy fn */
  69                oidcpy(&ds->candidate, current);
  70                ds->candidate_checked = 0;
  71                return;
  72        }
  73
  74        /* if we reach this point, we know ds->candidate satisfies fn */
  75        if (ds->fn(ds->repo, current, ds->cb_data)) {
  76                /*
  77                 * if both current and candidate satisfy fn, we cannot
  78                 * disambiguate.
  79                 */
  80                ds->candidate_ok = 0;
  81                ds->ambiguous = 1;
  82        }
  83
  84        /* otherwise, current can be discarded and candidate is still good */
  85}
  86
  87static int match_sha(unsigned, const unsigned char *, const unsigned char *);
  88
  89static void find_short_object_filename(struct disambiguate_state *ds)
  90{
  91        struct object_directory *odb;
  92
  93        for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) {
  94                int pos;
  95                struct oid_array *loose_objects;
  96
  97                loose_objects = odb_loose_cache(odb, &ds->bin_pfx);
  98                pos = oid_array_lookup(loose_objects, &ds->bin_pfx);
  99                if (pos < 0)
 100                        pos = -1 - pos;
 101                while (!ds->ambiguous && pos < loose_objects->nr) {
 102                        const struct object_id *oid;
 103                        oid = loose_objects->oid + pos;
 104                        if (!match_sha(ds->len, ds->bin_pfx.hash, oid->hash))
 105                                break;
 106                        update_candidates(ds, oid);
 107                        pos++;
 108                }
 109        }
 110}
 111
 112static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
 113{
 114        do {
 115                if (*a != *b)
 116                        return 0;
 117                a++;
 118                b++;
 119                len -= 2;
 120        } while (len > 1);
 121        if (len)
 122                if ((*a ^ *b) & 0xf0)
 123                        return 0;
 124        return 1;
 125}
 126
 127static void unique_in_midx(struct multi_pack_index *m,
 128                           struct disambiguate_state *ds)
 129{
 130        uint32_t num, i, first = 0;
 131        const struct object_id *current = NULL;
 132        num = m->num_objects;
 133
 134        if (!num)
 135                return;
 136
 137        bsearch_midx(&ds->bin_pfx, m, &first);
 138
 139        /*
 140         * At this point, "first" is the location of the lowest object
 141         * with an object name that could match "bin_pfx".  See if we have
 142         * 0, 1 or more objects that actually match(es).
 143         */
 144        for (i = first; i < num && !ds->ambiguous; i++) {
 145                struct object_id oid;
 146                current = nth_midxed_object_oid(&oid, m, i);
 147                if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash))
 148                        break;
 149                update_candidates(ds, current);
 150        }
 151}
 152
 153static void unique_in_pack(struct packed_git *p,
 154                           struct disambiguate_state *ds)
 155{
 156        uint32_t num, i, first = 0;
 157        const struct object_id *current = NULL;
 158
 159        if (open_pack_index(p) || !p->num_objects)
 160                return;
 161
 162        num = p->num_objects;
 163        bsearch_pack(&ds->bin_pfx, p, &first);
 164
 165        /*
 166         * At this point, "first" is the location of the lowest object
 167         * with an object name that could match "bin_pfx".  See if we have
 168         * 0, 1 or more objects that actually match(es).
 169         */
 170        for (i = first; i < num && !ds->ambiguous; i++) {
 171                struct object_id oid;
 172                current = nth_packed_object_oid(&oid, p, i);
 173                if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash))
 174                        break;
 175                update_candidates(ds, current);
 176        }
 177}
 178
 179static void find_short_packed_object(struct disambiguate_state *ds)
 180{
 181        struct multi_pack_index *m;
 182        struct packed_git *p;
 183
 184        for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous;
 185             m = m->next)
 186                unique_in_midx(m, ds);
 187        for (p = get_packed_git(ds->repo); p && !ds->ambiguous;
 188             p = p->next)
 189                unique_in_pack(p, ds);
 190}
 191
 192static int finish_object_disambiguation(struct disambiguate_state *ds,
 193                                        struct object_id *oid)
 194{
 195        if (ds->ambiguous)
 196                return SHORT_NAME_AMBIGUOUS;
 197
 198        if (!ds->candidate_exists)
 199                return MISSING_OBJECT;
 200
 201        if (!ds->candidate_checked)
 202                /*
 203                 * If this is the only candidate, there is no point
 204                 * calling the disambiguation hint callback.
 205                 *
 206                 * On the other hand, if the current candidate
 207                 * replaced an earlier candidate that did _not_ pass
 208                 * the disambiguation hint callback, then we do have
 209                 * more than one objects that match the short name
 210                 * given, so we should make sure this one matches;
 211                 * otherwise, if we discovered this one and the one
 212                 * that we previously discarded in the reverse order,
 213                 * we would end up showing different results in the
 214                 * same repository!
 215                 */
 216                ds->candidate_ok = (!ds->disambiguate_fn_used ||
 217                                    ds->fn(ds->repo, &ds->candidate, ds->cb_data));
 218
 219        if (!ds->candidate_ok)
 220                return SHORT_NAME_AMBIGUOUS;
 221
 222        oidcpy(oid, &ds->candidate);
 223        return 0;
 224}
 225
 226static int disambiguate_commit_only(struct repository *r,
 227                                    const struct object_id *oid,
 228                                    void *cb_data_unused)
 229{
 230        int kind = oid_object_info(r, oid, NULL);
 231        return kind == OBJ_COMMIT;
 232}
 233
 234static int disambiguate_committish_only(struct repository *r,
 235                                        const struct object_id *oid,
 236                                        void *cb_data_unused)
 237{
 238        struct object *obj;
 239        int kind;
 240
 241        kind = oid_object_info(r, oid, NULL);
 242        if (kind == OBJ_COMMIT)
 243                return 1;
 244        if (kind != OBJ_TAG)
 245                return 0;
 246
 247        /* We need to do this the hard way... */
 248        obj = deref_tag(r, parse_object(r, oid), NULL, 0);
 249        if (obj && obj->type == OBJ_COMMIT)
 250                return 1;
 251        return 0;
 252}
 253
 254static int disambiguate_tree_only(struct repository *r,
 255                                  const struct object_id *oid,
 256                                  void *cb_data_unused)
 257{
 258        int kind = oid_object_info(r, oid, NULL);
 259        return kind == OBJ_TREE;
 260}
 261
 262static int disambiguate_treeish_only(struct repository *r,
 263                                     const struct object_id *oid,
 264                                     void *cb_data_unused)
 265{
 266        struct object *obj;
 267        int kind;
 268
 269        kind = oid_object_info(r, oid, NULL);
 270        if (kind == OBJ_TREE || kind == OBJ_COMMIT)
 271                return 1;
 272        if (kind != OBJ_TAG)
 273                return 0;
 274
 275        /* We need to do this the hard way... */
 276        obj = deref_tag(r, parse_object(r, oid), NULL, 0);
 277        if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
 278                return 1;
 279        return 0;
 280}
 281
 282static int disambiguate_blob_only(struct repository *r,
 283                                  const struct object_id *oid,
 284                                  void *cb_data_unused)
 285{
 286        int kind = oid_object_info(r, oid, NULL);
 287        return kind == OBJ_BLOB;
 288}
 289
 290static disambiguate_hint_fn default_disambiguate_hint;
 291
 292int set_disambiguate_hint_config(const char *var, const char *value)
 293{
 294        static const struct {
 295                const char *name;
 296                disambiguate_hint_fn fn;
 297        } hints[] = {
 298                { "none", NULL },
 299                { "commit", disambiguate_commit_only },
 300                { "committish", disambiguate_committish_only },
 301                { "tree", disambiguate_tree_only },
 302                { "treeish", disambiguate_treeish_only },
 303                { "blob", disambiguate_blob_only }
 304        };
 305        int i;
 306
 307        if (!value)
 308                return config_error_nonbool(var);
 309
 310        for (i = 0; i < ARRAY_SIZE(hints); i++) {
 311                if (!strcasecmp(value, hints[i].name)) {
 312                        default_disambiguate_hint = hints[i].fn;
 313                        return 0;
 314                }
 315        }
 316
 317        return error("unknown hint type for '%s': %s", var, value);
 318}
 319
 320static int init_object_disambiguation(struct repository *r,
 321                                      const char *name, int len,
 322                                      struct disambiguate_state *ds)
 323{
 324        int i;
 325
 326        if (len < MINIMUM_ABBREV || len > the_hash_algo->hexsz)
 327                return -1;
 328
 329        memset(ds, 0, sizeof(*ds));
 330
 331        for (i = 0; i < len ;i++) {
 332                unsigned char c = name[i];
 333                unsigned char val;
 334                if (c >= '0' && c <= '9')
 335                        val = c - '0';
 336                else if (c >= 'a' && c <= 'f')
 337                        val = c - 'a' + 10;
 338                else if (c >= 'A' && c <='F') {
 339                        val = c - 'A' + 10;
 340                        c -= 'A' - 'a';
 341                }
 342                else
 343                        return -1;
 344                ds->hex_pfx[i] = c;
 345                if (!(i & 1))
 346                        val <<= 4;
 347                ds->bin_pfx.hash[i >> 1] |= val;
 348        }
 349
 350        ds->len = len;
 351        ds->hex_pfx[len] = '\0';
 352        ds->repo = r;
 353        prepare_alt_odb(r);
 354        return 0;
 355}
 356
 357static int show_ambiguous_object(const struct object_id *oid, void *data)
 358{
 359        const struct disambiguate_state *ds = data;
 360        struct strbuf desc = STRBUF_INIT;
 361        int type;
 362
 363        if (ds->fn && !ds->fn(ds->repo, oid, ds->cb_data))
 364                return 0;
 365
 366        type = oid_object_info(ds->repo, oid, NULL);
 367        if (type == OBJ_COMMIT) {
 368                struct commit *commit = lookup_commit(ds->repo, oid);
 369                if (commit) {
 370                        struct pretty_print_context pp = {0};
 371                        pp.date_mode.type = DATE_SHORT;
 372                        format_commit_message(commit, " %ad - %s", &desc, &pp);
 373                }
 374        } else if (type == OBJ_TAG) {
 375                struct tag *tag = lookup_tag(ds->repo, oid);
 376                if (!parse_tag(tag) && tag->tag)
 377                        strbuf_addf(&desc, " %s", tag->tag);
 378        }
 379
 380        advise("  %s %s%s",
 381               repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV),
 382               type_name(type) ? type_name(type) : "unknown type",
 383               desc.buf);
 384
 385        strbuf_release(&desc);
 386        return 0;
 387}
 388
 389static int collect_ambiguous(const struct object_id *oid, void *data)
 390{
 391        oid_array_append(data, oid);
 392        return 0;
 393}
 394
 395static int repo_collect_ambiguous(struct repository *r,
 396                                  const struct object_id *oid,
 397                                  void *data)
 398{
 399        return collect_ambiguous(oid, data);
 400}
 401
 402static struct repository *sort_ambiguous_repo;
 403static int sort_ambiguous(const void *a, const void *b)
 404{
 405        int a_type = oid_object_info(sort_ambiguous_repo, a, NULL);
 406        int b_type = oid_object_info(sort_ambiguous_repo, b, NULL);
 407        int a_type_sort;
 408        int b_type_sort;
 409
 410        /*
 411         * Sorts by hash within the same object type, just as
 412         * oid_array_for_each_unique() would do.
 413         */
 414        if (a_type == b_type)
 415                return oidcmp(a, b);
 416
 417        /*
 418         * Between object types show tags, then commits, and finally
 419         * trees and blobs.
 420         *
 421         * The object_type enum is commit, tree, blob, tag, but we
 422         * want tag, commit, tree blob. Cleverly (perhaps too
 423         * cleverly) do that with modulus, since the enum assigns 1 to
 424         * commit, so tag becomes 0.
 425         */
 426        a_type_sort = a_type % 4;
 427        b_type_sort = b_type % 4;
 428        return a_type_sort > b_type_sort ? 1 : -1;
 429}
 430
 431static void sort_ambiguous_oid_array(struct repository *r, struct oid_array *a)
 432{
 433        /* mutex will be needed if this code is to be made thread safe */
 434        sort_ambiguous_repo = r;
 435        QSORT(a->oid, a->nr, sort_ambiguous);
 436        sort_ambiguous_repo = NULL;
 437}
 438
 439static enum get_oid_result get_short_oid(struct repository *r,
 440                                         const char *name, int len,
 441                                         struct object_id *oid,
 442                                         unsigned flags)
 443{
 444        int status;
 445        struct disambiguate_state ds;
 446        int quietly = !!(flags & GET_OID_QUIETLY);
 447
 448        if (init_object_disambiguation(r, name, len, &ds) < 0)
 449                return -1;
 450
 451        if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS))
 452                BUG("multiple get_short_oid disambiguator flags");
 453
 454        if (flags & GET_OID_COMMIT)
 455                ds.fn = disambiguate_commit_only;
 456        else if (flags & GET_OID_COMMITTISH)
 457                ds.fn = disambiguate_committish_only;
 458        else if (flags & GET_OID_TREE)
 459                ds.fn = disambiguate_tree_only;
 460        else if (flags & GET_OID_TREEISH)
 461                ds.fn = disambiguate_treeish_only;
 462        else if (flags & GET_OID_BLOB)
 463                ds.fn = disambiguate_blob_only;
 464        else
 465                ds.fn = default_disambiguate_hint;
 466
 467        find_short_object_filename(&ds);
 468        find_short_packed_object(&ds);
 469        status = finish_object_disambiguation(&ds, oid);
 470
 471        if (!quietly && (status == SHORT_NAME_AMBIGUOUS)) {
 472                struct oid_array collect = OID_ARRAY_INIT;
 473
 474                error(_("short SHA1 %s is ambiguous"), ds.hex_pfx);
 475
 476                /*
 477                 * We may still have ambiguity if we simply saw a series of
 478                 * candidates that did not satisfy our hint function. In
 479                 * that case, we still want to show them, so disable the hint
 480                 * function entirely.
 481                 */
 482                if (!ds.ambiguous)
 483                        ds.fn = NULL;
 484
 485                advise(_("The candidates are:"));
 486                repo_for_each_abbrev(r, ds.hex_pfx, collect_ambiguous, &collect);
 487                sort_ambiguous_oid_array(r, &collect);
 488
 489                if (oid_array_for_each(&collect, show_ambiguous_object, &ds))
 490                        BUG("show_ambiguous_object shouldn't return non-zero");
 491                oid_array_clear(&collect);
 492        }
 493
 494        return status;
 495}
 496
 497int repo_for_each_abbrev(struct repository *r, const char *prefix,
 498                         each_abbrev_fn fn, void *cb_data)
 499{
 500        struct oid_array collect = OID_ARRAY_INIT;
 501        struct disambiguate_state ds;
 502        int ret;
 503
 504        if (init_object_disambiguation(r, prefix, strlen(prefix), &ds) < 0)
 505                return -1;
 506
 507        ds.always_call_fn = 1;
 508        ds.fn = repo_collect_ambiguous;
 509        ds.cb_data = &collect;
 510        find_short_object_filename(&ds);
 511        find_short_packed_object(&ds);
 512
 513        ret = oid_array_for_each_unique(&collect, fn, cb_data);
 514        oid_array_clear(&collect);
 515        return ret;
 516}
 517
 518/*
 519 * Return the slot of the most-significant bit set in "val". There are various
 520 * ways to do this quickly with fls() or __builtin_clzl(), but speed is
 521 * probably not a big deal here.
 522 */
 523static unsigned msb(unsigned long val)
 524{
 525        unsigned r = 0;
 526        while (val >>= 1)
 527                r++;
 528        return r;
 529}
 530
 531struct min_abbrev_data {
 532        unsigned int init_len;
 533        unsigned int cur_len;
 534        char *hex;
 535        struct repository *repo;
 536        const struct object_id *oid;
 537};
 538
 539static inline char get_hex_char_from_oid(const struct object_id *oid,
 540                                         unsigned int pos)
 541{
 542        static const char hex[] = "0123456789abcdef";
 543
 544        if ((pos & 1) == 0)
 545                return hex[oid->hash[pos >> 1] >> 4];
 546        else
 547                return hex[oid->hash[pos >> 1] & 0xf];
 548}
 549
 550static int extend_abbrev_len(const struct object_id *oid, void *cb_data)
 551{
 552        struct min_abbrev_data *mad = cb_data;
 553
 554        unsigned int i = mad->init_len;
 555        while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i))
 556                i++;
 557
 558        if (i < GIT_MAX_RAWSZ && i >= mad->cur_len)
 559                mad->cur_len = i + 1;
 560
 561        return 0;
 562}
 563
 564static int repo_extend_abbrev_len(struct repository *r,
 565                                  const struct object_id *oid,
 566                                  void *cb_data)
 567{
 568        return extend_abbrev_len(oid, cb_data);
 569}
 570
 571static void find_abbrev_len_for_midx(struct multi_pack_index *m,
 572                                     struct min_abbrev_data *mad)
 573{
 574        int match = 0;
 575        uint32_t num, first = 0;
 576        struct object_id oid;
 577        const struct object_id *mad_oid;
 578
 579        if (!m->num_objects)
 580                return;
 581
 582        num = m->num_objects;
 583        mad_oid = mad->oid;
 584        match = bsearch_midx(mad_oid, m, &first);
 585
 586        /*
 587         * first is now the position in the packfile where we would insert
 588         * mad->hash if it does not exist (or the position of mad->hash if
 589         * it does exist). Hence, we consider a maximum of two objects
 590         * nearby for the abbreviation length.
 591         */
 592        mad->init_len = 0;
 593        if (!match) {
 594                if (nth_midxed_object_oid(&oid, m, first))
 595                        extend_abbrev_len(&oid, mad);
 596        } else if (first < num - 1) {
 597                if (nth_midxed_object_oid(&oid, m, first + 1))
 598                        extend_abbrev_len(&oid, mad);
 599        }
 600        if (first > 0) {
 601                if (nth_midxed_object_oid(&oid, m, first - 1))
 602                        extend_abbrev_len(&oid, mad);
 603        }
 604        mad->init_len = mad->cur_len;
 605}
 606
 607static void find_abbrev_len_for_pack(struct packed_git *p,
 608                                     struct min_abbrev_data *mad)
 609{
 610        int match = 0;
 611        uint32_t num, first = 0;
 612        struct object_id oid;
 613        const struct object_id *mad_oid;
 614
 615        if (open_pack_index(p) || !p->num_objects)
 616                return;
 617
 618        num = p->num_objects;
 619        mad_oid = mad->oid;
 620        match = bsearch_pack(mad_oid, p, &first);
 621
 622        /*
 623         * first is now the position in the packfile where we would insert
 624         * mad->hash if it does not exist (or the position of mad->hash if
 625         * it does exist). Hence, we consider a maximum of two objects
 626         * nearby for the abbreviation length.
 627         */
 628        mad->init_len = 0;
 629        if (!match) {
 630                if (nth_packed_object_oid(&oid, p, first))
 631                        extend_abbrev_len(&oid, mad);
 632        } else if (first < num - 1) {
 633                if (nth_packed_object_oid(&oid, p, first + 1))
 634                        extend_abbrev_len(&oid, mad);
 635        }
 636        if (first > 0) {
 637                if (nth_packed_object_oid(&oid, p, first - 1))
 638                        extend_abbrev_len(&oid, mad);
 639        }
 640        mad->init_len = mad->cur_len;
 641}
 642
 643static void find_abbrev_len_packed(struct min_abbrev_data *mad)
 644{
 645        struct multi_pack_index *m;
 646        struct packed_git *p;
 647
 648        for (m = get_multi_pack_index(mad->repo); m; m = m->next)
 649                find_abbrev_len_for_midx(m, mad);
 650        for (p = get_packed_git(mad->repo); p; p = p->next)
 651                find_abbrev_len_for_pack(p, mad);
 652}
 653
 654int repo_find_unique_abbrev_r(struct repository *r, char *hex,
 655                              const struct object_id *oid, int len)
 656{
 657        struct disambiguate_state ds;
 658        struct min_abbrev_data mad;
 659        struct object_id oid_ret;
 660        const unsigned hexsz = r->hash_algo->hexsz;
 661
 662        if (len < 0) {
 663                unsigned long count = repo_approximate_object_count(r);
 664                /*
 665                 * Add one because the MSB only tells us the highest bit set,
 666                 * not including the value of all the _other_ bits (so "15"
 667                 * is only one off of 2^4, but the MSB is the 3rd bit.
 668                 */
 669                len = msb(count) + 1;
 670                /*
 671                 * We now know we have on the order of 2^len objects, which
 672                 * expects a collision at 2^(len/2). But we also care about hex
 673                 * chars, not bits, and there are 4 bits per hex. So all
 674                 * together we need to divide by 2 and round up.
 675                 */
 676                len = DIV_ROUND_UP(len, 2);
 677                /*
 678                 * For very small repos, we stick with our regular fallback.
 679                 */
 680                if (len < FALLBACK_DEFAULT_ABBREV)
 681                        len = FALLBACK_DEFAULT_ABBREV;
 682        }
 683
 684        oid_to_hex_r(hex, oid);
 685        if (len == hexsz || !len)
 686                return hexsz;
 687
 688        mad.repo = r;
 689        mad.init_len = len;
 690        mad.cur_len = len;
 691        mad.hex = hex;
 692        mad.oid = oid;
 693
 694        find_abbrev_len_packed(&mad);
 695
 696        if (init_object_disambiguation(r, hex, mad.cur_len, &ds) < 0)
 697                return -1;
 698
 699        ds.fn = repo_extend_abbrev_len;
 700        ds.always_call_fn = 1;
 701        ds.cb_data = (void *)&mad;
 702
 703        find_short_object_filename(&ds);
 704        (void)finish_object_disambiguation(&ds, &oid_ret);
 705
 706        hex[mad.cur_len] = 0;
 707        return mad.cur_len;
 708}
 709
 710const char *repo_find_unique_abbrev(struct repository *r,
 711                                    const struct object_id *oid,
 712                                    int len)
 713{
 714        static int bufno;
 715        static char hexbuffer[4][GIT_MAX_HEXSZ + 1];
 716        char *hex = hexbuffer[bufno];
 717        bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);
 718        repo_find_unique_abbrev_r(r, hex, oid, len);
 719        return hex;
 720}
 721
 722static int ambiguous_path(const char *path, int len)
 723{
 724        int slash = 1;
 725        int cnt;
 726
 727        for (cnt = 0; cnt < len; cnt++) {
 728                switch (*path++) {
 729                case '\0':
 730                        break;
 731                case '/':
 732                        if (slash)
 733                                break;
 734                        slash = 1;
 735                        continue;
 736                case '.':
 737                        continue;
 738                default:
 739                        slash = 0;
 740                        continue;
 741                }
 742                break;
 743        }
 744        return slash;
 745}
 746
 747static inline int at_mark(const char *string, int len,
 748                          const char **suffix, int nr)
 749{
 750        int i;
 751
 752        for (i = 0; i < nr; i++) {
 753                int suffix_len = strlen(suffix[i]);
 754                if (suffix_len <= len
 755                    && !strncasecmp(string, suffix[i], suffix_len))
 756                        return suffix_len;
 757        }
 758        return 0;
 759}
 760
 761static inline int upstream_mark(const char *string, int len)
 762{
 763        const char *suffix[] = { "@{upstream}", "@{u}" };
 764        return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
 765}
 766
 767static inline int push_mark(const char *string, int len)
 768{
 769        const char *suffix[] = { "@{push}" };
 770        return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
 771}
 772
 773static enum get_oid_result get_oid_1(struct repository *r, const char *name, int len, struct object_id *oid, unsigned lookup_flags);
 774static int interpret_nth_prior_checkout(struct repository *r, const char *name, int namelen, struct strbuf *buf);
 775
 776static int get_oid_basic(struct repository *r, const char *str, int len,
 777                         struct object_id *oid, unsigned int flags)
 778{
 779        static const char *warn_msg = "refname '%.*s' is ambiguous.";
 780        static const char *object_name_msg = N_(
 781        "Git normally never creates a ref that ends with 40 hex characters\n"
 782        "because it will be ignored when you just specify 40-hex. These refs\n"
 783        "may be created by mistake. For example,\n"
 784        "\n"
 785        "  git checkout -b $br $(git rev-parse ...)\n"
 786        "\n"
 787        "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n"
 788        "examine these refs and maybe delete them. Turn this message off by\n"
 789        "running \"git config advice.objectNameWarning false\"");
 790        struct object_id tmp_oid;
 791        char *real_ref = NULL;
 792        int refs_found = 0;
 793        int at, reflog_len, nth_prior = 0;
 794
 795        if (len == r->hash_algo->hexsz && !get_oid_hex(str, oid)) {
 796                if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) {
 797                        refs_found = repo_dwim_ref(r, str, len, &tmp_oid, &real_ref);
 798                        if (refs_found > 0) {
 799                                warning(warn_msg, len, str);
 800                                if (advice_object_name_warning)
 801                                        fprintf(stderr, "%s\n", _(object_name_msg));
 802                        }
 803                        free(real_ref);
 804                }
 805                return 0;
 806        }
 807
 808        /* basic@{time or number or -number} format to query ref-log */
 809        reflog_len = at = 0;
 810        if (len && str[len-1] == '}') {
 811                for (at = len-4; at >= 0; at--) {
 812                        if (str[at] == '@' && str[at+1] == '{') {
 813                                if (str[at+2] == '-') {
 814                                        if (at != 0)
 815                                                /* @{-N} not at start */
 816                                                return -1;
 817                                        nth_prior = 1;
 818                                        continue;
 819                                }
 820                                if (!upstream_mark(str + at, len - at) &&
 821                                    !push_mark(str + at, len - at)) {
 822                                        reflog_len = (len-1) - (at+2);
 823                                        len = at;
 824                                }
 825                                break;
 826                        }
 827                }
 828        }
 829
 830        /* Accept only unambiguous ref paths. */
 831        if (len && ambiguous_path(str, len))
 832                return -1;
 833
 834        if (nth_prior) {
 835                struct strbuf buf = STRBUF_INIT;
 836                int detached;
 837
 838                if (interpret_nth_prior_checkout(r, str, len, &buf) > 0) {
 839                        detached = (buf.len == r->hash_algo->hexsz && !get_oid_hex(buf.buf, oid));
 840                        strbuf_release(&buf);
 841                        if (detached)
 842                                return 0;
 843                }
 844        }
 845
 846        if (!len && reflog_len)
 847                /* allow "@{...}" to mean the current branch reflog */
 848                refs_found = repo_dwim_ref(r, "HEAD", 4, oid, &real_ref);
 849        else if (reflog_len)
 850                refs_found = repo_dwim_log(r, str, len, oid, &real_ref);
 851        else
 852                refs_found = repo_dwim_ref(r, str, len, oid, &real_ref);
 853
 854        if (!refs_found)
 855                return -1;
 856
 857        if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) &&
 858            (refs_found > 1 ||
 859             !get_short_oid(r, str, len, &tmp_oid, GET_OID_QUIETLY)))
 860                warning(warn_msg, len, str);
 861
 862        if (reflog_len) {
 863                int nth, i;
 864                timestamp_t at_time;
 865                timestamp_t co_time;
 866                int co_tz, co_cnt;
 867
 868                /* Is it asking for N-th entry, or approxidate? */
 869                for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
 870                        char ch = str[at+2+i];
 871                        if ('0' <= ch && ch <= '9')
 872                                nth = nth * 10 + ch - '0';
 873                        else
 874                                nth = -1;
 875                }
 876                if (100000000 <= nth) {
 877                        at_time = nth;
 878                        nth = -1;
 879                } else if (0 <= nth)
 880                        at_time = 0;
 881                else {
 882                        int errors = 0;
 883                        char *tmp = xstrndup(str + at + 2, reflog_len);
 884                        at_time = approxidate_careful(tmp, &errors);
 885                        free(tmp);
 886                        if (errors) {
 887                                free(real_ref);
 888                                return -1;
 889                        }
 890                }
 891                if (read_ref_at(get_main_ref_store(r),
 892                                real_ref, flags, at_time, nth, oid, NULL,
 893                                &co_time, &co_tz, &co_cnt)) {
 894                        if (!len) {
 895                                if (starts_with(real_ref, "refs/heads/")) {
 896                                        str = real_ref + 11;
 897                                        len = strlen(real_ref + 11);
 898                                } else {
 899                                        /* detached HEAD */
 900                                        str = "HEAD";
 901                                        len = 4;
 902                                }
 903                        }
 904                        if (at_time) {
 905                                if (!(flags & GET_OID_QUIETLY)) {
 906                                        warning("Log for '%.*s' only goes "
 907                                                "back to %s.", len, str,
 908                                                show_date(co_time, co_tz, DATE_MODE(RFC2822)));
 909                                }
 910                        } else {
 911                                if (flags & GET_OID_QUIETLY) {
 912                                        exit(128);
 913                                }
 914                                die("Log for '%.*s' only has %d entries.",
 915                                    len, str, co_cnt);
 916                        }
 917                }
 918        }
 919
 920        free(real_ref);
 921        return 0;
 922}
 923
 924static enum get_oid_result get_parent(struct repository *r,
 925                                      const char *name, int len,
 926                                      struct object_id *result, int idx)
 927{
 928        struct object_id oid;
 929        enum get_oid_result ret = get_oid_1(r, name, len, &oid,
 930                                            GET_OID_COMMITTISH);
 931        struct commit *commit;
 932        struct commit_list *p;
 933
 934        if (ret)
 935                return ret;
 936        commit = lookup_commit_reference(r, &oid);
 937        if (parse_commit(commit))
 938                return MISSING_OBJECT;
 939        if (!idx) {
 940                oidcpy(result, &commit->object.oid);
 941                return FOUND;
 942        }
 943        p = commit->parents;
 944        while (p) {
 945                if (!--idx) {
 946                        oidcpy(result, &p->item->object.oid);
 947                        return FOUND;
 948                }
 949                p = p->next;
 950        }
 951        return MISSING_OBJECT;
 952}
 953
 954static enum get_oid_result get_nth_ancestor(struct repository *r,
 955                                            const char *name, int len,
 956                                            struct object_id *result,
 957                                            int generation)
 958{
 959        struct object_id oid;
 960        struct commit *commit;
 961        int ret;
 962
 963        ret = get_oid_1(r, name, len, &oid, GET_OID_COMMITTISH);
 964        if (ret)
 965                return ret;
 966        commit = lookup_commit_reference(r, &oid);
 967        if (!commit)
 968                return MISSING_OBJECT;
 969
 970        while (generation--) {
 971                if (parse_commit(commit) || !commit->parents)
 972                        return MISSING_OBJECT;
 973                commit = commit->parents->item;
 974        }
 975        oidcpy(result, &commit->object.oid);
 976        return FOUND;
 977}
 978
 979struct object *repo_peel_to_type(struct repository *r, const char *name, int namelen,
 980                                 struct object *o, enum object_type expected_type)
 981{
 982        if (name && !namelen)
 983                namelen = strlen(name);
 984        while (1) {
 985                if (!o || (!o->parsed && !parse_object(r, &o->oid)))
 986                        return NULL;
 987                if (expected_type == OBJ_ANY || o->type == expected_type)
 988                        return o;
 989                if (o->type == OBJ_TAG)
 990                        o = ((struct tag*) o)->tagged;
 991                else if (o->type == OBJ_COMMIT)
 992                        o = &(repo_get_commit_tree(r, ((struct commit *)o))->object);
 993                else {
 994                        if (name)
 995                                error("%.*s: expected %s type, but the object "
 996                                      "dereferences to %s type",
 997                                      namelen, name, type_name(expected_type),
 998                                      type_name(o->type));
 999                        return NULL;
1000                }
1001        }
1002}
1003
1004static int peel_onion(struct repository *r, const char *name, int len,
1005                      struct object_id *oid, unsigned lookup_flags)
1006{
1007        struct object_id outer;
1008        const char *sp;
1009        unsigned int expected_type = 0;
1010        struct object *o;
1011
1012        /*
1013         * "ref^{type}" dereferences ref repeatedly until you cannot
1014         * dereference anymore, or you get an object of given type,
1015         * whichever comes first.  "ref^{}" means just dereference
1016         * tags until you get a non-tag.  "ref^0" is a shorthand for
1017         * "ref^{commit}".  "commit^{tree}" could be used to find the
1018         * top-level tree of the given commit.
1019         */
1020        if (len < 4 || name[len-1] != '}')
1021                return -1;
1022
1023        for (sp = name + len - 1; name <= sp; sp--) {
1024                int ch = *sp;
1025                if (ch == '{' && name < sp && sp[-1] == '^')
1026                        break;
1027        }
1028        if (sp <= name)
1029                return -1;
1030
1031        sp++; /* beginning of type name, or closing brace for empty */
1032        if (starts_with(sp, "commit}"))
1033                expected_type = OBJ_COMMIT;
1034        else if (starts_with(sp, "tag}"))
1035                expected_type = OBJ_TAG;
1036        else if (starts_with(sp, "tree}"))
1037                expected_type = OBJ_TREE;
1038        else if (starts_with(sp, "blob}"))
1039                expected_type = OBJ_BLOB;
1040        else if (starts_with(sp, "object}"))
1041                expected_type = OBJ_ANY;
1042        else if (sp[0] == '}')
1043                expected_type = OBJ_NONE;
1044        else if (sp[0] == '/')
1045                expected_type = OBJ_COMMIT;
1046        else
1047                return -1;
1048
1049        lookup_flags &= ~GET_OID_DISAMBIGUATORS;
1050        if (expected_type == OBJ_COMMIT)
1051                lookup_flags |= GET_OID_COMMITTISH;
1052        else if (expected_type == OBJ_TREE)
1053                lookup_flags |= GET_OID_TREEISH;
1054
1055        if (get_oid_1(r, name, sp - name - 2, &outer, lookup_flags))
1056                return -1;
1057
1058        o = parse_object(r, &outer);
1059        if (!o)
1060                return -1;
1061        if (!expected_type) {
1062                o = deref_tag(r, o, name, sp - name - 2);
1063                if (!o || (!o->parsed && !parse_object(r, &o->oid)))
1064                        return -1;
1065                oidcpy(oid, &o->oid);
1066                return 0;
1067        }
1068
1069        /*
1070         * At this point, the syntax look correct, so
1071         * if we do not get the needed object, we should
1072         * barf.
1073         */
1074        o = repo_peel_to_type(r, name, len, o, expected_type);
1075        if (!o)
1076                return -1;
1077
1078        oidcpy(oid, &o->oid);
1079        if (sp[0] == '/') {
1080                /* "$commit^{/foo}" */
1081                char *prefix;
1082                int ret;
1083                struct commit_list *list = NULL;
1084
1085                /*
1086                 * $commit^{/}. Some regex implementation may reject.
1087                 * We don't need regex anyway. '' pattern always matches.
1088                 */
1089                if (sp[1] == '}')
1090                        return 0;
1091
1092                prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1));
1093                commit_list_insert((struct commit *)o, &list);
1094                ret = get_oid_oneline(r, prefix, oid, list);
1095                free(prefix);
1096                return ret;
1097        }
1098        return 0;
1099}
1100
1101static int get_describe_name(struct repository *r,
1102                             const char *name, int len,
1103                             struct object_id *oid)
1104{
1105        const char *cp;
1106        unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT;
1107
1108        for (cp = name + len - 1; name + 2 <= cp; cp--) {
1109                char ch = *cp;
1110                if (!isxdigit(ch)) {
1111                        /* We must be looking at g in "SOMETHING-g"
1112                         * for it to be describe output.
1113                         */
1114                        if (ch == 'g' && cp[-1] == '-') {
1115                                cp++;
1116                                len -= cp - name;
1117                                return get_short_oid(r,
1118                                                     cp, len, oid, flags);
1119                        }
1120                }
1121        }
1122        return -1;
1123}
1124
1125static enum get_oid_result get_oid_1(struct repository *r,
1126                                     const char *name, int len,
1127                                     struct object_id *oid,
1128                                     unsigned lookup_flags)
1129{
1130        int ret, has_suffix;
1131        const char *cp;
1132
1133        /*
1134         * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
1135         */
1136        has_suffix = 0;
1137        for (cp = name + len - 1; name <= cp; cp--) {
1138                int ch = *cp;
1139                if ('0' <= ch && ch <= '9')
1140                        continue;
1141                if (ch == '~' || ch == '^')
1142                        has_suffix = ch;
1143                break;
1144        }
1145
1146        if (has_suffix) {
1147                int num = 0;
1148                int len1 = cp - name;
1149                cp++;
1150                while (cp < name + len)
1151                        num = num * 10 + *cp++ - '0';
1152                if (!num && len1 == len - 1)
1153                        num = 1;
1154                if (has_suffix == '^')
1155                        return get_parent(r, name, len1, oid, num);
1156                /* else if (has_suffix == '~') -- goes without saying */
1157                return get_nth_ancestor(r, name, len1, oid, num);
1158        }
1159
1160        ret = peel_onion(r, name, len, oid, lookup_flags);
1161        if (!ret)
1162                return FOUND;
1163
1164        ret = get_oid_basic(r, name, len, oid, lookup_flags);
1165        if (!ret)
1166                return FOUND;
1167
1168        /* It could be describe output that is "SOMETHING-gXXXX" */
1169        ret = get_describe_name(r, name, len, oid);
1170        if (!ret)
1171                return FOUND;
1172
1173        return get_short_oid(r, name, len, oid, lookup_flags);
1174}
1175
1176/*
1177 * This interprets names like ':/Initial revision of "git"' by searching
1178 * through history and returning the first commit whose message starts
1179 * the given regular expression.
1180 *
1181 * For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'.
1182 *
1183 * For a literal '!' character at the beginning of a pattern, you have to repeat
1184 * that, like: ':/!!foo'
1185 *
1186 * For future extension, all other sequences beginning with ':/!' are reserved.
1187 */
1188
1189/* Remember to update object flag allocation in object.h */
1190#define ONELINE_SEEN (1u<<20)
1191
1192struct handle_one_ref_cb {
1193        struct repository *repo;
1194        struct commit_list **list;
1195};
1196
1197static int handle_one_ref(const char *path, const struct object_id *oid,
1198                          int flag, void *cb_data)
1199{
1200        struct handle_one_ref_cb *cb = cb_data;
1201        struct commit_list **list = cb->list;
1202        struct object *object = parse_object(cb->repo, oid);
1203        if (!object)
1204                return 0;
1205        if (object->type == OBJ_TAG) {
1206                object = deref_tag(cb->repo, object, path,
1207                                   strlen(path));
1208                if (!object)
1209                        return 0;
1210        }
1211        if (object->type != OBJ_COMMIT)
1212                return 0;
1213        commit_list_insert((struct commit *)object, list);
1214        return 0;
1215}
1216
1217static int get_oid_oneline(struct repository *r,
1218                           const char *prefix, struct object_id *oid,
1219                           struct commit_list *list)
1220{
1221        struct commit_list *backup = NULL, *l;
1222        int found = 0;
1223        int negative = 0;
1224        regex_t regex;
1225
1226        if (prefix[0] == '!') {
1227                prefix++;
1228
1229                if (prefix[0] == '-') {
1230                        prefix++;
1231                        negative = 1;
1232                } else if (prefix[0] != '!') {
1233                        return -1;
1234                }
1235        }
1236
1237        if (regcomp(&regex, prefix, REG_EXTENDED))
1238                return -1;
1239
1240        for (l = list; l; l = l->next) {
1241                l->item->object.flags |= ONELINE_SEEN;
1242                commit_list_insert(l->item, &backup);
1243        }
1244        while (list) {
1245                const char *p, *buf;
1246                struct commit *commit;
1247                int matches;
1248
1249                commit = pop_most_recent_commit(&list, ONELINE_SEEN);
1250                if (!parse_object(r, &commit->object.oid))
1251                        continue;
1252                buf = get_commit_buffer(commit, NULL);
1253                p = strstr(buf, "\n\n");
1254                matches = negative ^ (p && !regexec(&regex, p + 2, 0, NULL, 0));
1255                unuse_commit_buffer(commit, buf);
1256
1257                if (matches) {
1258                        oidcpy(oid, &commit->object.oid);
1259                        found = 1;
1260                        break;
1261                }
1262        }
1263        regfree(&regex);
1264        free_commit_list(list);
1265        for (l = backup; l; l = l->next)
1266                clear_commit_marks(l->item, ONELINE_SEEN);
1267        free_commit_list(backup);
1268        return found ? 0 : -1;
1269}
1270
1271struct grab_nth_branch_switch_cbdata {
1272        int remaining;
1273        struct strbuf buf;
1274};
1275
1276static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid,
1277                                  const char *email, timestamp_t timestamp, int tz,
1278                                  const char *message, void *cb_data)
1279{
1280        struct grab_nth_branch_switch_cbdata *cb = cb_data;
1281        const char *match = NULL, *target = NULL;
1282        size_t len;
1283
1284        if (skip_prefix(message, "checkout: moving from ", &match))
1285                target = strstr(match, " to ");
1286
1287        if (!match || !target)
1288                return 0;
1289        if (--(cb->remaining) == 0) {
1290                len = target - match;
1291                strbuf_reset(&cb->buf);
1292                strbuf_add(&cb->buf, match, len);
1293                return 1; /* we are done */
1294        }
1295        return 0;
1296}
1297
1298/*
1299 * Parse @{-N} syntax, return the number of characters parsed
1300 * if successful; otherwise signal an error with negative value.
1301 */
1302static int interpret_nth_prior_checkout(struct repository *r,
1303                                        const char *name, int namelen,
1304                                        struct strbuf *buf)
1305{
1306        long nth;
1307        int retval;
1308        struct grab_nth_branch_switch_cbdata cb;
1309        const char *brace;
1310        char *num_end;
1311
1312        if (namelen < 4)
1313                return -1;
1314        if (name[0] != '@' || name[1] != '{' || name[2] != '-')
1315                return -1;
1316        brace = memchr(name, '}', namelen);
1317        if (!brace)
1318                return -1;
1319        nth = strtol(name + 3, &num_end, 10);
1320        if (num_end != brace)
1321                return -1;
1322        if (nth <= 0)
1323                return -1;
1324        cb.remaining = nth;
1325        strbuf_init(&cb.buf, 20);
1326
1327        retval = refs_for_each_reflog_ent_reverse(get_main_ref_store(r),
1328                        "HEAD", grab_nth_branch_switch, &cb);
1329        if (0 < retval) {
1330                strbuf_reset(buf);
1331                strbuf_addbuf(buf, &cb.buf);
1332                retval = brace - name + 1;
1333        } else
1334                retval = 0;
1335
1336        strbuf_release(&cb.buf);
1337        return retval;
1338}
1339
1340int get_oid_mb(const char *name, struct object_id *oid)
1341{
1342        struct commit *one, *two;
1343        struct commit_list *mbs;
1344        struct object_id oid_tmp;
1345        const char *dots;
1346        int st;
1347
1348        dots = strstr(name, "...");
1349        if (!dots)
1350                return get_oid(name, oid);
1351        if (dots == name)
1352                st = get_oid("HEAD", &oid_tmp);
1353        else {
1354                struct strbuf sb;
1355                strbuf_init(&sb, dots - name);
1356                strbuf_add(&sb, name, dots - name);
1357                st = get_oid_committish(sb.buf, &oid_tmp);
1358                strbuf_release(&sb);
1359        }
1360        if (st)
1361                return st;
1362        one = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
1363        if (!one)
1364                return -1;
1365
1366        if (get_oid_committish(dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
1367                return -1;
1368        two = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
1369        if (!two)
1370                return -1;
1371        mbs = get_merge_bases(one, two);
1372        if (!mbs || mbs->next)
1373                st = -1;
1374        else {
1375                st = 0;
1376                oidcpy(oid, &mbs->item->object.oid);
1377        }
1378        free_commit_list(mbs);
1379        return st;
1380}
1381
1382/* parse @something syntax, when 'something' is not {.*} */
1383static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf)
1384{
1385        const char *next;
1386
1387        if (len || name[1] == '{')
1388                return -1;
1389
1390        /* make sure it's a single @, or @@{.*}, not @foo */
1391        next = memchr(name + len + 1, '@', namelen - len - 1);
1392        if (next && next[1] != '{')
1393                return -1;
1394        if (!next)
1395                next = name + namelen;
1396        if (next != name + 1)
1397                return -1;
1398
1399        strbuf_reset(buf);
1400        strbuf_add(buf, "HEAD", 4);
1401        return 1;
1402}
1403
1404static int reinterpret(struct repository *r,
1405                       const char *name, int namelen, int len,
1406                       struct strbuf *buf, unsigned allowed)
1407{
1408        /* we have extra data, which might need further processing */
1409        struct strbuf tmp = STRBUF_INIT;
1410        int used = buf->len;
1411        int ret;
1412
1413        strbuf_add(buf, name + len, namelen - len);
1414        ret = repo_interpret_branch_name(r, buf->buf, buf->len, &tmp, allowed);
1415        /* that data was not interpreted, remove our cruft */
1416        if (ret < 0) {
1417                strbuf_setlen(buf, used);
1418                return len;
1419        }
1420        strbuf_reset(buf);
1421        strbuf_addbuf(buf, &tmp);
1422        strbuf_release(&tmp);
1423        /* tweak for size of {-N} versus expanded ref name */
1424        return ret - used + len;
1425}
1426
1427static void set_shortened_ref(struct repository *r, struct strbuf *buf, const char *ref)
1428{
1429        char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0);
1430        strbuf_reset(buf);
1431        strbuf_addstr(buf, s);
1432        free(s);
1433}
1434
1435static int branch_interpret_allowed(const char *refname, unsigned allowed)
1436{
1437        if (!allowed)
1438                return 1;
1439
1440        if ((allowed & INTERPRET_BRANCH_LOCAL) &&
1441            starts_with(refname, "refs/heads/"))
1442                return 1;
1443        if ((allowed & INTERPRET_BRANCH_REMOTE) &&
1444            starts_with(refname, "refs/remotes/"))
1445                return 1;
1446
1447        return 0;
1448}
1449
1450static int interpret_branch_mark(struct repository *r,
1451                                 const char *name, int namelen,
1452                                 int at, struct strbuf *buf,
1453                                 int (*get_mark)(const char *, int),
1454                                 const char *(*get_data)(struct branch *,
1455                                                         struct strbuf *),
1456                                 unsigned allowed)
1457{
1458        int len;
1459        struct branch *branch;
1460        struct strbuf err = STRBUF_INIT;
1461        const char *value;
1462
1463        len = get_mark(name + at, namelen - at);
1464        if (!len)
1465                return -1;
1466
1467        if (memchr(name, ':', at))
1468                return -1;
1469
1470        if (at) {
1471                char *name_str = xmemdupz(name, at);
1472                branch = branch_get(name_str);
1473                free(name_str);
1474        } else
1475                branch = branch_get(NULL);
1476
1477        value = get_data(branch, &err);
1478        if (!value)
1479                die("%s", err.buf);
1480
1481        if (!branch_interpret_allowed(value, allowed))
1482                return -1;
1483
1484        set_shortened_ref(r, buf, value);
1485        return len + at;
1486}
1487
1488int repo_interpret_branch_name(struct repository *r,
1489                               const char *name, int namelen,
1490                               struct strbuf *buf,
1491                               unsigned allowed)
1492{
1493        char *at;
1494        const char *start;
1495        int len;
1496
1497        if (!namelen)
1498                namelen = strlen(name);
1499
1500        if (!allowed || (allowed & INTERPRET_BRANCH_LOCAL)) {
1501                len = interpret_nth_prior_checkout(r, name, namelen, buf);
1502                if (!len) {
1503                        return len; /* syntax Ok, not enough switches */
1504                } else if (len > 0) {
1505                        if (len == namelen)
1506                                return len; /* consumed all */
1507                        else
1508                                return reinterpret(r, name, namelen, len, buf, allowed);
1509                }
1510        }
1511
1512        for (start = name;
1513             (at = memchr(start, '@', namelen - (start - name)));
1514             start = at + 1) {
1515
1516                if (!allowed || (allowed & INTERPRET_BRANCH_HEAD)) {
1517                        len = interpret_empty_at(name, namelen, at - name, buf);
1518                        if (len > 0)
1519                                return reinterpret(r, name, namelen, len, buf,
1520                                                   allowed);
1521                }
1522
1523                len = interpret_branch_mark(r, name, namelen, at - name, buf,
1524                                            upstream_mark, branch_get_upstream,
1525                                            allowed);
1526                if (len > 0)
1527                        return len;
1528
1529                len = interpret_branch_mark(r, name, namelen, at - name, buf,
1530                                            push_mark, branch_get_push,
1531                                            allowed);
1532                if (len > 0)
1533                        return len;
1534        }
1535
1536        return -1;
1537}
1538
1539void strbuf_branchname(struct strbuf *sb, const char *name, unsigned allowed)
1540{
1541        int len = strlen(name);
1542        int used = interpret_branch_name(name, len, sb, allowed);
1543
1544        if (used < 0)
1545                used = 0;
1546        strbuf_add(sb, name + used, len - used);
1547}
1548
1549int strbuf_check_branch_ref(struct strbuf *sb, const char *name)
1550{
1551        if (startup_info->have_repository)
1552                strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL);
1553        else
1554                strbuf_addstr(sb, name);
1555
1556        /*
1557         * This splice must be done even if we end up rejecting the
1558         * name; builtin/branch.c::copy_or_rename_branch() still wants
1559         * to see what the name expanded to so that "branch -m" can be
1560         * used as a tool to correct earlier mistakes.
1561         */
1562        strbuf_splice(sb, 0, 0, "refs/heads/", 11);
1563
1564        if (*name == '-' ||
1565            !strcmp(sb->buf, "refs/heads/HEAD"))
1566                return -1;
1567
1568        return check_refname_format(sb->buf, 0);
1569}
1570
1571/*
1572 * This is like "get_oid_basic()", except it allows "object ID expressions",
1573 * notably "xyz^" for "parent of xyz"
1574 */
1575int get_oid(const char *name, struct object_id *oid)
1576{
1577        struct object_context unused;
1578        return get_oid_with_context(the_repository, name, 0, oid, &unused);
1579}
1580
1581
1582/*
1583 * Many callers know that the user meant to name a commit-ish by
1584 * syntactical positions where the object name appears.  Calling this
1585 * function allows the machinery to disambiguate shorter-than-unique
1586 * abbreviated object names between commit-ish and others.
1587 *
1588 * Note that this does NOT error out when the named object is not a
1589 * commit-ish. It is merely to give a hint to the disambiguation
1590 * machinery.
1591 */
1592int get_oid_committish(const char *name, struct object_id *oid)
1593{
1594        struct object_context unused;
1595        return get_oid_with_context(the_repository,
1596                                    name, GET_OID_COMMITTISH,
1597                                    oid, &unused);
1598}
1599
1600int get_oid_treeish(const char *name, struct object_id *oid)
1601{
1602        struct object_context unused;
1603        return get_oid_with_context(the_repository,
1604                                    name, GET_OID_TREEISH,
1605                                    oid, &unused);
1606}
1607
1608int get_oid_commit(const char *name, struct object_id *oid)
1609{
1610        struct object_context unused;
1611        return get_oid_with_context(the_repository,
1612                                    name, GET_OID_COMMIT,
1613                                    oid, &unused);
1614}
1615
1616int get_oid_tree(const char *name, struct object_id *oid)
1617{
1618        struct object_context unused;
1619        return get_oid_with_context(the_repository,
1620                                    name, GET_OID_TREE,
1621                                    oid, &unused);
1622}
1623
1624int get_oid_blob(const char *name, struct object_id *oid)
1625{
1626        struct object_context unused;
1627        return get_oid_with_context(the_repository,
1628                                    name, GET_OID_BLOB,
1629                                    oid, &unused);
1630}
1631
1632/* Must be called only when object_name:filename doesn't exist. */
1633static void diagnose_invalid_oid_path(const char *prefix,
1634                                      const char *filename,
1635                                      const struct object_id *tree_oid,
1636                                      const char *object_name,
1637                                      int object_name_len)
1638{
1639        struct object_id oid;
1640        unsigned mode;
1641
1642        if (!prefix)
1643                prefix = "";
1644
1645        if (file_exists(filename))
1646                die("Path '%s' exists on disk, but not in '%.*s'.",
1647                    filename, object_name_len, object_name);
1648        if (is_missing_file_error(errno)) {
1649                char *fullname = xstrfmt("%s%s", prefix, filename);
1650
1651                if (!get_tree_entry(tree_oid, fullname, &oid, &mode)) {
1652                        die("Path '%s' exists, but not '%s'.\n"
1653                            "Did you mean '%.*s:%s' aka '%.*s:./%s'?",
1654                            fullname,
1655                            filename,
1656                            object_name_len, object_name,
1657                            fullname,
1658                            object_name_len, object_name,
1659                            filename);
1660                }
1661                die("Path '%s' does not exist in '%.*s'",
1662                    filename, object_name_len, object_name);
1663        }
1664}
1665
1666/* Must be called only when :stage:filename doesn't exist. */
1667static void diagnose_invalid_index_path(struct repository *r,
1668                                        int stage,
1669                                        const char *prefix,
1670                                        const char *filename)
1671{
1672        struct index_state *istate = r->index;
1673        const struct cache_entry *ce;
1674        int pos;
1675        unsigned namelen = strlen(filename);
1676        struct strbuf fullname = STRBUF_INIT;
1677
1678        if (!prefix)
1679                prefix = "";
1680
1681        /* Wrong stage number? */
1682        pos = index_name_pos(istate, filename, namelen);
1683        if (pos < 0)
1684                pos = -pos - 1;
1685        if (pos < istate->cache_nr) {
1686                ce = istate->cache[pos];
1687                if (ce_namelen(ce) == namelen &&
1688                    !memcmp(ce->name, filename, namelen))
1689                        die("Path '%s' is in the index, but not at stage %d.\n"
1690                            "Did you mean ':%d:%s'?",
1691                            filename, stage,
1692                            ce_stage(ce), filename);
1693        }
1694
1695        /* Confusion between relative and absolute filenames? */
1696        strbuf_addstr(&fullname, prefix);
1697        strbuf_addstr(&fullname, filename);
1698        pos = index_name_pos(istate, fullname.buf, fullname.len);
1699        if (pos < 0)
1700                pos = -pos - 1;
1701        if (pos < istate->cache_nr) {
1702                ce = istate->cache[pos];
1703                if (ce_namelen(ce) == fullname.len &&
1704                    !memcmp(ce->name, fullname.buf, fullname.len))
1705                        die("Path '%s' is in the index, but not '%s'.\n"
1706                            "Did you mean ':%d:%s' aka ':%d:./%s'?",
1707                            fullname.buf, filename,
1708                            ce_stage(ce), fullname.buf,
1709                            ce_stage(ce), filename);
1710        }
1711
1712        if (repo_file_exists(r, filename))
1713                die("Path '%s' exists on disk, but not in the index.", filename);
1714        if (is_missing_file_error(errno))
1715                die("Path '%s' does not exist (neither on disk nor in the index).",
1716                    filename);
1717
1718        strbuf_release(&fullname);
1719}
1720
1721
1722static char *resolve_relative_path(struct repository *r, const char *rel)
1723{
1724        if (!starts_with(rel, "./") && !starts_with(rel, "../"))
1725                return NULL;
1726
1727        if (r != the_repository || !is_inside_work_tree())
1728                die("relative path syntax can't be used outside working tree.");
1729
1730        /* die() inside prefix_path() if resolved path is outside worktree */
1731        return prefix_path(startup_info->prefix,
1732                           startup_info->prefix ? strlen(startup_info->prefix) : 0,
1733                           rel);
1734}
1735
1736static enum get_oid_result get_oid_with_context_1(struct repository *repo,
1737                                  const char *name,
1738                                  unsigned flags,
1739                                  const char *prefix,
1740                                  struct object_id *oid,
1741                                  struct object_context *oc)
1742{
1743        int ret, bracket_depth;
1744        int namelen = strlen(name);
1745        const char *cp;
1746        int only_to_die = flags & GET_OID_ONLY_TO_DIE;
1747
1748        if (only_to_die)
1749                flags |= GET_OID_QUIETLY;
1750
1751        memset(oc, 0, sizeof(*oc));
1752        oc->mode = S_IFINVALID;
1753        strbuf_init(&oc->symlink_path, 0);
1754        ret = get_oid_1(repo, name, namelen, oid, flags);
1755        if (!ret)
1756                return ret;
1757        /*
1758         * sha1:path --> object name of path in ent sha1
1759         * :path -> object name of absolute path in index
1760         * :./path -> object name of path relative to cwd in index
1761         * :[0-3]:path -> object name of path in index at stage
1762         * :/foo -> recent commit matching foo
1763         */
1764        if (name[0] == ':') {
1765                int stage = 0;
1766                const struct cache_entry *ce;
1767                char *new_path = NULL;
1768                int pos;
1769                if (!only_to_die && namelen > 2 && name[1] == '/') {
1770                        struct handle_one_ref_cb cb;
1771                        struct commit_list *list = NULL;
1772
1773                        cb.repo = repo;
1774                        cb.list = &list;
1775                        refs_for_each_ref(repo->refs, handle_one_ref, &cb);
1776                        refs_head_ref(repo->refs, handle_one_ref, &cb);
1777                        commit_list_sort_by_date(&list);
1778                        return get_oid_oneline(repo, name + 2, oid, list);
1779                }
1780                if (namelen < 3 ||
1781                    name[2] != ':' ||
1782                    name[1] < '0' || '3' < name[1])
1783                        cp = name + 1;
1784                else {
1785                        stage = name[1] - '0';
1786                        cp = name + 3;
1787                }
1788                new_path = resolve_relative_path(repo, cp);
1789                if (!new_path) {
1790                        namelen = namelen - (cp - name);
1791                } else {
1792                        cp = new_path;
1793                        namelen = strlen(cp);
1794                }
1795
1796                if (flags & GET_OID_RECORD_PATH)
1797                        oc->path = xstrdup(cp);
1798
1799                if (!repo->index->cache)
1800                        repo_read_index(the_repository);
1801                pos = index_name_pos(repo->index, cp, namelen);
1802                if (pos < 0)
1803                        pos = -pos - 1;
1804                while (pos < repo->index->cache_nr) {
1805                        ce = repo->index->cache[pos];
1806                        if (ce_namelen(ce) != namelen ||
1807                            memcmp(ce->name, cp, namelen))
1808                                break;
1809                        if (ce_stage(ce) == stage) {
1810                                oidcpy(oid, &ce->oid);
1811                                oc->mode = ce->ce_mode;
1812                                free(new_path);
1813                                return 0;
1814                        }
1815                        pos++;
1816                }
1817                if (only_to_die && name[1] && name[1] != '/')
1818                        diagnose_invalid_index_path(repo, stage, prefix, cp);
1819                free(new_path);
1820                return -1;
1821        }
1822        for (cp = name, bracket_depth = 0; *cp; cp++) {
1823                if (*cp == '{')
1824                        bracket_depth++;
1825                else if (bracket_depth && *cp == '}')
1826                        bracket_depth--;
1827                else if (!bracket_depth && *cp == ':')
1828                        break;
1829        }
1830        if (*cp == ':') {
1831                struct object_id tree_oid;
1832                int len = cp - name;
1833                unsigned sub_flags = flags;
1834
1835                sub_flags &= ~GET_OID_DISAMBIGUATORS;
1836                sub_flags |= GET_OID_TREEISH;
1837
1838                if (!get_oid_1(repo, name, len, &tree_oid, sub_flags)) {
1839                        const char *filename = cp+1;
1840                        char *new_filename = NULL;
1841
1842                        new_filename = resolve_relative_path(repo, filename);
1843                        if (new_filename)
1844                                filename = new_filename;
1845                        if (flags & GET_OID_FOLLOW_SYMLINKS) {
1846                                ret = get_tree_entry_follow_symlinks(&tree_oid,
1847                                        filename, oid, &oc->symlink_path,
1848                                        &oc->mode);
1849                        } else {
1850                                ret = get_tree_entry(&tree_oid, filename, oid,
1851                                                     &oc->mode);
1852                                if (ret && only_to_die) {
1853                                        diagnose_invalid_oid_path(prefix,
1854                                                                   filename,
1855                                                                   &tree_oid,
1856                                                                   name, len);
1857                                }
1858                        }
1859                        if (flags & GET_OID_RECORD_PATH)
1860                                oc->path = xstrdup(filename);
1861
1862                        free(new_filename);
1863                        return ret;
1864                } else {
1865                        if (only_to_die)
1866                                die("Invalid object name '%.*s'.", len, name);
1867                }
1868        }
1869        return ret;
1870}
1871
1872/*
1873 * Call this function when you know "name" given by the end user must
1874 * name an object but it doesn't; the function _may_ die with a better
1875 * diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not
1876 * exist in 'HEAD'" when given "HEAD:doc", or it may return in which case
1877 * you have a chance to diagnose the error further.
1878 */
1879void maybe_die_on_misspelt_object_name(const char *name, const char *prefix)
1880{
1881        struct object_context oc;
1882        struct object_id oid;
1883        get_oid_with_context_1(the_repository, name, GET_OID_ONLY_TO_DIE,
1884                               prefix, &oid, &oc);
1885}
1886
1887enum get_oid_result get_oid_with_context(struct repository *repo,
1888                                         const char *str,
1889                                         unsigned flags,
1890                                         struct object_id *oid,
1891                                         struct object_context *oc)
1892{
1893        if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE)
1894                BUG("incompatible flags for get_sha1_with_context");
1895        return get_oid_with_context_1(repo, str, flags, NULL, oid, oc);
1896}