src/revparse.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include <assert.h>
   9
  10 #include "common.h"
  11 #include "buffer.h"
  12 #include "tree.h"
  13 #include "refdb.h"
  14
  15 #include "git2.h"
  16
  17 static int maybe_sha_or_abbrev(git_object** out, git_repository *repo, const char *spec, size_t speclen)
  18 {
  19         git_oid oid;
  20
  21         if (git_oid_fromstrn(&oid, spec, speclen) < 0)
  22                 return GIT_ENOTFOUND;
  23
  24         return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJ_ANY);
  25 }
  26
  27 static int maybe_sha(git_object** out, git_repository *repo, const char *spec)
  28 {
  29         size_t speclen = strlen(spec);
  30
  31         if (speclen != GIT_OID_HEXSZ)
  32                 return GIT_ENOTFOUND;
  33
  34         return maybe_sha_or_abbrev(out, repo, spec, speclen);
  35 }
  36
  37 static int maybe_abbrev(git_object** out, git_repository *repo, const char *spec)
  38 {
  39         size_t speclen = strlen(spec);
  40
  41         return maybe_sha_or_abbrev(out, repo, spec, speclen);
  42 }
  43
  44 static int build_regex(regex_t *regex, const char *pattern)
  45 {
  46         int error;
  47
  48         if (*pattern == '\0') {
  49                 giterr_set(GITERR_REGEX, "Empty pattern");
  50                 return GIT_EINVALIDSPEC;
  51         }
  52
  53         error = regcomp(regex, pattern, REG_EXTENDED);
  54         if (!error)
  55                 return 0;
  56
  57         error = giterr_set_regex(regex, error);
  58
  59         regfree(regex);
  60
  61         return error;
  62 }
  63
  64 static int maybe_describe(git_object**out, git_repository *repo, const char *spec)
  65 {
  66         const char *substr;
  67         int error;
  68         regex_t regex;
  69
  70         substr = strstr(spec, "-g");
  71
  72         if (substr == NULL)
  73                 return GIT_ENOTFOUND;
  74
  75         if (build_regex(&regex, ".+-[0-9]+-g[0-9a-fA-F]+") < 0)
  76                 return -1;
  77
  78         error = regexec(&regex, spec, 0, NULL, 0);
  79         regfree(&regex);
  80
  81         if (error)
  82                 return GIT_ENOTFOUND;
  83
  84         return maybe_abbrev(out, repo, substr+2);
  85 }
  86
  87 static int revparse_lookup_object(git_object **out, git_repository *repo, const char *spec)
  88 {
  89         int error;
  90         git_reference *ref;
  91
  92         error = maybe_sha(out, repo, spec);
  93         if (!error)
  94                 return 0;
  95
  96         if (error < 0 && error != GIT_ENOTFOUND)
  97                 return error;
  98
  99         error = git_reference_dwim(&ref, repo, spec);
 100         if (!error) {
 101                 error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
 102                 git_reference_free(ref);
 103                 return error;
 104         }
 105
 106         if (error < 0 && error != GIT_ENOTFOUND)
 107                 return error;
 108
 109         error = maybe_abbrev(out, repo, spec);
 110         if (!error)
 111                 return 0;
 112
 113         if (error < 0 && error != GIT_ENOTFOUND)
 114                 return error;
 115
 116         error = maybe_describe(out, repo, spec);
 117         if (!error)
 118                 return 0;
 119
 120         if (error < 0 && error != GIT_ENOTFOUND)
 121                 return error;
 122
 123         giterr_set(GITERR_REFERENCE, "Refspec '%s' not found.", spec);
 124         return GIT_ENOTFOUND;
 125 }
 126
 127 static int try_parse_numeric(int *n, const char *curly_braces_content)
 128 {
 129         int32_t content;
 130         const char *end_ptr;
 131
 132         if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0)
 133                 return -1;
 134
 135         if (*end_ptr != '\0')
 136                 return -1;
 137
 138         *n = (int)content;
 139         return 0;
 140 }
 141
 142 static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
 143 {
 144         git_reference *ref = NULL;
 145         git_reflog *reflog = NULL;
 146         regex_t preg;
 147         int error = -1;
 148         size_t i, numentries, cur;
 149         const git_reflog_entry *entry;
 150         const char *msg;
 151         regmatch_t regexmatches[2];
 152         git_buf buf = GIT_BUF_INIT;
 153
 154         cur = position;
 155
 156         if (*identifier != '\0' || *base_ref != NULL)
 157                 return GIT_EINVALIDSPEC;
 158
 159         if (build_regex(&preg, "checkout: moving from (.*) to .*") < 0)
 160                 return -1;
 161
 162         if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
 163                 goto cleanup;
 164
 165         if (git_reflog_read(&reflog, ref) < 0)
 166                 goto cleanup;
 167
 168         numentries  = git_reflog_entrycount(reflog);
 169
 170         for (i = 0; i < numentries; i++) {
 171                 entry = git_reflog_entry_byindex(reflog, i);
 172                 msg = git_reflog_entry_message(entry);
 173
 174                 if (regexec(&preg, msg, 2, regexmatches, 0))
 175                         continue;
 176
 177                 cur--;
 178
 179                 if (cur > 0)
 180                         continue;
 181
 182                 git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
 183
 184                 if ((error = git_reference_dwim(base_ref, repo, git_buf_cstr(&buf))) == 0)
 185                         goto cleanup;
 186
 187                 if (error < 0 && error != GIT_ENOTFOUND)
 188                         goto cleanup;
 189
 190                 error = maybe_abbrev(out, repo, git_buf_cstr(&buf));
 191
 192                 goto cleanup;
 193         }
 194
 195         error = GIT_ENOTFOUND;
 196
 197 cleanup:
 198         git_reference_free(ref);
 199         git_buf_free(&buf);
 200         regfree(&preg);
 201         git_reflog_free(reflog);
 202         return error;
 203 }
 204
 205 static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier)
 206 {
 207         git_reflog *reflog;
 208         int error = -1;
 209         size_t numentries;
 210         const git_reflog_entry *entry;
 211         bool search_by_pos = (identifier <= 100000000);
 212
 213         if (git_reflog_read(&reflog, ref) < 0)
 214                 return -1;
 215
 216         numentries = git_reflog_entrycount(reflog);
 217
 218         if (search_by_pos) {
 219                 if (numentries < identifier + 1) {
 220                         giterr_set(
 221                                 GITERR_REFERENCE,
 222                                 "Reflog for '%s' has only "PRIuZ" entries, asked for "PRIuZ,
 223                                 git_reference_name(ref), numentries, identifier);
 224
 225                         error = GIT_ENOTFOUND;
 226                         goto cleanup;
 227                 }
 228
 229                 entry = git_reflog_entry_byindex(reflog, identifier);
 230                 git_oid_cpy(oid, git_reflog_entry_id_new(entry));
 231                 error = 0;
 232                 goto cleanup;
 233
 234         } else {
 235                 size_t i;
 236                 git_time commit_time;
 237
 238                 for (i = 0; i < numentries; i++) {
 239                         entry = git_reflog_entry_byindex(reflog, i);
 240                         commit_time = git_reflog_entry_committer(entry)->when;
 241
 242                         if (commit_time.time > (git_time_t)identifier)
 243                                 continue;
 244
 245                         git_oid_cpy(oid, git_reflog_entry_id_new(entry));
 246                         error = 0;
 247                         goto cleanup;
 248                 }
 249
 250                 error = GIT_ENOTFOUND;
 251         }
 252
 253 cleanup:
 254         git_reflog_free(reflog);
 255         return error;
 256 }
 257
 258 static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
 259 {
 260         git_reference *ref;
 261         git_oid oid;
 262         int error = -1;
 263
 264         if (*base_ref == NULL) {
 265                 if ((error = git_reference_dwim(&ref, repo, identifier)) < 0)
 266                         return error;
 267         } else {
 268                 ref = *base_ref;
 269                 *base_ref = NULL;
 270         }
 271
 272         if (position == 0) {
 273                 error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
 274                 goto cleanup;
 275         }
 276
 277         if ((error = retrieve_oid_from_reflog(&oid, ref, position)) < 0)
 278                 goto cleanup;
 279
 280         error = git_object_lookup(out, repo, &oid, GIT_OBJ_ANY);
 281
 282 cleanup:
 283         git_reference_free(ref);
 284         return error;
 285 }
 286
 287 static int retrieve_remote_tracking_reference(git_reference **base_ref, const char *identifier, git_repository *repo)
 288 {
 289         git_reference *tracking, *ref;
 290         int error = -1;
 291
 292         if (*base_ref == NULL) {
 293                 if ((error = git_reference_dwim(&ref, repo, identifier)) < 0)
 294                         return error;
 295         } else {
 296                 ref = *base_ref;
 297                 *base_ref = NULL;
 298         }
 299
 300         if (!git_reference_is_branch(ref)) {
 301                 error = GIT_EINVALIDSPEC;
 302                 goto cleanup;
 303         }
 304
 305         if ((error = git_branch_upstream(&tracking, ref)) < 0)
 306                 goto cleanup;
 307
 308         *base_ref = tracking;
 309
 310 cleanup:
 311         git_reference_free(ref);
 312         return error;
 313 }
 314
 315 static int handle_at_syntax(git_object **out, git_reference **ref, const char *spec, size_t identifier_len, git_repository* repo, const char *curly_braces_content)
 316 {
 317         bool is_numeric;
 318         int parsed = 0, error = -1;
 319         git_buf identifier = GIT_BUF_INIT;
 320         git_time_t timestamp;
 321
 322         assert(*out == NULL);
 323
 324         if (git_buf_put(&identifier, spec, identifier_len) < 0)
 325                 return -1;
 326
 327         is_numeric = !try_parse_numeric(&parsed, curly_braces_content);
 328
 329         if (*curly_braces_content == '-' && (!is_numeric || parsed == 0)) {
 330                 error = GIT_EINVALIDSPEC;
 331                 goto cleanup;
 332         }
 333
 334         if (is_numeric) {
 335                 if (parsed < 0)
 336                         error = retrieve_previously_checked_out_branch_or_revision(out, ref, repo, git_buf_cstr(&identifier), -parsed);
 337                 else
 338                         error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), parsed);
 339
 340                 goto cleanup;
 341         }
 342
 343         if (!strcmp(curly_braces_content, "u") || !strcmp(curly_braces_content, "upstream")) {
 344                 error = retrieve_remote_tracking_reference(ref, git_buf_cstr(&identifier), repo);
 345
 346                 goto cleanup;
 347         }
 348
 349         if (git__date_parse(&timestamp, curly_braces_content) < 0)
 350                 goto cleanup;
 351
 352         error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp);
 353
 354 cleanup:
 355         git_buf_free(&identifier);
 356         return error;
 357 }
 358
 359 static git_otype parse_obj_type(const char *str)
 360 {
 361         if (!strcmp(str, "commit"))
 362                 return GIT_OBJ_COMMIT;
 363
 364         if (!strcmp(str, "tree"))
 365                 return GIT_OBJ_TREE;
 366
 367         if (!strcmp(str, "blob"))
 368                 return GIT_OBJ_BLOB;
 369
 370         if (!strcmp(str, "tag"))
 371                 return GIT_OBJ_TAG;
 372
 373         return GIT_OBJ_BAD;
 374 }
 375
 376 static int dereference_to_non_tag(git_object **out, git_object *obj)
 377 {
 378         if (git_object_type(obj) == GIT_OBJ_TAG)
 379                 return git_tag_peel(out, (git_tag *)obj);
 380
 381         return git_object_dup(out, obj);
 382 }
 383
 384 static int handle_caret_parent_syntax(git_object **out, git_object *obj, int n)
 385 {
 386         git_object *temp_commit = NULL;
 387         int error;
 388
 389         if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
 390                 return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
 391                         GIT_EINVALIDSPEC : error;
 392
 393         if (n == 0) {
 394                 *out = temp_commit;
 395                 return 0;
 396         }
 397
 398         error = git_commit_parent((git_commit **)out, (git_commit*)temp_commit, n - 1);
 399
 400         git_object_free(temp_commit);
 401         return error;
 402 }
 403
 404 static int handle_linear_syntax(git_object **out, git_object *obj, int n)
 405 {
 406         git_object *temp_commit = NULL;
 407         int error;
 408
 409         if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
 410                 return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
 411                         GIT_EINVALIDSPEC : error;
 412
 413         error = git_commit_nth_gen_ancestor((git_commit **)out, (git_commit*)temp_commit, n);
 414
 415         git_object_free(temp_commit);
 416         return error;
 417 }
 418
 419 static int handle_colon_syntax(
 420         git_object **out,
 421         git_object *obj,
 422         const char *path)
 423 {
 424         git_object *tree;
 425         int error = -1;
 426         git_tree_entry *entry = NULL;
 427
 428         if ((error = git_object_peel(&tree, obj, GIT_OBJ_TREE)) < 0)
 429                 return error == GIT_ENOTFOUND ? GIT_EINVALIDSPEC : error;
 430
 431         if (*path == '\0') {
 432                 *out = tree;
 433                 return 0;
 434         }
 435
 436         /*
 437          * TODO: Handle the relative path syntax
 438          * (:./relative/path and :../relative/path)
 439          */
 440         if ((error = git_tree_entry_bypath(&entry, (git_tree *)tree, path)) < 0)
 441                 goto cleanup;
 442
 443         error = git_tree_entry_to_object(out, git_object_owner(tree), entry);
 444
 445 cleanup:
 446         git_tree_entry_free(entry);
 447         git_object_free(tree);
 448
 449         return error;
 450 }
 451
 452 static int walk_and_search(git_object **out, git_revwalk *walk, regex_t *regex)
 453 {
 454         int error;
 455         git_oid oid;
 456         git_object *obj;
 457
 458         while (!(error = git_revwalk_next(&oid, walk))) {
 459
 460                 error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJ_COMMIT);
 461                 if ((error < 0) && (error != GIT_ENOTFOUND))
 462                         return -1;
 463
 464                 if (!regexec(regex, git_commit_message((git_commit*)obj), 0, NULL, 0)) {
 465                         *out = obj;
 466                         return 0;
 467                 }
 468
 469                 git_object_free(obj);
 470         }
 471
 472         if (error < 0 && error == GIT_ITEROVER)
 473                 error = GIT_ENOTFOUND;
 474
 475         return error;
 476 }
 477
 478 static int handle_grep_syntax(git_object **out, git_repository *repo, const git_oid *spec_oid, const char *pattern)
 479 {
 480         regex_t preg;
 481         git_revwalk *walk = NULL;
 482         int error;
 483
 484         if ((error = build_regex(&preg, pattern)) < 0)
 485                 return error;
 486
 487         if ((error = git_revwalk_new(&walk, repo)) < 0)
 488                 goto cleanup;
 489
 490         git_revwalk_sorting(walk, GIT_SORT_TIME);
 491
 492         if (spec_oid == NULL) {
 493                 // TODO: @carlosmn: The glob should be refs/* but this makes git_revwalk_next() fails
 494                 if ((error = git_revwalk_push_glob(walk, GIT_REFS_HEADS_DIR "*")) < 0)
 495                         goto cleanup;
 496         } else if ((error = git_revwalk_push(walk, spec_oid)) < 0)
 497                         goto cleanup;
 498
 499         error = walk_and_search(out, walk, &preg);
 500
 501 cleanup:
 502         regfree(&preg);
 503         git_revwalk_free(walk);
 504
 505         return error;
 506 }
 507
 508 static int handle_caret_curly_syntax(git_object **out, git_object *obj, const char *curly_braces_content)
 509 {
 510         git_otype expected_type;
 511
 512         if (*curly_braces_content == '\0')
 513                 return dereference_to_non_tag(out, obj);
 514
 515         if (*curly_braces_content == '/')
 516                 return handle_grep_syntax(out, git_object_owner(obj), git_object_id(obj), curly_braces_content + 1);
 517
 518         expected_type = parse_obj_type(curly_braces_content);
 519
 520         if (expected_type == GIT_OBJ_BAD)
 521                 return GIT_EINVALIDSPEC;
 522
 523         return git_object_peel(out, obj, expected_type);
 524 }
 525
 526 static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *pos)
 527 {
 528         git_buf_clear(buf);
 529
 530         assert(spec[*pos] == '^' || spec[*pos] == '@');
 531
 532         (*pos)++;
 533
 534         if (spec[*pos] == '\0' || spec[*pos] != '{')
 535                 return GIT_EINVALIDSPEC;
 536
 537         (*pos)++;
 538
 539         while (spec[*pos] != '}') {
 540                 if (spec[*pos] == '\0')
 541                         return GIT_EINVALIDSPEC;
 542
 543                 git_buf_putc(buf, spec[(*pos)++]);
 544         }
 545
 546         (*pos)++;
 547
 548         return 0;
 549 }
 550
 551 static int extract_path(git_buf *buf, const char *spec, size_t *pos)
 552 {
 553         git_buf_clear(buf);
 554
 555         assert(spec[*pos] == ':');
 556
 557         (*pos)++;
 558
 559         if (git_buf_puts(buf, spec + *pos) < 0)
 560                 return -1;
 561
 562         *pos += git_buf_len(buf);
 563
 564         return 0;
 565 }
 566
 567 static int extract_how_many(int *n, const char *spec, size_t *pos)
 568 {
 569         const char *end_ptr;
 570         int parsed, accumulated;
 571         char kind = spec[*pos];
 572
 573         assert(spec[*pos] == '^' || spec[*pos] == '~');
 574
 575         accumulated = 0;
 576
 577         do {
 578                 do {
 579                         (*pos)++;
 580                         accumulated++;
 581                 } while (spec[(*pos)] == kind && kind == '~');
 582
 583                 if (git__isdigit(spec[*pos])) {
 584                         if (git__strtol32(&parsed, spec + *pos, &end_ptr, 10) < 0)
 585                                 return GIT_EINVALIDSPEC;
 586
 587                         accumulated += (parsed - 1);
 588                         *pos = end_ptr - spec;
 589                 }
 590
 591         }       while (spec[(*pos)] == kind && kind == '~');
 592
 593         *n = accumulated;
 594
 595         return 0;
 596 }
 597
 598 static int object_from_reference(git_object **object, git_reference *reference)
 599 {
 600         git_reference *resolved = NULL;
 601         int error;
 602
 603         if (git_reference_resolve(&resolved, reference) < 0)
 604                 return -1;
 605
 606         error = git_object_lookup(object, reference->db->repo, git_reference_target(resolved), GIT_OBJ_ANY);
 607         git_reference_free(resolved);
 608
 609         return error;
 610 }
 611
 612 static int ensure_base_rev_loaded(git_object **object, git_reference *reference, const char *spec, size_t identifier_len, git_repository *repo, bool allow_empty_identifier)
 613 {
 614         int error;
 615         git_buf identifier = GIT_BUF_INIT;
 616
 617         if (*object != NULL)
 618                 return 0;
 619
 620         if (reference != NULL)
 621                 return object_from_reference(object, reference);
 622
 623         if (!allow_empty_identifier && identifier_len == 0)
 624                 return GIT_EINVALIDSPEC;
 625
 626         if (git_buf_put(&identifier, spec, identifier_len) < 0)
 627                 return -1;
 628
 629         error = revparse_lookup_object(object, repo, git_buf_cstr(&identifier));
 630         git_buf_free(&identifier);
 631
 632         return error;
 633 }
 634
 635 static int ensure_base_rev_is_not_known_yet(git_object *object)
 636 {
 637         if (object == NULL)
 638                 return 0;
 639
 640         return GIT_EINVALIDSPEC;
 641 }
 642
 643 static bool any_left_hand_identifier(git_object *object, git_reference *reference, size_t identifier_len)
 644 {
 645         if (object != NULL)
 646                 return true;
 647
 648         if (reference != NULL)
 649                 return true;
 650
 651         if (identifier_len > 0)
 652                 return true;
 653
 654         return false;
 655 }
 656
 657 static int ensure_left_hand_identifier_is_not_known_yet(git_object *object, git_reference *reference)
 658 {
 659         if (!ensure_base_rev_is_not_known_yet(object) && reference == NULL)
 660                 return 0;
 661
 662         return GIT_EINVALIDSPEC;
 663 }
 664
 665 int revparse__ext(
 666         git_object **object_out,
 667         git_reference **reference_out,
 668         int *identifier_len_out,
 669         git_repository *repo,
 670         const char *spec)
 671 {
 672         size_t pos = 0, identifier_len = 0;
 673         int error = -1, n;
 674         git_buf buf = GIT_BUF_INIT;
 675
 676         git_reference *reference = NULL;
 677         git_object *base_rev = NULL;
 678
 679         assert(object_out && reference_out && repo && spec);
 680
 681         *object_out = NULL;
 682         *reference_out = NULL;
 683
 684         while (spec[pos]) {
 685                 switch (spec[pos]) {
 686                 case '^':
 687                         if ((error = ensure_base_rev_loaded(&base_rev, reference, spec, identifier_len, repo, false)) < 0)
 688                                 goto cleanup;
 689
 690                         if (spec[pos+1] == '{') {
 691                                 git_object *temp_object = NULL;
 692
 693                                 if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0)
 694                                         goto cleanup;
 695
 696                                 if ((error = handle_caret_curly_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0)
 697                                         goto cleanup;
 698
 699                                 git_object_free(base_rev);
 700                                 base_rev = temp_object;
 701                         } else {
 702                                 git_object *temp_object = NULL;
 703
 704                                 if ((error = extract_how_many(&n, spec, &pos)) < 0)
 705                                         goto cleanup;
 706
 707                                 if ((error = handle_caret_parent_syntax(&temp_object, base_rev, n)) < 0)
 708                                         goto cleanup;
 709
 710                                 git_object_free(base_rev);
 711                                 base_rev = temp_object;
 712                         }
 713                         break;
 714
 715                 case '~':
 716                 {
 717                         git_object *temp_object = NULL;
 718
 719                         if ((error = extract_how_many(&n, spec, &pos)) < 0)
 720                                 goto cleanup;
 721
 722                         if ((error = ensure_base_rev_loaded(&base_rev, reference, spec, identifier_len, repo, false)) < 0)
 723                                 goto cleanup;
 724
 725                         if ((error = handle_linear_syntax(&temp_object, base_rev, n)) < 0)
 726                                 goto cleanup;
 727
 728                         git_object_free(base_rev);
 729                         base_rev = temp_object;
 730                         break;
 731                 }
 732
 733                 case ':':
 734                 {
 735                         git_object *temp_object = NULL;
 736
 737                         if ((error = extract_path(&buf, spec, &pos)) < 0)
 738                                 goto cleanup;
 739
 740                         if (any_left_hand_identifier(base_rev, reference, identifier_len)) {
 741                                 if ((error = ensure_base_rev_loaded(&base_rev, reference, spec, identifier_len, repo, true)) < 0)
 742                                         goto cleanup;
 743
 744                                 if ((error = handle_colon_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0)
 745                                         goto cleanup;
 746                         } else {
 747                                 if (*git_buf_cstr(&buf) == '/') {
 748                                         if ((error = handle_grep_syntax(&temp_object, repo, NULL, git_buf_cstr(&buf) + 1)) < 0)
 749                                                 goto cleanup;
 750                                 } else {
 751
 752                                         /*
 753                                          * TODO: support merge-stage path lookup (":2:Makefile")
 754                                          * and plain index blob lookup (:i-am/a/blob)
 755                                          */
 756                                         giterr_set(GITERR_INVALID, "Unimplemented");
 757                                         error = GIT_ERROR;
 758                                         goto cleanup;
 759                                 }
 760                         }
 761
 762                         git_object_free(base_rev);
 763                         base_rev = temp_object;
 764                         break;
 765                 }
 766
 767                 case '@':
 768                 {
 769                         if (spec[pos+1] == '{') {
 770                                 git_object *temp_object = NULL;
 771
 772                                 if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0)
 773                                         goto cleanup;
 774
 775                                 if ((error = ensure_base_rev_is_not_known_yet(base_rev)) < 0)
 776                                         goto cleanup;
 777
 778                                 if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_buf_cstr(&buf))) < 0)
 779                                         goto cleanup;
 780
 781                                 if (temp_object != NULL)
 782                                         base_rev = temp_object;
 783                                 break;
 784                         } else {
 785                                 /* Fall through */
 786                         }
 787                 }
 788
 789                 default:
 790                         if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference)) < 0)
 791                                 goto cleanup;
 792
 793                         pos++;
 794                         identifier_len++;
 795                 }
 796         }
 797
 798         if ((error = ensure_base_rev_loaded(&base_rev, reference, spec, identifier_len, repo, false)) < 0)
 799                 goto cleanup;
 800
 801         *object_out = base_rev;
 802         *reference_out = reference;
 803         *identifier_len_out = identifier_len;
 804         error = 0;
 805
 806 cleanup:
 807         if (error) {
 808                 if (error == GIT_EINVALIDSPEC)
 809                         giterr_set(GITERR_INVALID,
 810                                 "Failed to parse revision specifier - Invalid pattern '%s'", spec);
 811
 812                 git_object_free(base_rev);
 813                 git_reference_free(reference);
 814         }
 815
 816         git_buf_free(&buf);
 817         return error;
 818 }
 819
 820 int git_revparse_ext(
 821         git_object **object_out,
 822         git_reference **reference_out,
 823         git_repository *repo,
 824         const char *spec)
 825 {
 826         int error, identifier_len;
 827         git_object *obj = NULL;
 828         git_reference *ref = NULL;
 829
 830         if ((error = revparse__ext(&obj, &ref, &identifier_len, repo, spec)) < 0)
 831                 goto cleanup;
 832
 833         *object_out = obj;
 834         *reference_out = ref;
 835
 836         return 0;
 837
 838 cleanup:
 839         git_object_free(obj);
 840         git_reference_free(ref);
 841         return error;
 842 }
 843
 844 int git_revparse_single(git_object **out, git_repository *repo, const char *spec)
 845 {
 846         int error;
 847         git_object *obj = NULL;
 848         git_reference *ref = NULL;
 849
 850         *out = NULL;
 851
 852         if ((error = git_revparse_ext(&obj, &ref, repo, spec)) < 0)
 853                 goto cleanup;
 854
 855         git_reference_free(ref);
 856
 857         *out = obj;
 858
 859         return 0;
 860
 861 cleanup:
 862         git_object_free(obj);
 863         git_reference_free(ref);
 864         return error;
 865 }
 866
 867 int git_revparse(
 868         git_revspec *revspec,
 869         git_repository *repo,
 870         const char *spec)
 871 {
 872         const char *dotdot;
 873         int error = 0;
 874
 875         assert(revspec && repo && spec);
 876
 877         memset(revspec, 0x0, sizeof(*revspec));
 878
 879         if ((dotdot = strstr(spec, "..")) != NULL) {
 880                 char *lstr;
 881                 const char *rstr;
 882                 revspec->flags = GIT_REVPARSE_RANGE;
 883
 884                 lstr = git__substrdup(spec, dotdot - spec);
 885                 rstr = dotdot + 2;
 886                 if (dotdot[2] == '.') {
 887                         revspec->flags |= GIT_REVPARSE_MERGE_BASE;
 888                         rstr++;
 889                 }
 890
 891                 if ((error = git_revparse_single(&revspec->from, repo, lstr)) < 0) {
 892                         return error;
 893                 }
 894
 895                 if ((error = git_revparse_single(&revspec->to, repo, rstr)) < 0) {
 896                         return error;
 897                 }
 898
 899                 git__free((void*)lstr);
 900         } else {
 901                 revspec->flags = GIT_REVPARSE_SINGLE;
 902                 error = git_revparse_single(&revspec->from, repo, spec);
 903         }
 904
 905         return error;
 906 }