* a Linking Exception. For full terms see the included COPYING file.
*/
-#include <assert.h>
-
#include "common.h"
+
#include "buffer.h"
#include "tree.h"
#include "refdb.h"
+#include "regexp.h"
#include "git2.h"
-static int maybe_sha_or_abbrev(git_object** out, git_repository *repo, const char *spec, size_t speclen)
+static int maybe_sha_or_abbrev(git_object **out, git_repository *repo, const char *spec, size_t speclen)
{
git_oid oid;
if (git_oid_fromstrn(&oid, spec, speclen) < 0)
return GIT_ENOTFOUND;
- return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJ_ANY);
+ return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJECT_ANY);
}
-static int maybe_sha(git_object** out, git_repository *repo, const char *spec)
+static int maybe_sha(git_object **out, git_repository *repo, const char *spec)
{
size_t speclen = strlen(spec);
return maybe_sha_or_abbrev(out, repo, spec, speclen);
}
-static int maybe_abbrev(git_object** out, git_repository *repo, const char *spec)
+static int maybe_abbrev(git_object **out, git_repository *repo, const char *spec)
{
size_t speclen = strlen(spec);
return maybe_sha_or_abbrev(out, repo, spec, speclen);
}
-static int build_regex(regex_t *regex, const char *pattern)
+static int build_regex(git_regexp *regex, const char *pattern)
{
int error;
if (*pattern == '\0') {
- giterr_set(GITERR_REGEX, "Empty pattern");
+ git_error_set(GIT_ERROR_REGEX, "empty pattern");
return GIT_EINVALIDSPEC;
}
- error = regcomp(regex, pattern, REG_EXTENDED);
+ error = git_regexp_compile(regex, pattern, 0);
if (!error)
return 0;
- error = giterr_set_regex(regex, error);
-
- regfree(regex);
+ git_regexp_dispose(regex);
return error;
}
{
const char *substr;
int error;
- regex_t regex;
+ git_regexp regex;
substr = strstr(spec, "-g");
if (build_regex(®ex, ".+-[0-9]+-g[0-9a-fA-F]+") < 0)
return -1;
- error = regexec(®ex, spec, 0, NULL, 0);
- regfree(®ex);
+ error = git_regexp_match(®ex, spec);
+ git_regexp_dispose(®ex);
if (error)
return GIT_ENOTFOUND;
int error;
git_reference *ref;
- error = maybe_sha(object_out, repo, spec);
- if (!error)
- return 0;
-
- if (error < 0 && error != GIT_ENOTFOUND)
+ if ((error = maybe_sha(object_out, repo, spec)) != GIT_ENOTFOUND)
return error;
error = git_reference_dwim(&ref, repo, spec);
if (!error) {
error = git_object_lookup(
- object_out, repo, git_reference_target(ref), GIT_OBJ_ANY);
+ object_out, repo, git_reference_target(ref), GIT_OBJECT_ANY);
if (!error)
*reference_out = ref;
return error;
}
- if (error < 0 && error != GIT_ENOTFOUND)
+ if (error != GIT_ENOTFOUND)
return error;
- error = maybe_abbrev(object_out, repo, spec);
- if (!error)
- return 0;
-
- if (error < 0 && error != GIT_ENOTFOUND)
- return error;
-
- error = maybe_describe(object_out, repo, spec);
- if (!error)
- return 0;
+ if ((strlen(spec) < GIT_OID_HEXSZ) &&
+ ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND))
+ return error;
- if (error < 0 && error != GIT_ENOTFOUND)
+ if ((error = maybe_describe(object_out, repo, spec)) != GIT_ENOTFOUND)
return error;
- giterr_set(GITERR_REFERENCE, "Refspec '%s' not found.", spec);
+ git_error_set(GIT_ERROR_REFERENCE, "revspec '%s' not found", spec);
return GIT_ENOTFOUND;
}
int32_t content;
const char *end_ptr;
- if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0)
+ if (git__strntol32(&content, curly_braces_content, strlen(curly_braces_content),
+ &end_ptr, 10) < 0)
return -1;
if (*end_ptr != '\0')
{
git_reference *ref = NULL;
git_reflog *reflog = NULL;
- regex_t preg;
+ git_regexp preg;
int error = -1;
size_t i, numentries, cur;
const git_reflog_entry *entry;
const char *msg;
- regmatch_t regexmatches[2];
git_buf buf = GIT_BUF_INIT;
cur = position;
if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
goto cleanup;
- if (git_reflog_read(&reflog, ref) < 0)
+ if (git_reflog_read(&reflog, repo, GIT_HEAD_FILE) < 0)
goto cleanup;
numentries = git_reflog_entrycount(reflog);
for (i = 0; i < numentries; i++) {
+ git_regmatch regexmatches[2];
+
entry = git_reflog_entry_byindex(reflog, i);
msg = git_reflog_entry_message(entry);
+ if (!msg)
+ continue;
- if (regexec(&preg, msg, 2, regexmatches, 0))
+ if (git_regexp_search(&preg, msg, 2, regexmatches) < 0)
continue;
cur--;
if (cur > 0)
continue;
- git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
+ if ((git_buf_put(&buf, msg+regexmatches[1].start, regexmatches[1].end - regexmatches[1].start)) < 0)
+ goto cleanup;
if ((error = git_reference_dwim(base_ref, repo, git_buf_cstr(&buf))) == 0)
goto cleanup;
cleanup:
git_reference_free(ref);
- git_buf_free(&buf);
- regfree(&preg);
+ git_buf_dispose(&buf);
+ git_regexp_dispose(&preg);
git_reflog_free(reflog);
return error;
}
static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier)
{
git_reflog *reflog;
- int error = -1;
size_t numentries;
const git_reflog_entry *entry;
bool search_by_pos = (identifier <= 100000000);
- if (git_reflog_read(&reflog, ref) < 0)
+ if (git_reflog_read(&reflog, git_reference_owner(ref), git_reference_name(ref)) < 0)
return -1;
numentries = git_reflog_entrycount(reflog);
if (search_by_pos) {
- if (numentries < identifier + 1) {
- giterr_set(
- GITERR_REFERENCE,
- "Reflog for '%s' has only "PRIuZ" entries, asked for "PRIuZ,
- git_reference_name(ref), numentries, identifier);
-
- error = GIT_ENOTFOUND;
- goto cleanup;
- }
+ if (numentries < identifier + 1)
+ goto notfound;
entry = git_reflog_entry_byindex(reflog, identifier);
git_oid_cpy(oid, git_reflog_entry_id_new(entry));
- error = 0;
- goto cleanup;
-
} else {
size_t i;
git_time commit_time;
continue;
git_oid_cpy(oid, git_reflog_entry_id_new(entry));
- error = 0;
- goto cleanup;
+ break;
}
- error = GIT_ENOTFOUND;
+ if (i == numentries)
+ goto notfound;
}
-cleanup:
git_reflog_free(reflog);
- return error;
+ return 0;
+
+notfound:
+ git_error_set(
+ GIT_ERROR_REFERENCE,
+ "reflog for '%s' has only %"PRIuZ" entries, asked for %"PRIuZ,
+ git_reference_name(ref), numentries, identifier);
+
+ git_reflog_free(reflog);
+ return GIT_ENOTFOUND;
}
static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
}
if (position == 0) {
- error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
+ error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJECT_ANY);
goto cleanup;
}
if ((error = retrieve_oid_from_reflog(&oid, ref, position)) < 0)
goto cleanup;
- error = git_object_lookup(out, repo, &oid, GIT_OBJ_ANY);
+ error = git_object_lookup(out, repo, &oid, GIT_OBJECT_ANY);
cleanup:
git_reference_free(ref);
return error;
}
-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)
+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)
{
bool is_numeric;
int parsed = 0, error = -1;
git_buf identifier = GIT_BUF_INIT;
git_time_t timestamp;
- assert(*out == NULL);
+ GIT_ASSERT(*out == NULL);
if (git_buf_put(&identifier, spec, identifier_len) < 0)
return -1;
error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp);
cleanup:
- git_buf_free(&identifier);
+ git_buf_dispose(&identifier);
return error;
}
-static git_otype parse_obj_type(const char *str)
+static git_object_t parse_obj_type(const char *str)
{
if (!strcmp(str, "commit"))
- return GIT_OBJ_COMMIT;
+ return GIT_OBJECT_COMMIT;
if (!strcmp(str, "tree"))
- return GIT_OBJ_TREE;
+ return GIT_OBJECT_TREE;
if (!strcmp(str, "blob"))
- return GIT_OBJ_BLOB;
+ return GIT_OBJECT_BLOB;
if (!strcmp(str, "tag"))
- return GIT_OBJ_TAG;
+ return GIT_OBJECT_TAG;
- return GIT_OBJ_BAD;
+ return GIT_OBJECT_INVALID;
}
static int dereference_to_non_tag(git_object **out, git_object *obj)
{
- if (git_object_type(obj) == GIT_OBJ_TAG)
+ if (git_object_type(obj) == GIT_OBJECT_TAG)
return git_tag_peel(out, (git_tag *)obj);
return git_object_dup(out, obj);
git_object *temp_commit = NULL;
int error;
- if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
+ if ((error = git_object_peel(&temp_commit, obj, GIT_OBJECT_COMMIT)) < 0)
return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
GIT_EINVALIDSPEC : error;
git_object *temp_commit = NULL;
int error;
- if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
+ if ((error = git_object_peel(&temp_commit, obj, GIT_OBJECT_COMMIT)) < 0)
return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
GIT_EINVALIDSPEC : error;
int error = -1;
git_tree_entry *entry = NULL;
- if ((error = git_object_peel(&tree, obj, GIT_OBJ_TREE)) < 0)
+ if ((error = git_object_peel(&tree, obj, GIT_OBJECT_TREE)) < 0)
return error == GIT_ENOTFOUND ? GIT_EINVALIDSPEC : error;
if (*path == '\0') {
return error;
}
-static int walk_and_search(git_object **out, git_revwalk *walk, regex_t *regex)
+static int walk_and_search(git_object **out, git_revwalk *walk, git_regexp *regex)
{
int error;
git_oid oid;
while (!(error = git_revwalk_next(&oid, walk))) {
- error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJ_COMMIT);
+ error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJECT_COMMIT);
if ((error < 0) && (error != GIT_ENOTFOUND))
return -1;
- if (!regexec(regex, git_commit_message((git_commit*)obj), 0, NULL, 0)) {
+ if (!git_regexp_match(regex, git_commit_message((git_commit*)obj))) {
*out = obj;
return 0;
}
static int handle_grep_syntax(git_object **out, git_repository *repo, const git_oid *spec_oid, const char *pattern)
{
- regex_t preg;
+ git_regexp preg;
git_revwalk *walk = NULL;
int error;
git_revwalk_sorting(walk, GIT_SORT_TIME);
if (spec_oid == NULL) {
- // TODO: @carlosmn: The glob should be refs/* but this makes git_revwalk_next() fails
- if ((error = git_revwalk_push_glob(walk, GIT_REFS_HEADS_DIR "*")) < 0)
+ if ((error = git_revwalk_push_glob(walk, "refs/*")) < 0)
goto cleanup;
} else if ((error = git_revwalk_push(walk, spec_oid)) < 0)
goto cleanup;
error = walk_and_search(out, walk, &preg);
cleanup:
- regfree(&preg);
+ git_regexp_dispose(&preg);
git_revwalk_free(walk);
return error;
static int handle_caret_curly_syntax(git_object **out, git_object *obj, const char *curly_braces_content)
{
- git_otype expected_type;
+ git_object_t expected_type;
if (*curly_braces_content == '\0')
return dereference_to_non_tag(out, obj);
expected_type = parse_obj_type(curly_braces_content);
- if (expected_type == GIT_OBJ_BAD)
+ if (expected_type == GIT_OBJECT_INVALID)
return GIT_EINVALIDSPEC;
return git_object_peel(out, obj, expected_type);
{
git_buf_clear(buf);
- assert(spec[*pos] == '^' || spec[*pos] == '@');
+ GIT_ASSERT_ARG(spec[*pos] == '^' || spec[*pos] == '@');
(*pos)++;
if (spec[*pos] == '\0')
return GIT_EINVALIDSPEC;
- git_buf_putc(buf, spec[(*pos)++]);
+ if (git_buf_putc(buf, spec[(*pos)++]) < 0)
+ return -1;
}
(*pos)++;
{
git_buf_clear(buf);
- assert(spec[*pos] == ':');
+ GIT_ASSERT_ARG(spec[*pos] == ':');
(*pos)++;
int parsed, accumulated;
char kind = spec[*pos];
- assert(spec[*pos] == '^' || spec[*pos] == '~');
+ GIT_ASSERT_ARG(spec[*pos] == '^' || spec[*pos] == '~');
accumulated = 0;
} while (spec[(*pos)] == kind && kind == '~');
if (git__isdigit(spec[*pos])) {
- if (git__strtol32(&parsed, spec + *pos, &end_ptr, 10) < 0)
+ if (git__strntol32(&parsed, spec + *pos, strlen(spec + *pos), &end_ptr, 10) < 0)
return GIT_EINVALIDSPEC;
accumulated += (parsed - 1);
*pos = end_ptr - spec;
}
- } while (spec[(*pos)] == kind && kind == '~');
+ } while (spec[(*pos)] == kind && kind == '~');
*n = accumulated;
if (git_reference_resolve(&resolved, reference) < 0)
return -1;
- error = git_object_lookup(object, reference->db->repo, git_reference_target(resolved), GIT_OBJ_ANY);
+ error = git_object_lookup(object, reference->db->repo, git_reference_target(resolved), GIT_OBJECT_ANY);
git_reference_free(resolved);
return error;
return -1;
error = revparse_lookup_object(object, reference, repo, git_buf_cstr(&identifier));
- git_buf_free(&identifier);
+ git_buf_dispose(&identifier);
return error;
}
return GIT_EINVALIDSPEC;
}
-int revparse__ext(
+static int revparse(
git_object **object_out,
git_reference **reference_out,
size_t *identifier_len_out,
git_reference *reference = NULL;
git_object *base_rev = NULL;
- assert(object_out && reference_out && repo && spec);
+ bool should_return_reference = true;
+
+ GIT_ASSERT_ARG(object_out);
+ GIT_ASSERT_ARG(reference_out);
+ GIT_ASSERT_ARG(repo);
+ GIT_ASSERT_ARG(spec);
*object_out = NULL;
*reference_out = NULL;
while (spec[pos]) {
switch (spec[pos]) {
case '^':
+ should_return_reference = false;
+
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0)
goto cleanup;
{
git_object *temp_object = NULL;
+ should_return_reference = false;
+
if ((error = extract_how_many(&n, spec, &pos)) < 0)
goto cleanup;
{
git_object *temp_object = NULL;
+ should_return_reference = false;
+
if ((error = extract_path(&buf, spec, &pos)) < 0)
goto cleanup;
* TODO: support merge-stage path lookup (":2:Makefile")
* and plain index blob lookup (:i-am/a/blob)
*/
- giterr_set(GITERR_INVALID, "Unimplemented");
+ git_error_set(GIT_ERROR_INVALID, "unimplemented");
error = GIT_ERROR;
goto cleanup;
}
}
case '@':
- {
if (spec[pos+1] == '{') {
git_object *temp_object = NULL;
if (temp_object != NULL)
base_rev = temp_object;
break;
- } else {
- /* Fall through */
}
- }
+ /* fall through */
default:
if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference)) < 0)
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0)
goto cleanup;
+ if (!should_return_reference) {
+ git_reference_free(reference);
+ reference = NULL;
+ }
+
*object_out = base_rev;
*reference_out = reference;
*identifier_len_out = identifier_len;
cleanup:
if (error) {
if (error == GIT_EINVALIDSPEC)
- giterr_set(GITERR_INVALID,
- "Failed to parse revision specifier - Invalid pattern '%s'", spec);
+ git_error_set(GIT_ERROR_INVALID,
+ "failed to parse revision specifier - Invalid pattern '%s'", spec);
git_object_free(base_rev);
git_reference_free(reference);
}
- git_buf_free(&buf);
+ git_buf_dispose(&buf);
return error;
}
git_object *obj = NULL;
git_reference *ref = NULL;
- if ((error = revparse__ext(&obj, &ref, &identifier_len, repo, spec)) < 0)
+ if ((error = revparse(&obj, &ref, &identifier_len, repo, spec)) < 0)
goto cleanup;
*object_out = obj;
const char *dotdot;
int error = 0;
- assert(revspec && repo && spec);
+ GIT_ASSERT_ARG(revspec);
+ GIT_ASSERT_ARG(repo);
+ GIT_ASSERT_ARG(spec);
memset(revspec, 0x0, sizeof(*revspec));
if ((dotdot = strstr(spec, "..")) != NULL) {
char *lstr;
const char *rstr;
- revspec->flags = GIT_REVPARSE_RANGE;
+ revspec->flags = GIT_REVSPEC_RANGE;
+
+ /*
+ * Following git.git, don't allow '..' because it makes command line
+ * arguments which can be either paths or revisions ambiguous when the
+ * path is almost certainly intended. The empty range '...' is still
+ * allowed.
+ */
+ if (!git__strcmp(spec, "..")) {
+ git_error_set(GIT_ERROR_INVALID, "Invalid pattern '..'");
+ return GIT_EINVALIDSPEC;
+ }
lstr = git__substrdup(spec, dotdot - spec);
rstr = dotdot + 2;
if (dotdot[2] == '.') {
- revspec->flags |= GIT_REVPARSE_MERGE_BASE;
+ revspec->flags |= GIT_REVSPEC_MERGE_BASE;
rstr++;
}
- if ((error = git_revparse_single(&revspec->from, repo, lstr)) < 0) {
- return error;
- }
+ error = git_revparse_single(
+ &revspec->from,
+ repo,
+ *lstr == '\0' ? "HEAD" : lstr);
- if ((error = git_revparse_single(&revspec->to, repo, rstr)) < 0) {
- return error;
+ if (!error) {
+ error = git_revparse_single(
+ &revspec->to,
+ repo,
+ *rstr == '\0' ? "HEAD" : rstr);
}
git__free((void*)lstr);
} else {
- revspec->flags = GIT_REVPARSE_SINGLE;
+ revspec->flags = GIT_REVSPEC_SINGLE;
error = git_revparse_single(&revspec->from, repo, spec);
}
projects / libgit2.git / blobdiff