git
/
object-name.c
2165 строк · 54.1 Кб
1#define USE_THE_REPOSITORY_VARIABLE2{54/* The hash algorithm of current has already been filtered */55if (ds->always_call_fn) {56ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0;57return;58}59if (!ds->candidate_exists) {60/* this is the first candidate */61oidcpy(&ds->candidate, current);62ds->candidate_exists = 1;63return;64} else if (oideq(&ds->candidate, current)) {65/* the same as what we already have seen */66return;67}68* if both current and candidate satisfy fn, we cannot92* disambiguate.93*/94ds->candidate_ok = 0;95ds->ambiguous = 1;96}97}100{105struct disambiguate_state *ds = arg;106/* no need to call match_hash, oidtree_each did prefix match */107update_candidates(ds, oid);108return ds->ambiguous ? CB_BREAK : CB_CONTINUE;109}110{113struct object_directory *odb;114}119{122do {123if (*a != *b)124return 0;125a++;126b++;127len -= 2;128} while (len > 1);129if (len)130if ((*a ^ *b) & 0xf0)131return 0;132return 1;133}134{138for (; m; m = m->base_midx) {139uint32_t num, i, first = 0;140const struct object_id *current = NULL;141int len = ds->len > ds->repo->hash_algo->hexsz ?142ds->repo->hash_algo->hexsz : ds->len;143* At this point, "first" is the location of the lowest153* object with an object name that could match154* "bin_pfx". See if we have 0, 1 or more objects that155* actually match(es).156*/157for (i = first; i < num && !ds->ambiguous; i++) {158struct object_id oid;159current = nth_midxed_object_oid(&oid, m, i);160if (!match_hash(len, ds->bin_pfx.hash, current->hash))161break;162update_candidates(ds, current);163}164}165}166{170uint32_t num, i, first = 0;171int len = ds->len > ds->repo->hash_algo->hexsz ?172ds->repo->hash_algo->hexsz : ds->len;173* At this point, "first" is the location of the lowest object185* with an object name that could match "bin_pfx". See if we have186* 0, 1 or more objects that actually match(es).187*/188for (i = first; i < num && !ds->ambiguous; i++) {189struct object_id oid;190nth_packed_object_id(&oid, p, i);191if (!match_hash(len, ds->bin_pfx.hash, oid.hash))192break;193update_candidates(ds, &oid);194}195}196{199struct multi_pack_index *m;200struct packed_git *p;201}213{217if (ds->ambiguous)218return SHORT_NAME_AMBIGUOUS;219* If this is the only candidate, there is no point226* calling the disambiguation hint callback.227*228* On the other hand, if the current candidate229* replaced an earlier candidate that did _not_ pass230* the disambiguation hint callback, then we do have231* more than one objects that match the short name232* given, so we should make sure this one matches;233* otherwise, if we discovered this one and the one234* that we previously discarded in the reverse order,235* we would end up showing different results in the236* same repository!237*/238ds->candidate_ok = (!ds->disambiguate_fn_used ||239ds->fn(ds->repo, &ds->candidate, ds->cb_data));240}247{252int kind = oid_object_info(r, oid, NULL);253return kind == OBJ_COMMIT;254}255{260struct object *obj;261int kind;262}275{280int kind = oid_object_info(r, oid, NULL);281return kind == OBJ_TREE;282}283{288struct object *obj;289int kind;290}303{308int kind = oid_object_info(r, oid, NULL);309return kind == OBJ_BLOB;310}311{316static const struct {317const char *name;318disambiguate_hint_fn fn;319} hints[] = {320{ "none", NULL },321{ "commit", disambiguate_commit_only },322{ "committish", disambiguate_committish_only },323{ "tree", disambiguate_tree_only },324{ "treeish", disambiguate_treeish_only },325{ "blob", disambiguate_blob_only }326};327int i;328}341{347int i;348}380{389struct ambiguous_output *state = data;390const struct disambiguate_state *ds = state->ds;391struct strbuf *advice = &state->advice;392struct strbuf *sb = &state->sb;393int type;394const char *hash;395* TRANSLATORS: This is a line of ambiguous object405* output shown when we cannot look up or parse the406* object in question. E.g. "deadbeef [bad object]".407*/408strbuf_addf(sb, _("%s [bad object]"), hash);409goto out;410}411* TRANSLATORS: This is a line of ambiguous commit431* object output. E.g.:432*433* "deadbeef commit 2021-01-01 - Some Commit Message"434*/435strbuf_addf(sb, _("%s commit %s - %s"), hash, date.buf,436msg.buf);437* TRANSLATORS: This is a line of ambiguous446* tag object output. E.g.:447*448* "deadbeef tag 2022-01-01 - Some Tag Message"449*450* The second argument is the YYYY-MM-DD found451* in the tag.452*453* The third argument is the "tag" string454* from object.c.455*/456strbuf_addf(sb, _("%s tag %s - %s"), hash,457show_date(tag->date, 0, DATE_MODE(SHORT)),458tag->tag);459} else {460/*461* TRANSLATORS: This is a line of ambiguous462* tag object output where we couldn't parse463* the tag itself. E.g.:464*465* "deadbeef [bad tag, could not parse it]"466*/467strbuf_addf(sb, _("%s [bad tag, could not parse it]"),468hash);469}470} else if (type == OBJ_TREE) {471/*472* TRANSLATORS: This is a line of ambiguous <type>473* object output. E.g. "deadbeef tree".474*/475strbuf_addf(sb, _("%s tree"), hash);476} else if (type == OBJ_BLOB) {477/*478* TRANSLATORS: This is a line of ambiguous <type>479* object output. E.g. "deadbeef blob".480*/481strbuf_addf(sb, _("%s blob"), hash);482}483* TRANSLATORS: This is line item of ambiguous object output488* from describe_ambiguous_object() above. For RTL languages489* you'll probably want to swap the "%s" and leading " " space490* around.491*/492strbuf_addf(advice, _(" %s\n"), sb->buf);493}497{500oid_array_append(data, oid);501return 0;502}503{508return collect_ambiguous(oid, data);509}510{513struct repository *sort_ambiguous_repo = ctx;514const struct object_id *a = va, *b = vb;515int a_type = oid_object_info(sort_ambiguous_repo, a, NULL);516int b_type = oid_object_info(sort_ambiguous_repo, b, NULL);517int a_type_sort;518int b_type_sort;519* Sorts by hash within the same object type, just as522* oid_array_for_each_unique() would do.523*/524if (a_type == b_type) {525if (a->algo == b->algo)526return oidcmp(a, b);527else528return a->algo > b->algo ? 1 : -1;529}530* Between object types show tags, then commits, and finally533* trees and blobs.534*535* The object_type enum is commit, tree, blob, tag, but we536* want tag, commit, tree blob. Cleverly (perhaps too537* cleverly) do that with modulus, since the enum assigns 1 to538* commit, so tag becomes 0.539*/540a_type_sort = a_type % 4;541b_type_sort = b_type % 4;542return a_type_sort > b_type_sort ? 1 : -1;543}544{547QSORT_S(a->oid, a->nr, sort_ambiguous, r);548}549{555int status;556struct disambiguate_state ds;557int quietly = !!(flags & GET_OID_QUIETLY);558const struct git_hash_algo *algo = r->hash_algo;559* If we didn't find it, do the usual reprepare() slow-path,588* since the object may have recently been added to the repository589* or migrated from loose to packed.590*/591if (status == MISSING_OBJECT) {592reprepare_packed_git(r);593find_short_object_filename(&ds);594find_short_packed_object(&ds);595status = finish_object_disambiguation(&ds, oid);596}597* We may still have ambiguity if we simply saw a series of610* candidates that did not satisfy our hint function. In611* that case, we still want to show them, so disable the hint612* function entirely.613*/614if (!ds.ambiguous)615ds.fn = NULL;616* TRANSLATORS: The argument is the list of ambiguous625* objects composed in show_ambiguous_object(). See626* its "TRANSLATORS" comments for details.627*/628advise(_("The candidates are:\n%s"), out.advice.buf);629}637{642struct oid_array collect = OID_ARRAY_INIT;643struct disambiguate_state ds;644int ret;645}659/*661* Return the slot of the most-significant bit set in "val". There are various662* ways to do this quickly with fls() or __builtin_clzl(), but speed is663* probably not a big deal here.664*/665static unsigned msb(unsigned long val)666{667unsigned r = 0;668while (val >>= 1)669r++;670return r;671}672{684static const char hex[] = "0123456789abcdef";685}691{694struct min_abbrev_data *mad = cb_data;695}705{710return extend_abbrev_len(oid, cb_data);711}712{716for (; m; m = m->base_midx) {717int match = 0;718uint32_t num, first = 0;719struct object_id oid;720const struct object_id *mad_oid;721* first is now the position in the packfile where we731* would insert mad->hash if it does not exist (or the732* position of mad->hash if it does exist). Hence, we733* consider a maximum of two objects nearby for the734* abbreviation length.735*/736mad->init_len = 0;737if (!match) {738if (nth_midxed_object_oid(&oid, m, first))739extend_abbrev_len(&oid, mad);740} else if (first < num - 1) {741if (nth_midxed_object_oid(&oid, m, first + 1))742extend_abbrev_len(&oid, mad);743}744if (first > 0) {745if (nth_midxed_object_oid(&oid, m, first - 1))746extend_abbrev_len(&oid, mad);747}748mad->init_len = mad->cur_len;749}750}751{755int match = 0;756uint32_t num, first = 0;757struct object_id oid;758const struct object_id *mad_oid;759* first is now the position in the packfile where we would insert772* mad->hash if it does not exist (or the position of mad->hash if773* it does exist). Hence, we consider a maximum of two objects774* nearby for the abbreviation length.775*/776mad->init_len = 0;777if (!match) {778if (!nth_packed_object_id(&oid, p, first))779extend_abbrev_len(&oid, mad);780} else if (first < num - 1) {781if (!nth_packed_object_id(&oid, p, first + 1))782extend_abbrev_len(&oid, mad);783}784if (first > 0) {785if (!nth_packed_object_id(&oid, p, first - 1))786extend_abbrev_len(&oid, mad);787}788mad->init_len = mad->cur_len;789}790{793struct multi_pack_index *m;794struct packed_git *p;795}801{805int r;806strbuf_grow(sb, GIT_MAX_HEXSZ + 1);807r = repo_find_unique_abbrev_r(repo, sb->buf + sb->len, oid, abbrev_len);808strbuf_setlen(sb, sb->len + r);809}810{814strbuf_repo_add_unique_abbrev(sb, the_repository, oid, abbrev_len);815}816{820const struct git_hash_algo *algo =821oid->algo ? &hash_algos[oid->algo] : r->hash_algo;822struct disambiguate_state ds;823struct min_abbrev_data mad;824struct object_id oid_ret;825const unsigned hexsz = algo->hexsz;826* Add one because the MSB only tells us the highest bit set,831* not including the value of all the _other_ bits (so "15"832* is only one off of 2^4, but the MSB is the 3rd bit.833*/834len = msb(count) + 1;835/*836* We now know we have on the order of 2^len objects, which837* expects a collision at 2^(len/2). But we also care about hex838* chars, not bits, and there are 4 bits per hex. So all839* together we need to divide by 2 and round up.840*/841len = DIV_ROUND_UP(len, 2);842/*843* For very small repos, we stick with our regular fallback.844*/845if (len < FALLBACK_DEFAULT_ABBREV)846len = FALLBACK_DEFAULT_ABBREV;847}848}874{879static int bufno;880static char hexbuffer[4][GIT_MAX_HEXSZ + 1];881char *hex = hexbuffer[bufno];882bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);883repo_find_unique_abbrev_r(r, hex, oid, len);884return hex;885}886{889int slash = 1;890int cnt;891}911{915int i;916}925{928const char *suffix[] = { "@{upstream}", "@{u}" };929return at_mark(string, len, suffix, ARRAY_SIZE(suffix));930}931{934const char *suffix[] = { "@{push}" };935return at_mark(string, len, suffix, ARRAY_SIZE(suffix));936}937{944static const char *warn_msg = "refname '%.*s' is ambiguous.";945static const char *object_name_msg = N_(946"Git normally never creates a ref that ends with 40 hex characters\n"947"because it will be ignored when you just specify 40-hex. These refs\n"948"may be created by mistake. For example,\n"949"\n"950" git switch -c $br $(git rev-parse ...)\n"951"\n"952"where \"$br\" is somehow empty and a 40-hex ref is created. Please\n"953"examine these refs and maybe delete them. Turn this message off by\n"954"running \"git config advice.objectNameWarning false\"");955struct object_id tmp_oid;956char *real_ref = NULL;957int refs_found = 0;958int at, reflog_len, nth_prior = 0;959int fatal = !(flags & GET_OID_QUIETLY);960* We were asked for the Nth reflog (counting1074* from 0), but there were only N entries.1075* read_ref_at() will have returned "1" to tell1076* us it did not find an entry, but it did1077* still fill in the oid with the "old" value,1078* which we can use.1079*/1080} else {1081if (flags & GET_OID_QUIETLY) {1082exit(128);1083}1084die(_("log for '%.*s' only has %d entries"),1085len, str, co_cnt);1086}1087}1088}1089}1093{1098struct object_id oid;1099enum get_oid_result ret = get_oid_1(r, name, len, &oid,1100GET_OID_COMMITTISH);1101struct commit *commit;1102struct commit_list *p;1103}1123{1129struct object_id oid;1130struct commit *commit;1131int ret;1132}1148{1152if (name && !namelen)1153namelen = strlen(name);1154while (1) {1155if (!o || (!o->parsed && !parse_object(r, &o->oid)))1156return NULL;1157if (expected_type == OBJ_ANY || o->type == expected_type)1158return o;1159if (o->type == OBJ_TAG)1160o = ((struct tag*) o)->tagged;1161else if (o->type == OBJ_COMMIT)1162o = &(repo_get_commit_tree(r, ((struct commit *)o))->object);1163else {1164if (name)1165error("%.*s: expected %s type, but the object "1166"dereferences to %s type",1167namelen, name, type_name(expected_type),1168type_name(o->type));1169return NULL;1170}1171}1172}1173{1177struct object_id outer;1178const char *sp;1179unsigned int expected_type = 0;1180struct object *o;1181* "ref^{type}" dereferences ref repeatedly until you cannot1184* dereference anymore, or you get an object of given type,1185* whichever comes first. "ref^{}" means just dereference1186* tags until you get a non-tag. "ref^0" is a shorthand for1187* "ref^{commit}". "commit^{tree}" could be used to find the1188* top-level tree of the given commit.1189*/1190if (len < 4 || name[len-1] != '}')1191return -1;1192* At this point, the syntax look correct, so1241* if we do not get the needed object, we should1242* barf.1243*/1244o = repo_peel_to_type(r, name, len, o, expected_type);1245if (!o)1246return -1;1247* $commit^{/}. Some regex implementation may reject.1257* We don't need regex anyway. '' pattern always matches.1258*/1259if (sp[1] == '}')1260return 0;1261}1272{1277const char *cp;1278unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT;1279* for it to be describe output.1285*/1286if (ch == 'g' && cp[-1] == '-') {1287cp++;1288len -= cp - name;1289return get_short_oid(r,1290cp, len, oid, flags);1291}1292}1293}1294return -1;1295}1296{1302int ret, has_suffix;1303const char *cp;1304* "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".1307*/1308has_suffix = 0;1309for (cp = name + len - 1; name <= cp; cp--) {1310int ch = *cp;1311if ('0' <= ch && ch <= '9')1312continue;1313if (ch == '~' || ch == '^')1314has_suffix = ch;1315break;1316}1317}1356/*1358* This interprets names like ':/Initial revision of "git"' by searching1359* through history and returning the first commit whose message starts1360* the given regular expression.1361*1362* For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'.1363*1364* For a literal '!' character at the beginning of a pattern, you have to repeat1365* that, like: ':/!!foo'1366*1367* For future extension, all other sequences beginning with ':/!' are reserved.1368*/1369/* Remember to update object flag allocation in object.h */1371#define ONELINE_SEEN (1u<<20)1372{1382struct handle_one_ref_cb *cb = cb_data;1383struct commit_list **list = cb->list;1384struct object *object = parse_object(cb->repo, oid);1385if (!object)1386return 0;1387if (object->type == OBJ_TAG) {1388object = deref_tag(cb->repo, object, path,1389strlen(path));1390if (!object)1391return 0;1392}1393if (object->type != OBJ_COMMIT)1394return 0;1395commit_list_insert((struct commit *)object, list);1396return 0;1397}1398{1403struct commit_list *copy = NULL;1404const struct commit_list *l;1405int found = 0;1406int negative = 0;1407regex_t regex;1408}1452{1465struct grab_nth_branch_switch_cbdata *cb = cb_data;1466const char *match = NULL, *target = NULL;1467size_t len;1468}1482/*1484* Parse @{-N} syntax, return the number of characters parsed1485* if successful; otherwise signal an error with negative value.1486*/1487static int interpret_nth_prior_checkout(struct repository *r,1488const char *name, int namelen,1489struct strbuf *buf)1490{1491long nth;1492int retval;1493struct grab_nth_branch_switch_cbdata cb;1494const char *brace;1495char *num_end;1496}1521{1526struct commit *one, *two;1527struct commit_list *mbs = NULL;1528struct object_id oid_tmp;1529const char *dots;1530int st;1531}1568/* parse @something syntax, when 'something' is not {.*} */1570static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf)1571{1572const char *next;1573}1590{1595/* we have extra data, which might need further processing */1596struct strbuf tmp = STRBUF_INIT;1597int used = buf->len;1598int ret;1599struct interpret_branch_name_options options = {1600.allowed = allowed1601};1602}1616{1619char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0);1620strbuf_reset(buf);1621strbuf_addstr(buf, s);1622free(s);1623}1624{1627if (!allowed)1628return 1;1629}1639{1648int len;1649struct branch *branch;1650struct strbuf err = STRBUF_INIT;1651const char *value;1652}1683{1689char *at;1690const char *start;1691int len;1692}1735{1738int len = strlen(name);1739struct interpret_branch_name_options options = {1740.allowed = allowed1741};1742int used = repo_interpret_branch_name(the_repository, name, len, sb,1743&options);1744}1749{1752if (startup_info->have_repository)1753strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL);1754else1755strbuf_addstr(sb, name);1756* This splice must be done even if we end up rejecting the1759* name; builtin/branch.c::copy_or_rename_branch() still wants1760* to see what the name expanded to so that "branch -m" can be1761* used as a tool to correct earlier mistakes.1762*/1763strbuf_splice(sb, 0, 0, "refs/heads/", 11);1764}1771{1774free(ctx->path);1775strbuf_release(&ctx->symlink_path);1776}1777/*1779* This is like "get_oid_basic()", except it allows "object ID expressions",1780* notably "xyz^" for "parent of xyz"1781*/1782int repo_get_oid(struct repository *r, const char *name, struct object_id *oid)1783{1784struct object_context unused;1785int ret = get_oid_with_context(r, name, 0, oid, &unused);1786object_context_release(&unused);1787return ret;1788}1789/*1791* This returns a non-zero value if the string (built using printf1792* format and the given arguments) is not a valid object.1793*/1794int get_oidf(struct object_id *oid, const char *fmt, ...)1795{1796va_list ap;1797int ret;1798struct strbuf sb = STRBUF_INIT;1799}1809/*1811* Many callers know that the user meant to name a commit-ish by1812* syntactical positions where the object name appears. Calling this1813* function allows the machinery to disambiguate shorter-than-unique1814* abbreviated object names between commit-ish and others.1815*1816* Note that this does NOT error out when the named object is not a1817* commit-ish. It is merely to give a hint to the disambiguation1818* machinery.1819*/1820int repo_get_oid_committish(struct repository *r,1821const char *name,1822struct object_id *oid)1823{1824struct object_context unused;1825int ret = get_oid_with_context(r, name, GET_OID_COMMITTISH,1826oid, &unused);1827object_context_release(&unused);1828return ret;1829}1830{1835struct object_context unused;1836int ret = get_oid_with_context(r, name, GET_OID_TREEISH,1837oid, &unused);1838object_context_release(&unused);1839return ret;1840}1841{1846struct object_context unused;1847int ret = get_oid_with_context(r, name, GET_OID_COMMIT,1848oid, &unused);1849object_context_release(&unused);1850return ret;1851}1852{1857struct object_context unused;1858int ret = get_oid_with_context(r, name, GET_OID_TREE,1859oid, &unused);1860object_context_release(&unused);1861return ret;1862}1863{1868struct object_context unused;1869int ret = get_oid_with_context(r, name, GET_OID_BLOB,1870oid, &unused);1871object_context_release(&unused);1872return ret;1873}1874/* Must be called only when object_name:filename doesn't exist. */1876static void diagnose_invalid_oid_path(struct repository *r,1877const char *prefix,1878const char *filename,1879const struct object_id *tree_oid,1880const char *object_name,1881int object_name_len)1882{1883struct object_id oid;1884unsigned short mode;1885}1909/* Must be called only when :stage:filename doesn't exist. */1911static void diagnose_invalid_index_path(struct repository *r,1912int stage,1913const char *prefix,1914const char *filename)1915{1916struct index_state *istate = r->index;1917const struct cache_entry *ce;1918int pos;1919unsigned namelen = strlen(filename);1920struct strbuf fullname = STRBUF_INIT;1921}1966{1970if (!starts_with(rel, "./") && !starts_with(rel, "../"))1971return NULL;1972}1981{1989if (!S_ISSPARSEDIR(ce->ce_mode))1990return 0;1991if (only_to_die)1992diagnose_invalid_index_path(repo, stage, prefix, cp);1993return -1;1994}1995{2003int ret, bracket_depth;2004int namelen = strlen(name);2005const char *cp;2006int only_to_die = flags & GET_OID_ONLY_TO_DIE;2007* tree:path --> object name of path in tree2019* :path -> object name of absolute path in index2020* :./path -> object name of path relative to cwd in index2021* :[0-3]:path -> object name of path in index at stage2022* :/foo -> recent commit matching foo2023*/2024if (name[0] == ':') {2025int stage = 0;2026const struct cache_entry *ce;2027char *new_path = NULL;2028int pos;2029if (!only_to_die && namelen > 2 && name[1] == '/') {2030struct handle_one_ref_cb cb;2031struct commit_list *list = NULL;2032}2137/*2139* Call this function when you know "name" given by the end user must2140* name an object but it doesn't; the function _may_ die with a better2141* diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not2142* exist in 'HEAD'" when given "HEAD:doc", or it may return in which case2143* you have a chance to diagnose the error further.2144*/2145void maybe_die_on_misspelt_object_name(struct repository *r,2146const char *name,2147const char *prefix)2148{2149struct object_context oc;2150struct object_id oid;2151get_oid_with_context_1(r, name, GET_OID_ONLY_TO_DIE | GET_OID_QUIETLY,2152prefix, &oid, &oc);2153object_context_release(&oc);2154}2155{2162if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE)2163BUG("incompatible flags for get_oid_with_context");2164return get_oid_with_context_1(repo, str, flags, NULL, oid, oc);2165}2166