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