proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-05-09 22:39:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1087 from libgit2/great-renaming

Browse Source 
The Great Renaming of 2012
This commit is contained in:
Ben Straub 2012-11-27 18:59:22 -08:00
commit 64c5112188
163 changed files with 2247 additions and 2037 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -204,7 +204,7 @@ IF (BUILD_CLAR)
ADD_CUSTOM_COMMAND( ADD_CUSTOM_COMMAND(
OUTPUT ${CLAR_PATH}/clar_main.c ${CLAR_PATH}/clar.h OUTPUT ${CLAR_PATH}/clar_main.c ${CLAR_PATH}/clar.h
COMMAND ${PYTHON_EXECUTABLE} clar -vtap . COMMAND ${PYTHON_EXECUTABLE} clar .
DEPENDS ${CLAR_PATH}/clar ${SRC_TEST} DEPENDS ${CLAR_PATH}/clar ${SRC_TEST}
WORKING_DIRECTORY ${CLAR_PATH} WORKING_DIRECTORY ${CLAR_PATH}
) )

10
examples/diff.c
View File

@ -30,7 +30,7 @@ static int resolve_to_tree(
git_reference_resolve(&resolved, ref); git_reference_resolve(&resolved, ref);
git_reference_free(ref); git_reference_free(ref);
if (resolved) { if (resolved) {
git_object_lookup(&obj, repo, git_reference_oid(resolved), GIT_OBJ_ANY); git_object_lookup(&obj, repo, git_reference_target(resolved), GIT_OBJ_ANY);
git_reference_free(resolved); git_reference_free(resolved);
} }
} }
@ -63,12 +63,12 @@ char *colors[] = {
}; };
static int printer( static int printer(
void *data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
char usage, char usage,
const char *line, const char *line,
size_t line_len) size_t line_len,
void *data)
{ {
int *last_color = data, color = 0; int *last_color = data, color = 0;
@ -225,9 +225,9 @@ int main(int argc, char *argv[])
fputs(colors[0], stdout); fputs(colors[0], stdout);
if (compact) if (compact)
check(git_diff_print_compact(diff, &color, printer), "Displaying diff"); check(git_diff_print_compact(diff, printer, &color), "Displaying diff");
else else
check(git_diff_print_patch(diff, &color, printer), "Displaying diff"); check(git_diff_print_patch(diff, printer, &color), "Displaying diff");
if (color >= 0) if (color >= 0)
fputs(colors[0], stdout); fputs(colors[0], stdout);

12
examples/general.c
View File

@ -261,8 +261,8 @@ int main (int argc, char** argv)
git_tree_lookup(&tree, repo, &oid); git_tree_lookup(&tree, repo, &oid);
// Getting the count of entries in the tree so you can iterate over them if you want to. // Getting the count of entries in the tree so you can iterate over them if you want to.
int cnt = git_tree_entrycount(tree); // 3 size_t cnt = git_tree_entrycount(tree); // 3
printf("tree entries: %d\n", cnt); printf("tree entries: %d\n", (int)cnt);
entry = git_tree_entry_byindex(tree, 0); entry = git_tree_entry_byindex(tree, 0);
printf("Entry name: %s\n", git_tree_entry_name(entry)); // "hello.c" printf("Entry name: %s\n", git_tree_entry_name(entry)); // "hello.c"
@ -298,7 +298,7 @@ int main (int argc, char** argv)
// Note that this buffer may not be contain ASCII data for certain blobs (e.g. binary files): // Note that this buffer may not be contain ASCII data for certain blobs (e.g. binary files):
// do not consider the buffer a NULL-terminated string, and use the `git_blob_rawsize` attribute to // do not consider the buffer a NULL-terminated string, and use the `git_blob_rawsize` attribute to
// find out its exact size in bytes // find out its exact size in bytes
printf("Blob Size: %ld\n", git_blob_rawsize(blob)); // 8 printf("Blob Size: %ld\n", (long)git_blob_rawsize(blob)); // 8
git_blob_rawcontent(blob); // "content" git_blob_rawcontent(blob); // "content"
// ### Revwalking // ### Revwalking
@ -371,7 +371,7 @@ int main (int argc, char** argv)
// All these properties are exported publicly in the `git_index_entry` struct // All these properties are exported publicly in the `git_index_entry` struct
ecount = git_index_entrycount(index); ecount = git_index_entrycount(index);
for (i = 0; i < ecount; ++i) { for (i = 0; i < ecount; ++i) {
git_index_entry *e = git_index_get_byindex(index, i); const git_index_entry *e = git_index_get_byindex(index, i);
printf("path: %s\n", e->path); printf("path: %s\n", e->path);
printf("mtime: %d\n", (int)e->mtime.seconds); printf("mtime: %d\n", (int)e->mtime.seconds);
@ -405,12 +405,12 @@ int main (int argc, char** argv)
switch (git_reference_type(ref)) { switch (git_reference_type(ref)) {
case GIT_REF_OID: case GIT_REF_OID:
git_oid_fmt(out, git_reference_oid(ref)); git_oid_fmt(out, git_reference_target(ref));
printf("%s [%s]\n", refname, out); printf("%s [%s]\n", refname, out);
break; break;
case GIT_REF_SYMBOLIC: case GIT_REF_SYMBOLIC:
printf("%s => %s\n", refname, git_reference_target(ref)); printf("%s => %s\n", refname, git_reference_symbolic_target(ref));
break; break;
default: default:
fprintf(stderr, "Unexpected reference type\n"); fprintf(stderr, "Unexpected reference type\n");

2
examples/network/clone.c
View File

@ -72,7 +72,7 @@ int do_clone(git_repository *repo, int argc, char **argv)
checkout_opts.progress_payload = &pd; checkout_opts.progress_payload = &pd;
// Do the clone // Do the clone
error = git_clone(&cloned_repo, url, path, &fetch_progress, &pd, &checkout_opts); error = git_clone(&cloned_repo, url, path, &checkout_opts, &fetch_progress, &pd);
printf("\n"); printf("\n");
if (error != 0) { if (error != 0) {
const git_error *err = giterr_last(); const git_error *err = giterr_last();

2
examples/network/fetch.c
View File

@ -25,7 +25,7 @@ static void *download(void *ptr)
// Connect to the remote end specifying that we want to fetch // Connect to the remote end specifying that we want to fetch
// information from it. // information from it.
if (git_remote_connect(data->remote, GIT_DIR_FETCH) < 0) { if (git_remote_connect(data->remote, GIT_DIRECTION_FETCH) < 0) {
data->ret = -1; data->ret = -1;
goto exit; goto exit;
} }

4
examples/network/ls-remote.c
View File

@ -27,7 +27,7 @@ static int use_unnamed(git_repository *repo, const char *url)
// When connecting, the underlying code needs to know wether we // When connecting, the underlying code needs to know wether we
// want to push or fetch // want to push or fetch
error = git_remote_connect(remote, GIT_DIR_FETCH); error = git_remote_connect(remote, GIT_DIRECTION_FETCH);
if (error < 0) if (error < 0)
goto cleanup; goto cleanup;
@ -49,7 +49,7 @@ static int use_remote(git_repository *repo, char *name)
if (error < 0) if (error < 0)
goto cleanup; goto cleanup;
error = git_remote_connect(remote, GIT_DIR_FETCH); error = git_remote_connect(remote, GIT_DIRECTION_FETCH);
if (error < 0) if (error < 0)
goto cleanup; goto cleanup;

4
include/git2/attr.h
View File

@ -183,6 +183,8 @@ GIT_EXTERN(int) git_attr_get_many(
size_t num_attr, size_t num_attr,
const char **names); const char **names);
typedef int (*git_attr_foreach_cb)(const char *name, const char *value, void *payload);
/** /**
* Loop over all the git attributes for a path. * Loop over all the git attributes for a path.
* *
@ -204,7 +206,7 @@ GIT_EXTERN(int) git_attr_foreach(
git_repository *repo, git_repository *repo,
uint32_t flags, uint32_t flags,
const char *path, const char *path,
int (*callback)(const char *name, const char *value, void *payload), git_attr_foreach_cb callback,
void *payload); void *payload);
/** /**

32
include/git2/blob.h
View File

@ -68,6 +68,17 @@ GIT_INLINE(void) git_blob_free(git_blob *blob)
git_object_free((git_object *) blob); git_object_free((git_object *) blob);
} }
/**
* Get the id of a blob.
*
* @param blob a previously loaded blob.
* @return SHA1 hash for this blob.
*/
GIT_INLINE(const git_oid *) git_blob_id(const git_blob *blob)
{
return git_object_id((const git_object *)blob);
}
/** /**
* Get a read-only buffer with the raw content of a blob. * Get a read-only buffer with the raw content of a blob.
@ -88,32 +99,35 @@ GIT_EXTERN(const void *) git_blob_rawcontent(git_blob *blob);
* @param blob pointer to the blob * @param blob pointer to the blob
* @return size on bytes * @return size on bytes
*/ */
GIT_EXTERN(size_t) git_blob_rawsize(git_blob *blob); GIT_EXTERN(git_off_t) git_blob_rawsize(git_blob *blob);
/** /**
* Read a file from the working folder of a repository * Read a file from the working folder of a repository
* and write it to the Object Database as a loose blob * and write it to the Object Database as a loose blob
* *
* @param oid return the id of the written blob * @param id return the id of the written blob
* @param repo repository where the blob will be written. * @param repo repository where the blob will be written.
* this repository cannot be bare * this repository cannot be bare
* @param path file from which the blob will be created, * @param relative_path file from which the blob will be created,
* relative to the repository's working dir * relative to the repository's working dir
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path); GIT_EXTERN(int) git_blob_create_fromworkdir(git_oid *id, git_repository *repo, const char *relative_path);
/** /**
* Read a file from the filesystem and write its content * Read a file from the filesystem and write its content
* to the Object Database as a loose blob * to the Object Database as a loose blob
* *
* @param oid return the id of the written blob * @param id return the id of the written blob
* @param repo repository where the blob will be written. * @param repo repository where the blob will be written.
* this repository can be bare or not * this repository can be bare or not
* @param path file from which the blob will be created * @param path file from which the blob will be created
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, const char *path); GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path);
typedef int (*git_blob_chunk_cb)(char *content, size_t max_length, void *payload);
/** /**
* Write a loose blob to the Object Database from a * Write a loose blob to the Object Database from a
@ -141,7 +155,7 @@ GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, con
* - When an error occurs, the callback should return -1. * - When an error occurs, the callback should return -1.
* *
* *
* @param oid Return the id of the written blob * @param id Return the id of the written blob
* *
* @param repo repository where the blob will be written. * @param repo repository where the blob will be written.
* This repository can be bare or not. * This repository can be bare or not.
@ -152,10 +166,10 @@ GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, con
* @return GIT_SUCCESS or an error code * @return GIT_SUCCESS or an error code
*/ */
GIT_EXTERN(int) git_blob_create_fromchunks( GIT_EXTERN(int) git_blob_create_fromchunks(
git_oid *oid, git_oid *id,
git_repository *repo, git_repository *repo,
const char *hintpath, const char *hintpath,
int (*source_cb)(char *content, size_t max_length, void *payload), git_blob_chunk_cb callback,
void *payload); void *payload);
/** /**

14
include/git2/branch.h
View File

@ -29,7 +29,7 @@ GIT_BEGIN_DECL
* *
* The returned reference must be freed by the user. * The returned reference must be freed by the user.
* *
* @param branch_out Pointer where to store the underlying reference. * @param out Pointer where to store the underlying reference.
* *
* @param branch_name Name for the branch; this name is * @param branch_name Name for the branch; this name is
* validated for consistency. It should also not conflict with * validated for consistency. It should also not conflict with
@ -47,10 +47,10 @@ GIT_BEGIN_DECL
* pointing to the provided target commit. * pointing to the provided target commit.
*/ */
GIT_EXTERN(int) git_branch_create( GIT_EXTERN(int) git_branch_create(
git_reference **branch_out, git_reference **out,
git_repository *repo, git_repository *repo,
const char *branch_name, const char *branch_name,
const git_object *target, const git_commit *target,
int force); int force);
/** /**
@ -113,7 +113,7 @@ GIT_EXTERN(int) git_branch_move(
* *
* The generated reference must be freed by the user. * The generated reference must be freed by the user.
* *
* @param branch_out pointer to the looked-up branch reference * @param out pointer to the looked-up branch reference
* *
* @param repo the repository to look up the branch * @param repo the repository to look up the branch
* *
@ -127,7 +127,7 @@ GIT_EXTERN(int) git_branch_move(
* exists, otherwise an error code. * exists, otherwise an error code.
*/ */
GIT_EXTERN(int) git_branch_lookup( GIT_EXTERN(int) git_branch_lookup(
git_reference **branch_out, git_reference **out,
git_repository *repo, git_repository *repo,
const char *branch_name, const char *branch_name,
git_branch_t branch_type); git_branch_t branch_type);
@ -136,7 +136,7 @@ GIT_EXTERN(int) git_branch_lookup(
* Return the reference supporting the remote tracking branch, * Return the reference supporting the remote tracking branch,
* given a local branch reference. * given a local branch reference.
* *
* @param tracking_out Pointer where to store the retrieved * @param out Pointer where to store the retrieved
* reference. * reference.
* *
* @param branch Current underlying reference of the branch. * @param branch Current underlying reference of the branch.
@ -145,7 +145,7 @@ GIT_EXTERN(int) git_branch_lookup(
* reference exists, otherwise an error code. * reference exists, otherwise an error code.
*/ */
GIT_EXTERN(int) git_branch_tracking( GIT_EXTERN(int) git_branch_tracking(
git_reference **tracking_out, git_reference **out,
git_reference *branch); git_reference *branch);
/** /**

8
include/git2/checkout.h
View File

@ -146,8 +146,12 @@ typedef enum {
* Checkout options structure * Checkout options structure
* *
* Use zeros to indicate default settings. * Use zeros to indicate default settings.
* This needs to be initialized with the `GIT_CHECKOUT_OPTS_INIT` macro:
*
* git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
*/ */
typedef struct git_checkout_opts { typedef struct git_checkout_opts {
unsigned int version;
unsigned int checkout_strategy; /** default will be a dry run */ unsigned int checkout_strategy; /** default will be a dry run */
int disable_filters; /** don't apply filters like CRLF conversion */ int disable_filters; /** don't apply filters like CRLF conversion */
@ -182,6 +186,8 @@ typedef struct git_checkout_opts {
git_strarray paths; git_strarray paths;
} git_checkout_opts; } git_checkout_opts;
#define GIT_CHECKOUT_OPTS_INIT {1, 0}
/** /**
* Updates files in the index and the working tree to match the content of the * Updates files in the index and the working tree to match the content of the
* commit pointed at by HEAD. * commit pointed at by HEAD.
@ -223,7 +229,7 @@ GIT_EXTERN(int) git_checkout_index(
*/ */
GIT_EXTERN(int) git_checkout_tree( GIT_EXTERN(int) git_checkout_tree(
git_repository *repo, git_repository *repo,
git_object *treeish, const git_object *treeish,
git_checkout_opts *opts); git_checkout_opts *opts);
/** @} */ /** @} */

4
include/git2/clone.h
View File

@ -42,9 +42,9 @@ GIT_EXTERN(int) git_clone(
git_repository **out, git_repository **out,
const char *origin_url, const char *origin_url,
const char *workdir_path, const char *workdir_path,
git_checkout_opts *checkout_opts,
git_transfer_progress_callback fetch_progress_cb, git_transfer_progress_callback fetch_progress_cb,
void *fetch_progress_payload, void *fetch_progress_payload);
git_checkout_opts *checkout_opts);
/** /**
* Create a bare clone of a remote repository. * Create a bare clone of a remote repository.

35
include/git2/commit.h
View File

@ -76,7 +76,10 @@ GIT_INLINE(void) git_commit_free(git_commit *commit)
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return object identity for the commit. * @return object identity for the commit.
*/ */
GIT_EXTERN(const git_oid *) git_commit_id(git_commit *commit); GIT_INLINE(const git_oid *) git_commit_id(const git_commit *commit)
{
return git_object_id((const git_object *)commit);
}
/** /**
* Get the encoding for the message of a commit, * Get the encoding for the message of a commit,
@ -88,7 +91,7 @@ GIT_EXTERN(const git_oid *) git_commit_id(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return NULL, or the encoding * @return NULL, or the encoding
*/ */
GIT_EXTERN(const char *) git_commit_message_encoding(git_commit *commit); GIT_EXTERN(const char *) git_commit_message_encoding(const git_commit *commit);
/** /**
* Get the full message of a commit. * Get the full message of a commit.
@ -96,7 +99,7 @@ GIT_EXTERN(const char *) git_commit_message_encoding(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return the message of a commit * @return the message of a commit
*/ */
GIT_EXTERN(const char *) git_commit_message(git_commit *commit); GIT_EXTERN(const char *) git_commit_message(const git_commit *commit);
/** /**
* Get the commit time (i.e. committer time) of a commit. * Get the commit time (i.e. committer time) of a commit.
@ -104,7 +107,7 @@ GIT_EXTERN(const char *) git_commit_message(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return the time of a commit * @return the time of a commit
*/ */
GIT_EXTERN(git_time_t) git_commit_time(git_commit *commit); GIT_EXTERN(git_time_t) git_commit_time(const git_commit *commit);
/** /**
* Get the commit timezone offset (i.e. committer's preferred timezone) of a commit. * Get the commit timezone offset (i.e. committer's preferred timezone) of a commit.
@ -112,7 +115,7 @@ GIT_EXTERN(git_time_t) git_commit_time(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return positive or negative timezone offset, in minutes from UTC * @return positive or negative timezone offset, in minutes from UTC
*/ */
GIT_EXTERN(int) git_commit_time_offset(git_commit *commit); GIT_EXTERN(int) git_commit_time_offset(const git_commit *commit);
/** /**
* Get the committer of a commit. * Get the committer of a commit.
@ -120,7 +123,7 @@ GIT_EXTERN(int) git_commit_time_offset(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return the committer of a commit * @return the committer of a commit
*/ */
GIT_EXTERN(const git_signature *) git_commit_committer(git_commit *commit); GIT_EXTERN(const git_signature *) git_commit_committer(const git_commit *commit);
/** /**
* Get the author of a commit. * Get the author of a commit.
@ -128,7 +131,7 @@ GIT_EXTERN(const git_signature *) git_commit_committer(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return the author of a commit * @return the author of a commit
*/ */
GIT_EXTERN(const git_signature *) git_commit_author(git_commit *commit); GIT_EXTERN(const git_signature *) git_commit_author(const git_commit *commit);
/** /**
* Get the tree pointed to by a commit. * Get the tree pointed to by a commit.
@ -137,7 +140,7 @@ GIT_EXTERN(const git_signature *) git_commit_author(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, git_commit *commit); GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, const git_commit *commit);
/** /**
* Get the id of the tree pointed to by a commit. This differs from * Get the id of the tree pointed to by a commit. This differs from
@ -147,7 +150,7 @@ GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return the id of tree pointed to by commit. * @return the id of tree pointed to by commit.
*/ */
GIT_EXTERN(const git_oid *) git_commit_tree_oid(git_commit *commit); GIT_EXTERN(const git_oid *) git_commit_tree_id(const git_commit *commit);
/** /**
* Get the number of parents of this commit * Get the number of parents of this commit
@ -155,17 +158,17 @@ GIT_EXTERN(const git_oid *) git_commit_tree_oid(git_commit *commit);
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @return integer of count of parents * @return integer of count of parents
*/ */
GIT_EXTERN(unsigned int) git_commit_parentcount(git_commit *commit); GIT_EXTERN(unsigned int) git_commit_parentcount(const git_commit *commit);
/** /**
* Get the specified parent of the commit. * Get the specified parent of the commit.
* *
* @param parent Pointer where to store the parent commit * @param out Pointer where to store the parent commit
* @param commit a previously loaded commit. * @param commit a previously loaded commit.
* @param n the position of the parent (from 0 to `parentcount`) * @param n the position of the parent (from 0 to `parentcount`)
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n); GIT_EXTERN(int) git_commit_parent(git_commit **out, git_commit *commit, unsigned int n);
/** /**
* Get the oid of a specified parent for a commit. This is different from * Get the oid of a specified parent for a commit. This is different from
@ -176,7 +179,7 @@ GIT_EXTERN(int) git_commit_parent(git_commit **parent, git_commit *commit, unsig
* @param n the position of the parent (from 0 to `parentcount`) * @param n the position of the parent (from 0 to `parentcount`)
* @return the id of the parent, NULL on error. * @return the id of the parent, NULL on error.
*/ */
GIT_EXTERN(const git_oid *) git_commit_parent_oid(git_commit *commit, unsigned int n); GIT_EXTERN(const git_oid *) git_commit_parent_id(git_commit *commit, unsigned int n);
/** /**
* Get the commit object that is the <n>th generation ancestor * Get the commit object that is the <n>th generation ancestor
@ -204,7 +207,7 @@ GIT_EXTERN(int) git_commit_nth_gen_ancestor(
* The message will not be cleaned up. This can be achieved * The message will not be cleaned up. This can be achieved
* through `git_message_prettify()`. * through `git_message_prettify()`.
* *
* @param oid Pointer where to store the OID of the * @param id Pointer where to store the OID of the
* newly created commit * newly created commit
* *
* @param repo Repository where to store the commit * @param repo Repository where to store the commit
@ -245,7 +248,7 @@ GIT_EXTERN(int) git_commit_nth_gen_ancestor(
* the given reference will be updated to point to it * the given reference will be updated to point to it
*/ */
GIT_EXTERN(int) git_commit_create( GIT_EXTERN(int) git_commit_create(
git_oid *oid, git_oid *id,
git_repository *repo, git_repository *repo,
const char *update_ref, const char *update_ref,
const git_signature *author, const git_signature *author,
@ -273,7 +276,7 @@ GIT_EXTERN(int) git_commit_create(
* @see git_commit_create * @see git_commit_create
*/ */
GIT_EXTERN(int) git_commit_create_v( GIT_EXTERN(int) git_commit_create_v(
git_oid *oid, git_oid *id,
git_repository *repo, git_repository *repo,
const char *update_ref, const char *update_ref,
const git_signature *author, const git_signature *author,

110
include/git2/config.h
View File

@ -41,23 +41,26 @@ typedef struct {
unsigned int level; unsigned int level;
} git_config_entry; } git_config_entry;
typedef int (*git_config_foreach_cb)(const git_config_entry *, void *);
/** /**
* Generic backend that implements the interface to * Generic backend that implements the interface to
* access a configuration file * access a configuration file
*/ */
struct git_config_file { struct git_config_backend {
struct git_config *cfg; struct git_config *cfg;
/* Open means open the file/database and parse if necessary */ /* Open means open the file/database and parse if necessary */
int (*open)(struct git_config_file *, unsigned int level); int (*open)(struct git_config_backend *, unsigned int level);
int (*get)(struct git_config_file *, const char *key, const git_config_entry **entry); int (*get)(const struct git_config_backend *, const char *key, const git_config_entry **entry);
int (*get_multivar)(struct git_config_file *, const char *key, const char *regexp, int (*fn)(const git_config_entry *, void *), void *data); int (*get_multivar)(struct git_config_backend *, const char *key, const char *regexp, git_config_foreach_cb callback, void *payload);
int (*set)(struct git_config_file *, const char *key, const char *value); int (*set)(struct git_config_backend *, const char *key, const char *value);
int (*set_multivar)(git_config_file *cfg, const char *name, const char *regexp, const char *value); int (*set_multivar)(git_config_backend *cfg, const char *name, const char *regexp, const char *value);
int (*del)(struct git_config_file *, const char *key); int (*del)(struct git_config_backend *, const char *key);
int (*foreach)(struct git_config_file *, const char *, int (*fn)(const git_config_entry *, void *), void *data); int (*foreach)(struct git_config_backend *, const char *, git_config_foreach_cb callback, void *payload);
int (*refresh)(struct git_config_file *); int (*refresh)(struct git_config_backend *);
void (*free)(struct git_config_file *); void (*free)(struct git_config_backend *);
}; };
typedef enum { typedef enum {
@ -87,11 +90,11 @@ typedef struct {
* This method will not guess the path to the xdg compatible * This method will not guess the path to the xdg compatible
* config file (.config/git/config). * config file (.config/git/config).
* *
* @param global_config_path Buffer of GIT_PATH_MAX length to store the path * @param out Buffer to store the path in
* @return 0 if a global configuration file has been * @param length size of the buffer in bytes
* found. Its path will be stored in `buffer`. * @return 0 if a global configuration file has been found. Its path will be stored in `buffer`.
*/ */
GIT_EXTERN(int) git_config_find_global(char *global_config_path, size_t length); GIT_EXTERN(int) git_config_find_global(char *out, size_t length);
/** /**
* Locate the path to the global xdg compatible configuration file * Locate the path to the global xdg compatible configuration file
@ -104,11 +107,12 @@ GIT_EXTERN(int) git_config_find_global(char *global_config_path, size_t length);
* may be used on any `git_config` call to load the * may be used on any `git_config` call to load the
* xdg compatible configuration file. * xdg compatible configuration file.
* *
* @param xdg_config_path Buffer of GIT_PATH_MAX length to store the path * @param out Buffer to store the path in
* @param length size of the buffer in bytes
* @return 0 if a xdg compatible configuration file has been * @return 0 if a xdg compatible configuration file has been
* found. Its path will be stored in `buffer`. * found. Its path will be stored in `buffer`.
*/ */
GIT_EXTERN(int) git_config_find_xdg(char *xdg_config_path, size_t length); GIT_EXTERN(int) git_config_find_xdg(char *out, size_t length);
/** /**
* Locate the path to the system configuration file * Locate the path to the system configuration file
@ -116,11 +120,12 @@ GIT_EXTERN(int) git_config_find_xdg(char *xdg_config_path, size_t length);
* If /etc/gitconfig doesn't exist, it will look for * If /etc/gitconfig doesn't exist, it will look for
* %PROGRAMFILES%\Git\etc\gitconfig. * %PROGRAMFILES%\Git\etc\gitconfig.
* @param system_config_path Buffer of GIT_PATH_MAX length to store the path * @param global_config_path Buffer to store the path in
* @param length size of the buffer in bytes
* @return 0 if a system configuration file has been * @return 0 if a system configuration file has been
* found. Its path will be stored in `buffer`. * found. Its path will be stored in `buffer`.
*/ */
GIT_EXTERN(int) git_config_find_system(char *system_config_path, size_t length); GIT_EXTERN(int) git_config_find_system(char *out, size_t length);
/** /**
* Open the global, XDG and system configuration files * Open the global, XDG and system configuration files
@ -163,9 +168,9 @@ GIT_EXTERN(int) git_config_new(git_config **out);
* @return 0 on success, GIT_EEXISTS when adding more than one file * @return 0 on success, GIT_EEXISTS when adding more than one file
* for a given priority level (and force_replace set to 0), or error code * for a given priority level (and force_replace set to 0), or error code
*/ */
GIT_EXTERN(int) git_config_add_file( GIT_EXTERN(int) git_config_add_backend(
git_config *cfg, git_config *cfg,
git_config_file *file, git_config_backend *file,
unsigned int level, unsigned int level,
int force); int force);
@ -223,12 +228,15 @@ GIT_EXTERN(int) git_config_open_ondisk(git_config **out, const char *path);
* will return different config instances, but containing the same config_file * will return different config instances, but containing the same config_file
* instance. * instance.
* *
* @param out The configuration instance to create
* @param parent Multi-level config to search for the given level
* @param level Configuration level to search for
* @return 0, GIT_ENOTFOUND if the passed level cannot be found in the * @return 0, GIT_ENOTFOUND if the passed level cannot be found in the
* multi-level parent config, or an error code * multi-level parent config, or an error code
*/ */
GIT_EXTERN(int) git_config_open_level( GIT_EXTERN(int) git_config_open_level(
git_config **cfg_out, git_config **out,
git_config *cfg_parent, const git_config *parent,
unsigned int level); unsigned int level);
/** /**
@ -262,7 +270,10 @@ GIT_EXTERN(void) git_config_free(git_config *cfg);
* @param name the variable's name * @param name the variable's name
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_config_get_entry(const git_config_entry **out, git_config *cfg, const char *name); GIT_EXTERN(int) git_config_get_entry(
const git_config_entry **out,
const git_config *cfg,
const char *name);
/** /**
* Get the value of an integer config variable. * Get the value of an integer config variable.
@ -276,7 +287,7 @@ GIT_EXTERN(int) git_config_get_entry(const git_config_entry **out, git_config *c
* @param name the variable's name * @param name the variable's name
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_config_get_int32(int32_t *out, git_config *cfg, const char *name); GIT_EXTERN(int) git_config_get_int32(int32_t *out, const git_config *cfg, const char *name);
/** /**
* Get the value of a long integer config variable. * Get the value of a long integer config variable.
@ -290,7 +301,7 @@ GIT_EXTERN(int) git_config_get_int32(int32_t *out, git_config *cfg, const char *
* @param name the variable's name * @param name the variable's name
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_config_get_int64(int64_t *out, git_config *cfg, const char *name); GIT_EXTERN(int) git_config_get_int64(int64_t *out, const git_config *cfg, const char *name);
/** /**
* Get the value of a boolean config variable. * Get the value of a boolean config variable.
@ -307,7 +318,7 @@ GIT_EXTERN(int) git_config_get_int64(int64_t *out, git_config *cfg, const char *
* @param name the variable's name * @param name the variable's name
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_config_get_bool(int *out, git_config *cfg, const char *name); GIT_EXTERN(int) git_config_get_bool(int *out, const git_config *cfg, const char *name);
/** /**
* Get the value of a string config variable. * Get the value of a string config variable.
@ -324,7 +335,7 @@ GIT_EXTERN(int) git_config_get_bool(int *out, git_config *cfg, const char *name)
* @param name the variable's name * @param name the variable's name
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_config_get_string(const char **out, git_config *cfg, const char *name); GIT_EXTERN(int) git_config_get_string(const char **out, const git_config *cfg, const char *name);
/** /**
* Get each value of a multivar. * Get each value of a multivar.
@ -338,7 +349,7 @@ GIT_EXTERN(int) git_config_get_string(const char **out, git_config *cfg, const c
* @param fn the function to be called on each value of the variable * @param fn the function to be called on each value of the variable
* @param data opaque pointer to pass to the callback * @param data opaque pointer to pass to the callback
*/ */
GIT_EXTERN(int) git_config_get_multivar(git_config *cfg, const char *name, const char *regexp, int (*fn)(const git_config_entry *, void *), void *data); GIT_EXTERN(int) git_config_get_multivar(const git_config *cfg, const char *name, const char *regexp, git_config_foreach_cb callback, void *payload);
/** /**
* Set the value of an integer config variable in the config file * Set the value of an integer config variable in the config file
@ -404,7 +415,7 @@ GIT_EXTERN(int) git_config_set_multivar(git_config *cfg, const char *name, const
* @param cfg the configuration * @param cfg the configuration
* @param name the variable to delete * @param name the variable to delete
*/ */
GIT_EXTERN(int) git_config_delete(git_config *cfg, const char *name); GIT_EXTERN(int) git_config_delete_entry(git_config *cfg, const char *name);
/** /**
* Perform an operation on each config variable. * Perform an operation on each config variable.
@ -420,8 +431,8 @@ GIT_EXTERN(int) git_config_delete(git_config *cfg, const char *name);
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_config_foreach( GIT_EXTERN(int) git_config_foreach(
git_config *cfg, const git_config *cfg,
int (*callback)(const git_config_entry *, void *payload), git_config_foreach_cb callback,
void *payload); void *payload);
/** /**
@ -438,9 +449,9 @@ GIT_EXTERN(int) git_config_foreach(
* @return 0 or the return value of the callback which didn't return 0 * @return 0 or the return value of the callback which didn't return 0
*/ */
GIT_EXTERN(int) git_config_foreach_match( GIT_EXTERN(int) git_config_foreach_match(
git_config *cfg, const git_config *cfg,
const char *regexp, const char *regexp,
int (*callback)(const git_config_entry *entry, void *payload), git_config_foreach_cb callback,
void *payload); void *payload);
/** /**
@ -477,7 +488,12 @@ GIT_EXTERN(int) git_config_foreach_match(
* @param map_n number of mapping objects in `maps` * @param map_n number of mapping objects in `maps`
* @return 0 on success, error code otherwise * @return 0 on success, error code otherwise
*/ */
GIT_EXTERN(int) git_config_get_mapped(int *out, git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n); GIT_EXTERN(int) git_config_get_mapped(
int *out,
const git_config *cfg,
const char *name,
const git_cvar_map *maps,
size_t map_n);
/** /**
* Maps a string value to an integer constant * Maps a string value to an integer constant
@ -489,7 +505,7 @@ GIT_EXTERN(int) git_config_get_mapped(int *out, git_config *cfg, const char *nam
*/ */
GIT_EXTERN(int) git_config_lookup_map_value( GIT_EXTERN(int) git_config_lookup_map_value(
int *out, int *out,
git_cvar_map *maps, const git_cvar_map *maps,
size_t map_n, size_t map_n,
const char *value); const char *value);
@ -505,18 +521,6 @@ GIT_EXTERN(int) git_config_lookup_map_value(
*/ */
GIT_EXTERN(int) git_config_parse_bool(int *out, const char *value); GIT_EXTERN(int) git_config_parse_bool(int *out, const char *value);
/**
* Parse a string value as an int64.
*
* An optional value suffix of 'k', 'm', or 'g' will
* cause the value to be multiplied by 1024, 1048576,
* or 1073741824 prior to output.
*
* @param out place to store the result of the parsing
* @param value value to parse
*/
GIT_EXTERN(int) git_config_parse_int64(int64_t *out, const char *value);
/** /**
* Parse a string value as an int32. * Parse a string value as an int32.
* *
@ -529,6 +533,18 @@ GIT_EXTERN(int) git_config_parse_int64(int64_t *out, const char *value);
*/ */
GIT_EXTERN(int) git_config_parse_int32(int32_t *out, const char *value); GIT_EXTERN(int) git_config_parse_int32(int32_t *out, const char *value);
/**
* Parse a string value as an int64.
*
* An optional value suffix of 'k', 'm', or 'g' will
* cause the value to be multiplied by 1024, 1048576,
* or 1073741824 prior to output.
*
* @param out place to store the result of the parsing
* @param value value to parse
*/
GIT_EXTERN(int) git_config_parse_int64(int64_t *out, const char *value);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

71
include/git2/diff.h
View File

@ -106,6 +106,7 @@ typedef enum {
* - max_size: maximum blob size to diff, above this treated as binary * - max_size: maximum blob size to diff, above this treated as binary
*/ */
typedef struct { typedef struct {
unsigned int version; /**< version for the struct */
uint32_t flags; /**< defaults to GIT_DIFF_NORMAL */ uint32_t flags; /**< defaults to GIT_DIFF_NORMAL */
uint16_t context_lines; /**< defaults to 3 */ uint16_t context_lines; /**< defaults to 3 */
uint16_t interhunk_lines; /**< defaults to 0 */ uint16_t interhunk_lines; /**< defaults to 0 */
@ -186,10 +187,10 @@ typedef struct {
/** /**
* When iterating over a diff, callback that will be made per file. * When iterating over a diff, callback that will be made per file.
*/ */
typedef int (*git_diff_file_fn)( typedef int (*git_diff_file_cb)(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
float progress); float progress,
void *payload);
/** /**
* Structure describing a hunk of a diff. * Structure describing a hunk of a diff.
@ -204,31 +205,31 @@ typedef struct {
/** /**
* When iterating over a diff, callback that will be made per hunk. * When iterating over a diff, callback that will be made per hunk.
*/ */
typedef int (*git_diff_hunk_fn)( typedef int (*git_diff_hunk_cb)(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
const char *header, const char *header,
size_t header_len); size_t header_len,
void *payload);
/** /**
* Line origin constants. * Line origin constants.
* *
* These values describe where a line came from and will be passed to * These values describe where a line came from and will be passed to
* the git_diff_data_fn when iterating over a diff. There are some * the git_diff_data_cb when iterating over a diff. There are some
* special origin constants at the end that are used for the text * special origin constants at the end that are used for the text
* output callbacks to demarcate lines that are actually part of * output callbacks to demarcate lines that are actually part of
* the file or hunk headers. * the file or hunk headers.
*/ */
typedef enum { typedef enum {
/* These values will be sent to `git_diff_data_fn` along with the line */ /* These values will be sent to `git_diff_data_cb` along with the line */
GIT_DIFF_LINE_CONTEXT = ' ', GIT_DIFF_LINE_CONTEXT = ' ',
GIT_DIFF_LINE_ADDITION = '+', GIT_DIFF_LINE_ADDITION = '+',
GIT_DIFF_LINE_DELETION = '-', GIT_DIFF_LINE_DELETION = '-',
GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< Removed line w/o LF & added one with */ GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< Removed line w/o LF & added one with */
GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */ GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */
/* The following values will only be sent to a `git_diff_data_fn` when /* The following values will only be sent to a `git_diff_data_cb` when
* the content of a diff is being formatted (eg. through * the content of a diff is being formatted (eg. through
* git_diff_print_patch() or git_diff_print_compact(), for instance). * git_diff_print_patch() or git_diff_print_compact(), for instance).
*/ */
@ -245,13 +246,13 @@ typedef enum {
* of text. This uses some extra GIT_DIFF_LINE_... constants for output * of text. This uses some extra GIT_DIFF_LINE_... constants for output
* of lines of file and hunk headers. * of lines of file and hunk headers.
*/ */
typedef int (*git_diff_data_fn)( typedef int (*git_diff_data_cb)(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
char line_origin, /**< GIT_DIFF_LINE_... value from above */ char line_origin, /**< GIT_DIFF_LINE_... value from above */
const char *content, const char *content,
size_t content_len); size_t content_len,
void *payload);
/** /**
* The diff patch is used to store all the text diffs for a delta. * The diff patch is used to store all the text diffs for a delta.
@ -283,6 +284,8 @@ typedef enum {
* Control behavior of rename and copy detection * Control behavior of rename and copy detection
*/ */
typedef struct { typedef struct {
unsigned int version;
/** Combination of git_diff_find_t values (default FIND_RENAMES) */ /** Combination of git_diff_find_t values (default FIND_RENAMES) */
unsigned int flags; unsigned int flags;
@ -461,7 +464,6 @@ GIT_EXTERN(int) git_diff_find_similar(
* the iteration and cause this return `GIT_EUSER`. * the iteration and cause this return `GIT_EUSER`.
* *
* @param diff A git_diff_list generated by one of the above functions. * @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callbacks.
* @param file_cb Callback function to make per file in the diff. * @param file_cb Callback function to make per file in the diff.
* @param hunk_cb Optional callback to make per hunk of text diff. This * @param hunk_cb Optional callback to make per hunk of text diff. This
* callback is called to describe a range of lines in the * callback is called to describe a range of lines in the
@ -469,14 +471,15 @@ GIT_EXTERN(int) git_diff_find_similar(
* @param line_cb Optional callback to make per line of diff text. This * @param line_cb Optional callback to make per line of diff text. This
* same callback will be made for context lines, added, and * same callback will be made for context lines, added, and
* removed lines, and even for a deleted trailing newline. * removed lines, and even for a deleted trailing newline.
* @param payload Reference pointer that will be passed to your callbacks.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_diff_foreach( GIT_EXTERN(int) git_diff_foreach(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_file_cb file_cb,
git_diff_file_fn file_cb, git_diff_hunk_cb hunk_cb,
git_diff_hunk_fn hunk_cb, git_diff_data_cb line_cb,
git_diff_data_fn line_cb); void *payload);
/** /**
* Iterate over a diff generating text output like "git diff --name-status". * Iterate over a diff generating text output like "git diff --name-status".
@ -485,14 +488,14 @@ GIT_EXTERN(int) git_diff_foreach(
* iteration and cause this return `GIT_EUSER`. * iteration and cause this return `GIT_EUSER`.
* *
* @param diff A git_diff_list generated by one of the above functions. * @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callback.
* @param print_cb Callback to make per line of diff text. * @param print_cb Callback to make per line of diff text.
* @param payload Reference pointer that will be passed to your callback.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_diff_print_compact( GIT_EXTERN(int) git_diff_print_compact(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb); void *payload);
/** /**
* Look up the single character abbreviation for a delta status code. * Look up the single character abbreviation for a delta status code.
@ -517,7 +520,7 @@ GIT_EXTERN(char) git_diff_status_char(git_delta_t status);
* iteration and cause this return `GIT_EUSER`. * iteration and cause this return `GIT_EUSER`.
* *
* @param diff A git_diff_list generated by one of the above functions. * @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callbacks. * @param payload Reference pointer that will be passed to your callbacks.
* @param print_cb Callback function to output lines of the diff. This * @param print_cb Callback function to output lines of the diff. This
* same function will be called for file headers, hunk * same function will be called for file headers, hunk
* headers, and diff lines. Fortunately, you can probably * headers, and diff lines. Fortunately, you can probably
@ -527,8 +530,8 @@ GIT_EXTERN(char) git_diff_status_char(git_delta_t status);
*/ */
GIT_EXTERN(int) git_diff_print_patch( GIT_EXTERN(int) git_diff_print_patch(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb); void *payload);
/** /**
* Query how many diff records are there in a diff list. * Query how many diff records are there in a diff list.
@ -572,15 +575,15 @@ GIT_EXTERN(size_t) git_diff_num_deltas_of_type(
* It is okay to pass NULL for either of the output parameters; if you pass * It is okay to pass NULL for either of the output parameters; if you pass
* NULL for the `git_diff_patch`, then the text diff will not be calculated. * NULL for the `git_diff_patch`, then the text diff will not be calculated.
* *
* @param patch Output parameter for the delta patch object * @param patch_out Output parameter for the delta patch object
* @param delta Output parameter for the delta object * @param delta_out Output parameter for the delta object
* @param diff Diff list object * @param diff Diff list object
* @param idx Index into diff list * @param idx Index into diff list
* @return 0 on success, other value < 0 on error * @return 0 on success, other value < 0 on error
*/ */
GIT_EXTERN(int) git_diff_get_patch( GIT_EXTERN(int) git_diff_get_patch(
git_diff_patch **patch, git_diff_patch **patch_out,
const git_diff_delta **delta, const git_diff_delta **delta_out,
git_diff_list *diff, git_diff_list *diff,
size_t idx); size_t idx);
@ -672,15 +675,15 @@ GIT_EXTERN(int) git_diff_patch_get_line_in_hunk(
* and cause this return `GIT_EUSER`. * and cause this return `GIT_EUSER`.
* *
* @param patch A git_diff_patch representing changes to one file * @param patch A git_diff_patch representing changes to one file
* @param cb_data Reference pointer that will be passed to your callbacks.
* @param print_cb Callback function to output lines of the patch. Will be * @param print_cb Callback function to output lines of the patch. Will be
* called for file headers, hunk headers, and diff lines. * called for file headers, hunk headers, and diff lines.
* @param payload Reference pointer that will be passed to your callbacks.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_diff_patch_print( GIT_EXTERN(int) git_diff_patch_print(
git_diff_patch *patch, git_diff_patch *patch,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb); void *payload);
/** /**
* Get the content of a patch as a single diff text. * Get the content of a patch as a single diff text.
@ -718,10 +721,10 @@ GIT_EXTERN(int) git_diff_blobs(
git_blob *old_blob, git_blob *old_blob,
git_blob *new_blob, git_blob *new_blob,
const git_diff_options *options, const git_diff_options *options,
void *cb_data, git_diff_file_cb file_cb,
git_diff_file_fn file_cb, git_diff_hunk_cb hunk_cb,
git_diff_hunk_fn hunk_cb, git_diff_data_cb line_cb,
git_diff_data_fn line_cb); void *payload);
GIT_END_DECL GIT_END_DECL

53
include/git2/index.h
View File

@ -119,11 +119,11 @@ enum {
* *
* The index must be freed once it's no longer in use. * The index must be freed once it's no longer in use.
* *
* @param index the pointer for the new index * @param out the pointer for the new index
* @param index_path the path to the index file in disk * @param index_path the path to the index file in disk
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_open(git_index **index, const char *index_path); GIT_EXTERN(int) git_index_open(git_index **out, const char *index_path);
/** /**
* Create an in-memory index object. * Create an in-memory index object.
@ -133,10 +133,10 @@ GIT_EXTERN(int) git_index_open(git_index **index, const char *index_path);
* *
* The index must be freed once it's no longer in use. * The index must be freed once it's no longer in use.
* *
* @param index the pointer for the new index * @param out the pointer for the new index
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_new(git_index **index); GIT_EXTERN(int) git_index_new(git_index **out);
/** /**
* Free an existing index object. * Free an existing index object.
@ -201,7 +201,7 @@ GIT_EXTERN(int) git_index_write(git_index *index);
* @param tree tree to read * @param tree tree to read
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_read_tree(git_index *index, git_tree *tree); GIT_EXTERN(int) git_index_read_tree(git_index *index, const git_tree *tree);
/** /**
* Write the index as a tree * Write the index as a tree
@ -217,12 +217,12 @@ GIT_EXTERN(int) git_index_read_tree(git_index *index, git_tree *tree);
* *
* The index must not contain any file in conflict. * The index must not contain any file in conflict.
* *
* @param oid Pointer where to store the OID of the written tree * @param out Pointer where to store the OID of the written tree
* @param index Index to write * @param index Index to write
* @return 0 on success, GIT_EUNMERGED when the index is not clean * @return 0 on success, GIT_EUNMERGED when the index is not clean
* or an error code * or an error code
*/ */
GIT_EXTERN(int) git_index_write_tree(git_oid *oid, git_index *index); GIT_EXTERN(int) git_index_write_tree(git_oid *out, git_index *index);
/** /**
* Write the index as a tree to the given repository * Write the index as a tree to the given repository
@ -233,13 +233,13 @@ GIT_EXTERN(int) git_index_write_tree(git_oid *oid, git_index *index);
* *
* The index must not contain any file in conflict. * The index must not contain any file in conflict.
* *
* @param oid Pointer where to store OID of the the written tree * @param out Pointer where to store OID of the the written tree
* @param index Index to write * @param index Index to write
* @param repo Repository where to write the tree * @param repo Repository where to write the tree
* @return 0 on success, GIT_EUNMERGED when the index is not clean * @return 0 on success, GIT_EUNMERGED when the index is not clean
* or an error code * or an error code
*/ */
GIT_EXTERN(int) git_index_write_tree_to(git_oid *oid, git_index *index, git_repository *repo); GIT_EXTERN(int) git_index_write_tree_to(git_oid *out, git_index *index, git_repository *repo);
/**@}*/ /**@}*/
@ -258,7 +258,7 @@ GIT_EXTERN(int) git_index_write_tree_to(git_oid *oid, git_index *index, git_repo
* @param index an existing index object * @param index an existing index object
* @return integer of count of current entries * @return integer of count of current entries
*/ */
GIT_EXTERN(unsigned int) git_index_entrycount(git_index *index); GIT_EXTERN(size_t) git_index_entrycount(const git_index *index);
/** /**
* Clear the contents (all the entries) of an index object. * Clear the contents (all the entries) of an index object.
@ -282,7 +282,8 @@ GIT_EXTERN(void) git_index_clear(git_index *index);
* @param n the position of the entry * @param n the position of the entry
* @return a pointer to the entry; NULL if out of bounds * @return a pointer to the entry; NULL if out of bounds
*/ */
GIT_EXTERN(git_index_entry *) git_index_get_byindex(git_index *index, size_t n); GIT_EXTERN(const git_index_entry *) git_index_get_byindex(
git_index *index, size_t n);
/** /**
* Get a pointer to one of the entries in the index * Get a pointer to one of the entries in the index
@ -298,7 +299,8 @@ GIT_EXTERN(git_index_entry *) git_index_get_byindex(git_index *index, size_t n);
* @param stage stage to search * @param stage stage to search
* @return a pointer to the entry; NULL if it was not found * @return a pointer to the entry; NULL if it was not found
*/ */
GIT_EXTERN(git_index_entry *) git_index_get_bypath(git_index *index, const char *path, int stage); GIT_EXTERN(const git_index_entry *) git_index_get_bypath(
git_index *index, const char *path, int stage);
/** /**
* Remove an entry from the index * Remove an entry from the index
@ -402,7 +404,8 @@ GIT_EXTERN(int) git_index_find(git_index *index, const char *path);
* @param their_entry the entry data for their side of the merge conflict * @param their_entry the entry data for their side of the merge conflict
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_conflict_add(git_index *index, GIT_EXTERN(int) git_index_conflict_add(
git_index *index,
const git_index_entry *ancestor_entry, const git_index_entry *ancestor_entry,
const git_index_entry *our_entry, const git_index_entry *our_entry,
const git_index_entry *their_entry); const git_index_entry *their_entry);
@ -442,7 +445,7 @@ GIT_EXTERN(void) git_index_conflict_cleanup(git_index *index);
* *
* @return 1 if at least one conflict is found, 0 otherwise. * @return 1 if at least one conflict is found, 0 otherwise.
*/ */
GIT_EXTERN(int) git_index_has_conflicts(git_index *index); GIT_EXTERN(int) git_index_has_conflicts(const git_index *index);
/**@}*/ /**@}*/
@ -475,7 +478,7 @@ GIT_EXTERN(int) git_index_reuc_find(git_index *index, const char *path);
* Get a resolve undo entry from the index. * Get a resolve undo entry from the index.
* *
* The returned entry is read-only and should not be modified * The returned entry is read-only and should not be modified
* of freed by the caller. * or freed by the caller.
* *
* @param index an existing index object * @param index an existing index object
* @param path path to search * @param path path to search
@ -487,7 +490,7 @@ GIT_EXTERN(const git_index_reuc_entry *) git_index_reuc_get_bypath(git_index *in
* Get a resolve undo entry from the index. * Get a resolve undo entry from the index.
* *
* The returned entry is read-only and should not be modified * The returned entry is read-only and should not be modified
* of freed by the caller. * or freed by the caller.
* *
* @param index an existing index object * @param index an existing index object
* @param n the position of the entry * @param n the position of the entry
@ -496,7 +499,7 @@ GIT_EXTERN(const git_index_reuc_entry *) git_index_reuc_get_bypath(git_index *in
GIT_EXTERN(const git_index_reuc_entry *) git_index_reuc_get_byindex(git_index *index, size_t n); GIT_EXTERN(const git_index_reuc_entry *) git_index_reuc_get_byindex(git_index *index, size_t n);
/** /**
* Adds an resolve undo entry for a file based on the given parameters. * Adds a resolve undo entry for a file based on the given parameters.
* *
* The resolve undo entry contains the OIDs of files that were involved * The resolve undo entry contains the OIDs of files that were involved
* in a merge conflict after the conflict has been resolved. This allows * in a merge conflict after the conflict has been resolved. This allows
@ -510,26 +513,26 @@ GIT_EXTERN(const git_index_reuc_entry *) git_index_reuc_get_byindex(git_index *i
* @param index an existing index object * @param index an existing index object
* @param path filename to add * @param path filename to add
* @param ancestor_mode mode of the ancestor file * @param ancestor_mode mode of the ancestor file
* @param ancestor_oid oid of the ancestor file * @param ancestor_id oid of the ancestor file
* @param our_mode mode of our file * @param our_mode mode of our file
* @param our_oid oid of our file * @param our_id oid of our file
* @param their_mode mode of their file * @param their_mode mode of their file
* @param their_oid oid of their file * @param their_id oid of their file
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_reuc_add(git_index *index, const char *path, GIT_EXTERN(int) git_index_reuc_add(git_index *index, const char *path,
int ancestor_mode, git_oid *ancestor_oid, int ancestor_mode, git_oid *ancestor_id,
int our_mode, git_oid *our_oid, int our_mode, git_oid *our_id,
int their_mode, git_oid *their_oid); int their_mode, git_oid *their_id);
/** /**
* Remove an resolve undo entry from the index * Remove an resolve undo entry from the index
* *
* @param index an existing index object * @param index an existing index object
* @param position position of the resolve undo entry to remove * @param n position of the resolve undo entry to remove
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_index_reuc_remove(git_index *index, int position); GIT_EXTERN(int) git_index_reuc_remove(git_index *index, size_t n);
/**@}*/ /**@}*/

8
include/git2/indexer.h
View File

@ -44,14 +44,14 @@ GIT_EXTERN(int) git_indexer_stream_new(
git_indexer_stream **out, git_indexer_stream **out,
const char *path, const char *path,
git_transfer_progress_callback progress_cb, git_transfer_progress_callback progress_cb,
void *progress_callback_payload); void *progress_cb_payload);
/** /**
* Add data to the indexer * Add data to the indexer
* *
* @param idx the indexer * @param idx the indexer
* @param data the data to add * @param data the data to add
* @param size the size of the data * @param size the size of the data in bytes
* @param stats stat storage * @param stats stat storage
*/ */
GIT_EXTERN(int) git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_transfer_progress *stats); GIT_EXTERN(int) git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_transfer_progress *stats);
@ -73,7 +73,7 @@ GIT_EXTERN(int) git_indexer_stream_finalize(git_indexer_stream *idx, git_transfe
* *
* @param idx the indexer instance * @param idx the indexer instance
*/ */
GIT_EXTERN(const git_oid *) git_indexer_stream_hash(git_indexer_stream *idx); GIT_EXTERN(const git_oid *) git_indexer_stream_hash(const git_indexer_stream *idx);
/** /**
* Free the indexer and its resources * Free the indexer and its resources
@ -120,7 +120,7 @@ GIT_EXTERN(int) git_indexer_write(git_indexer *idx);
* *
* @param idx the indexer instance * @param idx the indexer instance
*/ */
GIT_EXTERN(const git_oid *) git_indexer_hash(git_indexer *idx); GIT_EXTERN(const git_oid *) git_indexer_hash(const git_indexer *idx);
/** /**
* Free the indexer and its resources * Free the indexer and its resources

14
include/git2/merge.h
View File

@ -27,8 +27,13 @@ GIT_BEGIN_DECL
* @param repo the repository where the commits exist * @param repo the repository where the commits exist
* @param one one of the commits * @param one one of the commits
* @param two the other commit * @param two the other commit
* @return Zero on success; GIT_ENOTFOUND or -1 on failure.
*/ */
GIT_EXTERN(int) git_merge_base(git_oid *out, git_repository *repo, const git_oid *one, const git_oid *two); GIT_EXTERN(int) git_merge_base(
git_oid *out,
git_repository *repo,
const git_oid *one,
const git_oid *two);
/** /**
* Find a merge base given a list of commits * Find a merge base given a list of commits
@ -37,8 +42,13 @@ GIT_EXTERN(int) git_merge_base(git_oid *out, git_repository *repo, const git_oid
* @param repo the repository where the commits exist * @param repo the repository where the commits exist
* @param input_array oids of the commits * @param input_array oids of the commits
* @param length The number of commits in the provided `input_array` * @param length The number of commits in the provided `input_array`
* @return Zero on success; GIT_ENOTFOUND or -1 on failure.
*/ */
GIT_EXTERN(int) git_merge_base_many(git_oid *out, git_repository *repo, const git_oid input_array[], size_t length); GIT_EXTERN(int) git_merge_base_many(
git_oid *out,
git_repository *repo,
const git_oid input_array[],
size_t length);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

18
include/git2/message.h
View File

@ -23,21 +23,27 @@ GIT_BEGIN_DECL
* *
* Optionally, can remove lines starting with a "#". * Optionally, can remove lines starting with a "#".
* *
* @param message_out The user allocated buffer which will be filled with * @param out The user-allocated buffer which will be filled with the
* the cleaned up message. Pass NULL if you just want to get the size of the * cleaned up message. Pass NULL if you just want to get the needed
* prettified message as the output value. * size of the prettified message as the output value.
* *
* @param size The size of the allocated buffer message_out. * @param out_size Size of the `out` buffer in bytes.
* *
* @param message The message to be prettified. * @param message The message to be prettified.
* *
* @param strip_comments 1 to remove lines starting with a "#", 0 otherwise. * @param strip_comments Non-zero to remove lines starting with "#", 0 to
* leave them in.
* *
* @return -1 on error, else number of characters in prettified message * @return -1 on error, else number of characters in prettified message
* including the trailing NUL byte * including the trailing NUL byte
*/ */
GIT_EXTERN(int) git_message_prettify(char *message_out, size_t buffer_size, const char *message, int strip_comments); GIT_EXTERN(int) git_message_prettify(
char *out,
size_t out_size,
const char *message,
int strip_comments);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL
#endif /* INCLUDE_git_message_h__ */ #endif /* INCLUDE_git_message_h__ */

12
include/git2/net.h
View File

@ -4,8 +4,8 @@
* This file is part of libgit2, distributed under the GNU GPL v2 with * This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file. * a Linking Exception. For full terms see the included COPYING file.
*/ */
#ifndef INCLUDE_net_h__ #ifndef INCLUDE_git_net_h__
#define INCLUDE_net_h__ #define INCLUDE_git_net_h__
#include "common.h" #include "common.h"
#include "oid.h" #include "oid.h"
@ -27,8 +27,10 @@ GIT_BEGIN_DECL
* gets called. * gets called.
*/ */
#define GIT_DIR_FETCH 0 typedef enum {
#define GIT_DIR_PUSH 1 GIT_DIRECTION_FETCH = 0,
GIT_DIRECTION_PUSH = 1
} git_direction;
/** /**
@ -44,7 +46,7 @@ struct git_remote_head {
/** /**
* Callback for listing the remote heads * Callback for listing the remote heads
*/ */
typedef int (*git_headlist_cb)(git_remote_head *, void *); typedef int (*git_headlist_cb)(git_remote_head *rhead, void *payload);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

61
include/git2/notes.h
View File

@ -18,21 +18,35 @@
*/ */
GIT_BEGIN_DECL GIT_BEGIN_DECL
/**
* Callback for git_note_foreach.
*
* Receives:
* - blob_id: Oid of the blob containing the message
* - annotated_object_id: Oid of the git object being annotated
* - payload: Payload data passed to `git_note_foreach`
*/
typedef int (*git_note_foreach_cb)(
const git_oid *blob_id, const git_oid *annotated_object_id, void *payload);
/** /**
* Read the note for an object * Read the note for an object
* *
* The note must be freed manually by the user. * The note must be freed manually by the user.
* *
* @param note pointer to the read note; NULL in case of error * @param out pointer to the read note; NULL in case of error
* @param repo repository where to look up the note * @param repo repository where to look up the note
* @param notes_ref canonical name of the reference to use (optional); * @param notes_ref canonical name of the reference to use (optional); defaults to
* defaults to "refs/notes/commits" * "refs/notes/commits"
* @param oid OID of the git object to read the note from * @param oid OID of the git object to read the note from
* *
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_note_read(git_note **note, git_repository *repo, GIT_EXTERN(int) git_note_read(
const char *notes_ref, const git_oid *oid); git_note **out,
git_repository *repo,
const char *notes_ref,
const git_oid *oid);
/** /**
* Get the note message * Get the note message
@ -40,7 +54,7 @@ GIT_EXTERN(int) git_note_read(git_note **note, git_repository *repo,
* @param note * @param note
* @return the note message * @return the note message
*/ */
GIT_EXTERN(const char *) git_note_message(git_note *note); GIT_EXTERN(const char *) git_note_message(const git_note *note);
/** /**
@ -49,7 +63,7 @@ GIT_EXTERN(const char *) git_note_message(git_note *note);
* @param note * @param note
* @return the note object OID * @return the note object OID
*/ */
GIT_EXTERN(const git_oid *) git_note_oid(git_note *note); GIT_EXTERN(const git_oid *) git_note_oid(const git_note *note);
/** /**
* Add a note for an object * Add a note for an object
@ -65,9 +79,13 @@ GIT_EXTERN(const git_oid *) git_note_oid(git_note *note);
* *
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_note_create(git_oid *out, git_repository *repo, GIT_EXTERN(int) git_note_create(
git_signature *author, git_signature *committer, git_oid *out,
const char *notes_ref, const git_oid *oid, git_repository *repo,
const git_signature *author,
const git_signature *committer,
const char *notes_ref,
const git_oid *oid,
const char *note); const char *note);
@ -83,8 +101,11 @@ GIT_EXTERN(int) git_note_create(git_oid *out, git_repository *repo,
* *
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_note_remove(git_repository *repo, const char *notes_ref, GIT_EXTERN(int) git_note_remove(
git_signature *author, git_signature *committer, git_repository *repo,
const char *notes_ref,
const git_signature *author,
const git_signature *committer,
const git_oid *oid); const git_oid *oid);
/** /**
@ -104,17 +125,6 @@ GIT_EXTERN(void) git_note_free(git_note *note);
*/ */
GIT_EXTERN(int) git_note_default_ref(const char **out, git_repository *repo); GIT_EXTERN(int) git_note_default_ref(const char **out, git_repository *repo);
/**
* Basic components of a note
*
* - Oid of the blob containing the message
* - Oid of the git object being annotated
*/
typedef struct {
git_oid blob_oid;
git_oid annotated_object_oid;
} git_note_data;
/** /**
* Loop over all the notes within a specified namespace * Loop over all the notes within a specified namespace
* and issue a callback for each one. * and issue a callback for each one.
@ -134,9 +144,8 @@ typedef struct {
GIT_EXTERN(int) git_note_foreach( GIT_EXTERN(int) git_note_foreach(
git_repository *repo, git_repository *repo,
const char *notes_ref, const char *notes_ref,
int (*note_cb)(git_note_data *note_data, void *payload), git_note_foreach_cb note_cb,
void *payload void *payload);
);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

2
include/git2/object.h
View File

@ -184,7 +184,7 @@ GIT_EXTERN(size_t) git_object__size(git_otype type);
*/ */
GIT_EXTERN(int) git_object_peel( GIT_EXTERN(int) git_object_peel(
git_object **peeled, git_object **peeled,
git_object *object, const git_object *object,
git_otype target_type); git_otype target_type);
/** @} */ /** @} */

41
include/git2/odb.h
View File

@ -136,9 +136,10 @@ GIT_EXTERN(int) git_odb_read(git_odb_object **out, git_odb *db, const git_oid *i
* @param db database to search for the object in. * @param db database to search for the object in.
* @param short_id a prefix of the id of the object to read. * @param short_id a prefix of the id of the object to read.
* @param len the length of the prefix * @param len the length of the prefix
* @return 0 if the object was read; * @return
* GIT_ENOTFOUND if the object is not in the database. * - 0 if the object was read;
* GIT_EAMBIGUOUS if the prefix is ambiguous (several objects match the prefix) * - GIT_ENOTFOUND if the object is not in the database.
* - GIT_EAMBIGUOUS if the prefix is ambiguous (several objects match the prefix)
*/ */
GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, size_t len); GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, size_t len);
@ -152,15 +153,15 @@ GIT_EXTERN(int) git_odb_read_prefix(git_odb_object **out, git_odb *db, const git
* of an object, so the whole object will be read and then the * of an object, so the whole object will be read and then the
* header will be returned. * header will be returned.
* *
* @param len_p pointer where to store the length * @param len_out pointer where to store the length
* @param type_p pointer where to store the type * @param type_out pointer where to store the type
* @param db database to search for the object in. * @param db database to search for the object in.
* @param id identity of the object to read. * @param id identity of the object to read.
* @return * @return
* - 0 if the object was read; * - 0 if the object was read;
* - GIT_ENOTFOUND if the object is not in the database. * - GIT_ENOTFOUND if the object is not in the database.
*/ */
GIT_EXTERN(int) git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id); GIT_EXTERN(int) git_odb_read_header(size_t *len_out, git_otype *type_out, git_odb *db, const git_oid *id);
/** /**
* Determine if the given object can be found in the object database. * Determine if the given object can be found in the object database.
@ -183,10 +184,10 @@ GIT_EXTERN(int) git_odb_exists(git_odb *db, const git_oid *id);
* *
* @param db database to use * @param db database to use
* @param cb the callback to call for each object * @param cb the callback to call for each object
* @param data data to pass to the callback * @param payload data to pass to the callback
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_odb_foreach(git_odb *db, int (*cb)(git_oid *oid, void *data), void *data); GIT_EXTERN(int) git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload);
/** /**
* Write an object directly into the ODB * Write an object directly into the ODB
@ -199,14 +200,14 @@ GIT_EXTERN(int) git_odb_foreach(git_odb *db, int (*cb)(git_oid *oid, void *data)
* This method is provided for compatibility with custom backends * This method is provided for compatibility with custom backends
* which are not able to support streaming writes * which are not able to support streaming writes
* *
* @param oid pointer to store the OID result of the write * @param out pointer to store the OID result of the write
* @param odb object database where to store the object * @param odb object database where to store the object
* @param data buffer with the data to store * @param data buffer with the data to store
* @param len size of the buffer * @param len size of the buffer
* @param type type of the data to store * @param type type of the data to store
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_odb_write(git_oid *oid, git_odb *odb, const void *data, size_t len, git_otype type); GIT_EXTERN(int) git_odb_write(git_oid *out, git_odb *odb, const void *data, size_t len, git_otype type);
/** /**
* Open a stream to write an object into the ODB * Open a stream to write an object into the ODB
@ -229,13 +230,13 @@ GIT_EXTERN(int) git_odb_write(git_oid *oid, git_odb *odb, const void *data, size
* *
* @see git_odb_stream * @see git_odb_stream
* *
* @param stream pointer where to store the stream * @param out pointer where to store the stream
* @param db object database where the stream will write * @param db object database where the stream will write
* @param size final size of the object that will be written * @param size final size of the object that will be written
* @param type type of the object that will be written * @param type type of the object that will be written
* @return 0 if the stream was created; error code otherwise * @return 0 if the stream was created; error code otherwise
*/ */
GIT_EXTERN(int) git_odb_open_wstream(git_odb_stream **stream, git_odb *db, size_t size, git_otype type); GIT_EXTERN(int) git_odb_open_wstream(git_odb_stream **out, git_odb *db, size_t size, git_otype type);
/** /**
* Open a stream to read an object from the ODB * Open a stream to read an object from the ODB
@ -256,12 +257,12 @@ GIT_EXTERN(int) git_odb_open_wstream(git_odb_stream **stream, git_odb *db, size_
* *
* @see git_odb_stream * @see git_odb_stream
* *
* @param stream pointer where to store the stream * @param out pointer where to store the stream
* @param db object database where the stream will read from * @param db object database where the stream will read from
* @param oid oid of the object the stream will read from * @param oid oid of the object the stream will read from
* @return 0 if the stream was created; error code otherwise * @return 0 if the stream was created; error code otherwise
*/ */
GIT_EXTERN(int) git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oid); GIT_EXTERN(int) git_odb_open_rstream(git_odb_stream **out, git_odb *db, const git_oid *oid);
/** /**
* Open a stream for writing a pack file to the ODB. * Open a stream for writing a pack file to the ODB.
@ -274,14 +275,18 @@ GIT_EXTERN(int) git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const
* *
* @see git_odb_writepack * @see git_odb_writepack
* *
* @param writepack pointer to the writepack functions * @param out pointer to the writepack functions
* @param db object database where the stream will read from * @param db object database where the stream will read from
* @param progress_cb function to call with progress information. * @param progress_cb function to call with progress information.
* Be aware that this is called inline with network and indexing operations, * Be aware that this is called inline with network and indexing operations,
* so performance may be affected. * so performance may be affected.
* @param progress_payload payload for the progress callback * @param progress_payload payload for the progress callback
*/ */
GIT_EXTERN(int) git_odb_write_pack(git_odb_writepack **writepack, git_odb *db, git_transfer_progress_callback progress_cb, void *progress_payload); GIT_EXTERN(int) git_odb_write_pack(
git_odb_writepack **out,
git_odb *db,
git_transfer_progress_callback progress_cb,
void *progress_payload);
/** /**
* Determine the object-ID (sha1 hash) of a data buffer * Determine the object-ID (sha1 hash) of a data buffer
@ -289,13 +294,13 @@ GIT_EXTERN(int) git_odb_write_pack(git_odb_writepack **writepack, git_odb *db, g
* The resulting SHA-1 OID will be the identifier for the data * The resulting SHA-1 OID will be the identifier for the data
* buffer as if the data buffer it were to written to the ODB. * buffer as if the data buffer it were to written to the ODB.
* *
* @param id the resulting object-ID. * @param out the resulting object-ID.
* @param data data to hash * @param data data to hash
* @param len size of the data * @param len size of the data
* @param type of the data to hash * @param type of the data to hash
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type); GIT_EXTERN(int) git_odb_hash(git_oid *out, const void *data, size_t len, git_otype type);
/** /**
* Read a file from disk and fill a git_oid with the object id * Read a file from disk and fill a git_oid with the object id

26
include/git2/odb_backend.h
View File

@ -24,7 +24,14 @@ GIT_BEGIN_DECL
struct git_odb_stream; struct git_odb_stream;
struct git_odb_writepack; struct git_odb_writepack;
/** An instance for a custom backend */ /**
* Function type for callbacks from git_odb_foreach.
*/
typedef int (*git_odb_foreach_cb)(const git_oid *id, void *payload);
/**
* An instance for a custom backend
*/
struct git_odb_backend { struct git_odb_backend {
git_odb *odb; git_odb *odb;
@ -79,8 +86,8 @@ struct git_odb_backend {
int (* foreach)( int (* foreach)(
struct git_odb_backend *, struct git_odb_backend *,
int (*cb)(git_oid *oid, void *data), git_odb_foreach_cb cb,
void *data); void *payload);
int (* writepack)( int (* writepack)(
struct git_odb_writepack **, struct git_odb_writepack **,
@ -101,7 +108,7 @@ enum {
/** A stream to read/write from a backend */ /** A stream to read/write from a backend */
struct git_odb_stream { struct git_odb_stream {
struct git_odb_backend *backend; struct git_odb_backend *backend;
int mode; unsigned int mode;
int (*read)(struct git_odb_stream *stream, char *buffer, size_t len); int (*read)(struct git_odb_stream *stream, char *buffer, size_t len);
int (*write)(struct git_odb_stream *stream, const char *buffer, size_t len); int (*write)(struct git_odb_stream *stream, const char *buffer, size_t len);
@ -118,12 +125,15 @@ struct git_odb_writepack {
void (*free)(struct git_odb_writepack *writepack); void (*free)(struct git_odb_writepack *writepack);
}; };
GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir);
GIT_EXTERN(int) git_odb_backend_loose(git_odb_backend **backend_out, const char *objects_dir, int compression_level, int do_fsync);
GIT_EXTERN(int) git_odb_backend_one_pack(git_odb_backend **backend_out, const char *index_file);
GIT_EXTERN(void *) git_odb_backend_malloc(git_odb_backend *backend, size_t len); GIT_EXTERN(void *) git_odb_backend_malloc(git_odb_backend *backend, size_t len);
/**
* Constructors for in-box ODB backends.
*/
GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **out, const char *objects_dir);
GIT_EXTERN(int) git_odb_backend_loose(git_odb_backend **out, const char *objects_dir, int compression_level, int do_fsync);
GIT_EXTERN(int) git_odb_backend_one_pack(git_odb_backend **out, const char *index_file);
GIT_END_DECL GIT_END_DECL
#endif #endif

31
include/git2/oid.h
View File

@ -30,11 +30,10 @@ GIT_BEGIN_DECL
#define GIT_OID_MINPREFIXLEN 4 #define GIT_OID_MINPREFIXLEN 4
/** Unique identity of any object (commit, tree, blob, tag). */ /** Unique identity of any object (commit, tree, blob, tag). */
typedef struct _git_oid git_oid; typedef struct git_oid {
struct _git_oid {
/** raw binary formatted id */ /** raw binary formatted id */
unsigned char id[GIT_OID_RAWSZ]; unsigned char id[GIT_OID_RAWSZ];
}; } git_oid;
/** /**
* Parse a hex formatted object id into a git_oid. * Parse a hex formatted object id into a git_oid.
@ -71,14 +70,14 @@ GIT_EXTERN(void) git_oid_fromraw(git_oid *out, const unsigned char *raw);
/** /**
* Format a git_oid into a hex string. * Format a git_oid into a hex string.
* *
* @param str output hex string; must be pointing at the start of * @param out output hex string; must be pointing at the start of
* the hex sequence and have at least the number of bytes * the hex sequence and have at least the number of bytes
* needed for an oid encoded in hex (40 bytes). Only the * needed for an oid encoded in hex (40 bytes). Only the
* oid digits are written; a '\\0' terminator must be added * oid digits are written; a '\\0' terminator must be added
* by the caller if it is required. * by the caller if it is required.
* @param oid oid structure to format. * @param oid oid structure to format.
*/ */
GIT_EXTERN(void) git_oid_fmt(char *str, const git_oid *oid); GIT_EXTERN(void) git_oid_fmt(char *out, const git_oid *id);
/** /**
* Format a git_oid into a loose-object path string. * Format a git_oid into a loose-object path string.
@ -86,14 +85,14 @@ GIT_EXTERN(void) git_oid_fmt(char *str, const git_oid *oid);
* The resulting string is "aa/...", where "aa" is the first two * The resulting string is "aa/...", where "aa" is the first two
* hex digits of the oid and "..." is the remaining 38 digits. * hex digits of the oid and "..." is the remaining 38 digits.
* *
* @param str output hex string; must be pointing at the start of * @param out output hex string; must be pointing at the start of
* the hex sequence and have at least the number of bytes * the hex sequence and have at least the number of bytes
* needed for an oid encoded in hex (41 bytes). Only the * needed for an oid encoded in hex (41 bytes). Only the
* oid digits are written; a '\\0' terminator must be added * oid digits are written; a '\\0' terminator must be added
* by the caller if it is required. * by the caller if it is required.
* @param oid oid structure to format. * @param id oid structure to format.
*/ */
GIT_EXTERN(void) git_oid_pathfmt(char *str, const git_oid *oid); GIT_EXTERN(void) git_oid_pathfmt(char *out, const git_oid *id);
/** /**
* Format a git_oid into a newly allocated c-string. * Format a git_oid into a newly allocated c-string.
@ -102,7 +101,7 @@ GIT_EXTERN(void) git_oid_pathfmt(char *str, const git_oid *oid);
* @return the c-string; NULL if memory is exhausted. Caller must * @return the c-string; NULL if memory is exhausted. Caller must
* deallocate the string with git__free(). * deallocate the string with git__free().
*/ */
GIT_EXTERN(char *) git_oid_allocfmt(const git_oid *oid); GIT_EXTERN(char *) git_oid_allocfmt(const git_oid *id);
/** /**
* Format a git_oid into a buffer as a hex format c-string. * Format a git_oid into a buffer as a hex format c-string.
@ -115,11 +114,11 @@ GIT_EXTERN(char *) git_oid_allocfmt(const git_oid *oid);
* *
* @param out the buffer into which the oid string is output. * @param out the buffer into which the oid string is output.
* @param n the size of the out buffer. * @param n the size of the out buffer.
* @param oid the oid structure to format. * @param id the oid structure to format.
* @return the out buffer pointer, assuming no input parameter * @return the out buffer pointer, assuming no input parameter
* errors, otherwise a pointer to an empty string. * errors, otherwise a pointer to an empty string.
*/ */
GIT_EXTERN(char *) git_oid_tostr(char *out, size_t n, const git_oid *oid); GIT_EXTERN(char *) git_oid_tostr(char *out, size_t n, const git_oid *id);
/** /**
* Copy an oid from one structure to another. * Copy an oid from one structure to another.
@ -176,19 +175,19 @@ GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, size_t len);
/** /**
* Check if an oid equals an hex formatted object id. * Check if an oid equals an hex formatted object id.
* *
* @param a oid structure. * @param id oid structure.
* @param str input hex string of an object id. * @param str input hex string of an object id.
* @return GIT_ENOTOID if str is not a valid hex string, * @return GIT_ENOTOID if str is not a valid hex string,
* 0 in case of a match, GIT_ERROR otherwise. * 0 in case of a match, GIT_ERROR otherwise.
*/ */
GIT_EXTERN(int) git_oid_streq(const git_oid *a, const char *str); GIT_EXTERN(int) git_oid_streq(const git_oid *id, const char *str);
/** /**
* Check is an oid is all zeros. * Check is an oid is all zeros.
* *
* @return 1 if all zeros, 0 otherwise. * @return 1 if all zeros, 0 otherwise.
*/ */
GIT_EXTERN(int) git_oid_iszero(const git_oid *a); GIT_EXTERN(int) git_oid_iszero(const git_oid *id);
/** /**
* OID Shortener object * OID Shortener object
@ -230,12 +229,12 @@ GIT_EXTERN(git_oid_shorten *) git_oid_shorten_new(size_t min_length);
* GIT_ENOMEM error * GIT_ENOMEM error
* *
* @param os a `git_oid_shorten` instance * @param os a `git_oid_shorten` instance
* @param text_oid an OID in text form * @param text_id an OID in text form
* @return the minimal length to uniquely identify all OIDs * @return the minimal length to uniquely identify all OIDs
* added so far to the set; or an error code (<0) if an * added so far to the set; or an error code (<0) if an
* error occurs. * error occurs.
*/ */
GIT_EXTERN(int) git_oid_shorten_add(git_oid_shorten *os, const char *text_oid); GIT_EXTERN(int) git_oid_shorten_add(git_oid_shorten *os, const char *text_id);
/** /**
* Free an OID shortener instance * Free an OID shortener instance

20
include/git2/pack.h
View File

@ -38,8 +38,9 @@ GIT_EXTERN(int) git_packbuilder_new(git_packbuilder **out, git_repository *repo)
* *
* @param pb The packbuilder * @param pb The packbuilder
* @param n Number of threads to spawn * @param n Number of threads to spawn
* @return number of actual threads to be used
*/ */
GIT_EXTERN(void) git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n); GIT_EXTERN(unsigned int) git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n);
/** /**
* Insert a single object * Insert a single object
@ -48,12 +49,12 @@ GIT_EXTERN(void) git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n
* commits followed by trees and blobs. * commits followed by trees and blobs.
* *
* @param pb The packbuilder * @param pb The packbuilder
* @param oid The oid of the commit * @param id The oid of the commit
* @param oid The name; might be NULL * @param name The name; might be NULL
* *
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid, const char *name); GIT_EXTERN(int) git_packbuilder_insert(git_packbuilder *pb, const git_oid *id, const char *name);
/** /**
* Insert a root tree object * Insert a root tree object
@ -61,11 +62,11 @@ GIT_EXTERN(int) git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
* This will add the tree as well as all referenced trees and blobs. * This will add the tree as well as all referenced trees and blobs.
* *
* @param pb The packbuilder * @param pb The packbuilder
* @param oid The oid of the root tree * @param id The oid of the root tree
* *
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid); GIT_EXTERN(int) git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *id);
/** /**
* Write the new pack and the corresponding index to path * Write the new pack and the corresponding index to path
@ -82,15 +83,17 @@ GIT_EXTERN(int) git_packbuilder_write(git_packbuilder *pb, const char *file);
* *
* @param pb the packbuilder * @param pb the packbuilder
* @param cb the callback to call with each packed object's buffer * @param cb the callback to call with each packed object's buffer
* @param data the callback's data * @param payload the callback's data
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *data), void *data); typedef int (*git_packbuilder_foreach_cb)(void *buf, size_t size, void *payload);
GIT_EXTERN(int) git_packbuilder_foreach(git_packbuilder *pb, git_packbuilder_foreach_cb cb, void *payload);
/** /**
* Get the total number of objects the packbuilder will write out * Get the total number of objects the packbuilder will write out
* *
* @param pb the packbuilder * @param pb the packbuilder
* @return
*/ */
GIT_EXTERN(uint32_t) git_packbuilder_object_count(git_packbuilder *pb); GIT_EXTERN(uint32_t) git_packbuilder_object_count(git_packbuilder *pb);
@ -98,6 +101,7 @@ GIT_EXTERN(uint32_t) git_packbuilder_object_count(git_packbuilder *pb);
* Get the number of objects the packbuilder has already written out * Get the number of objects the packbuilder has already written out
* *
* @param pb the packbuilder * @param pb the packbuilder
* @return
*/ */
GIT_EXTERN(uint32_t) git_packbuilder_written(git_packbuilder *pb); GIT_EXTERN(uint32_t) git_packbuilder_written(git_packbuilder *pb);

24
include/git2/reflog.h
View File

@ -30,11 +30,11 @@ GIT_BEGIN_DECL
* The reflog must be freed manually by using * The reflog must be freed manually by using
* git_reflog_free(). * git_reflog_free().
* *
* @param reflog pointer to reflog * @param out pointer to reflog
* @param ref reference to read the reflog for * @param ref reference to read the reflog for
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_reflog_read(git_reflog **reflog, git_reference *ref); GIT_EXTERN(int) git_reflog_read(git_reflog **out, const git_reference *ref);
/** /**
* Write an existing in-memory reflog object back to disk * Write an existing in-memory reflog object back to disk
@ -51,12 +51,12 @@ GIT_EXTERN(int) git_reflog_write(git_reflog *reflog);
* `msg` is optional and can be NULL. * `msg` is optional and can be NULL.
* *
* @param reflog an existing reflog object * @param reflog an existing reflog object
* @param new_oid the OID the reference is now pointing to * @param id the OID the reference is now pointing to
* @param committer the signature of the committer * @param committer the signature of the committer
* @param msg the reflog message * @param msg the reflog message
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg); GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *id, const git_signature *committer, const char *msg);
/** /**
* Rename the reflog for the given reference * Rename the reflog for the given reference
@ -64,10 +64,10 @@ GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *new_oid, co
* The reflog to be renamed is expected to already exist * The reflog to be renamed is expected to already exist
* *
* @param ref the reference * @param ref the reference
* @param new_name the new name of the reference * @param name the new name of the reference
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_reflog_rename(git_reference *ref, const char *new_name); GIT_EXTERN(int) git_reflog_rename(git_reference *ref, const char *name);
/** /**
* Delete the reflog for the given reference * Delete the reflog for the given reference
@ -83,7 +83,7 @@ GIT_EXTERN(int) git_reflog_delete(git_reference *ref);
* @param reflog the previously loaded reflog * @param reflog the previously loaded reflog
* @return the number of log entries * @return the number of log entries
*/ */
GIT_EXTERN(unsigned int) git_reflog_entrycount(git_reflog *reflog); GIT_EXTERN(size_t) git_reflog_entrycount(git_reflog *reflog);
/** /**
* Lookup an entry by its index * Lookup an entry by its index
@ -126,7 +126,7 @@ GIT_EXTERN(int) git_reflog_drop(
* @param entry a reflog entry * @param entry a reflog entry
* @return the old oid * @return the old oid
*/ */
GIT_EXTERN(const git_oid *) git_reflog_entry_oidold(const git_reflog_entry *entry); GIT_EXTERN(const git_oid *) git_reflog_entry_id_old(const git_reflog_entry *entry);
/** /**
* Get the new oid * Get the new oid
@ -134,7 +134,7 @@ GIT_EXTERN(const git_oid *) git_reflog_entry_oidold(const git_reflog_entry *entr
* @param entry a reflog entry * @param entry a reflog entry
* @return the new oid at this time * @return the new oid at this time
*/ */
GIT_EXTERN(const git_oid *) git_reflog_entry_oidnew(const git_reflog_entry *entry); GIT_EXTERN(const git_oid *) git_reflog_entry_id_new(const git_reflog_entry *entry);
/** /**
* Get the committer of this entry * Get the committer of this entry
@ -142,15 +142,15 @@ GIT_EXTERN(const git_oid *) git_reflog_entry_oidnew(const git_reflog_entry *entr
* @param entry a reflog entry * @param entry a reflog entry
* @return the committer * @return the committer
*/ */
GIT_EXTERN(git_signature *) git_reflog_entry_committer(const git_reflog_entry *entry); GIT_EXTERN(const git_signature *) git_reflog_entry_committer(const git_reflog_entry *entry);
/** /**
* Get the log msg * Get the log message
* *
* @param entry a reflog entry * @param entry a reflog entry
* @return the log msg * @return the log msg
*/ */
GIT_EXTERN(char *) git_reflog_entry_msg(const git_reflog_entry *entry); GIT_EXTERN(const char *) git_reflog_entry_message(const git_reflog_entry *entry);
/** /**
* Free the reflog * Free the reflog

57
include/git2/refs.h
View File

@ -29,12 +29,12 @@ GIT_BEGIN_DECL
* See `git_reference_create_symbolic()` for documentation about valid * See `git_reference_create_symbolic()` for documentation about valid
* reference names. * reference names.
* *
* @param reference_out pointer to the looked-up reference * @param out pointer to the looked-up reference
* @param repo the repository to look up the reference * @param repo the repository to look up the reference
* @param name the long name for the reference (e.g. HEAD, refs/heads/master, refs/tags/v0.1.0, ...) * @param name the long name for the reference (e.g. HEAD, refs/heads/master, refs/tags/v0.1.0, ...)
* @return 0 or an error code * @return 0 or an error code (ENOTFOUND, EINVALIDSPEC)
*/ */
GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_repository *repo, const char *name); GIT_EXTERN(int) git_reference_lookup(git_reference **out, git_repository *repo, const char *name);
/** /**
* Lookup a reference by name and resolve immediately to OID. * Lookup a reference by name and resolve immediately to OID.
@ -43,12 +43,13 @@ GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_reposito
* through to the object id that it refers to. This avoids having to * through to the object id that it refers to. This avoids having to
* allocate or free any `git_reference` objects for simple situations. * allocate or free any `git_reference` objects for simple situations.
* *
* @param oid Pointer to oid to be filled in * @param out Pointer to oid to be filled in
* @param repo The repository in which to look up the reference * @param repo The repository in which to look up the reference
* @param name The long name for the reference * @param name The long name for the reference
* @return 0 on success, -1 if name could not be resolved * @return 0 on success, -1 if name could not be resolved (EINVALIDSPEC,
* ENOTFOUND, etc)
*/ */
GIT_EXTERN(int) git_reference_name_to_oid( GIT_EXTERN(int) git_reference_name_to_id(
git_oid *out, git_repository *repo, const char *name); git_oid *out, git_repository *repo, const char *name);
/** /**
@ -73,14 +74,14 @@ GIT_EXTERN(int) git_reference_name_to_oid(
* This function will return an error if a reference already exists with the * This function will return an error if a reference already exists with the
* given name unless `force` is true, in which case it will be overwritten. * given name unless `force` is true, in which case it will be overwritten.
* *
* @param ref_out Pointer to the newly created reference * @param out Pointer to the newly created reference
* @param repo Repository where that reference will live * @param repo Repository where that reference will live
* @param name The name of the reference * @param name The name of the reference
* @param target The target of the reference * @param target The target of the reference
* @param force Overwrite existing references * @param force Overwrite existing references
* @return 0 or an error code * @return 0 or an error code (EEXISTS, EINVALIDSPEC)
*/ */
GIT_EXTERN(int) git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target, int force); GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repository *repo, const char *name, const char *target, int force);
/** /**
* Create a new direct reference. * Create a new direct reference.
@ -105,14 +106,14 @@ GIT_EXTERN(int) git_reference_create_symbolic(git_reference **ref_out, git_repos
* This function will return an error if a reference already exists with the * This function will return an error if a reference already exists with the
* given name unless `force` is true, in which case it will be overwritten. * given name unless `force` is true, in which case it will be overwritten.
* *
* @param ref_out Pointer to the newly created reference * @param out Pointer to the newly created reference
* @param repo Repository where that reference will live * @param repo Repository where that reference will live
* @param name The name of the reference * @param name The name of the reference
* @param id The object id pointed to by the reference. * @param id The object id pointed to by the reference.
* @param force Overwrite existing references * @param force Overwrite existing references
* @return 0 or an error code * @return 0 or an error code (EINVALIDSPEC, EEXISTS)
*/ */
GIT_EXTERN(int) git_reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id, int force); GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force);
/** /**
* Get the OID pointed to by a direct reference. * Get the OID pointed to by a direct reference.
@ -127,7 +128,7 @@ GIT_EXTERN(int) git_reference_create_oid(git_reference **ref_out, git_repository
* @param ref The reference * @param ref The reference
* @return a pointer to the oid if available, NULL otherwise * @return a pointer to the oid if available, NULL otherwise
*/ */
GIT_EXTERN(const git_oid *) git_reference_oid(git_reference *ref); GIT_EXTERN(const git_oid *) git_reference_target(const git_reference *ref);
/** /**
* Get full name to the reference pointed to by a symbolic reference. * Get full name to the reference pointed to by a symbolic reference.
@ -137,7 +138,7 @@ GIT_EXTERN(const git_oid *) git_reference_oid(git_reference *ref);
* @param ref The reference * @param ref The reference
* @return a pointer to the name if available, NULL otherwise * @return a pointer to the name if available, NULL otherwise
*/ */
GIT_EXTERN(const char *) git_reference_target(git_reference *ref); GIT_EXTERN(const char *) git_reference_symbolic_target(const git_reference *ref);
/** /**
* Get the type of a reference. * Get the type of a reference.
@ -147,7 +148,7 @@ GIT_EXTERN(const char *) git_reference_target(git_reference *ref);
* @param ref The reference * @param ref The reference
* @return the type * @return the type
*/ */
GIT_EXTERN(git_ref_t) git_reference_type(git_reference *ref); GIT_EXTERN(git_ref_t) git_reference_type(const git_reference *ref);
/** /**
* Get the full name of a reference. * Get the full name of a reference.
@ -157,7 +158,7 @@ GIT_EXTERN(git_ref_t) git_reference_type(git_reference *ref);
* @param ref The reference * @param ref The reference
* @return the full name for the ref * @return the full name for the ref
*/ */
GIT_EXTERN(const char *) git_reference_name(git_reference *ref); GIT_EXTERN(const char *) git_reference_name(const git_reference *ref);
/** /**
* Resolve a symbolic reference to a direct reference. * Resolve a symbolic reference to a direct reference.
@ -175,7 +176,7 @@ GIT_EXTERN(const char *) git_reference_name(git_reference *ref);
* @param ref The reference * @param ref The reference
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_reference_resolve(git_reference **resolved_ref, git_reference *ref); GIT_EXTERN(int) git_reference_resolve(git_reference **out, const git_reference *ref);
/** /**
* Get the repository where a reference resides. * Get the repository where a reference resides.
@ -183,7 +184,7 @@ GIT_EXTERN(int) git_reference_resolve(git_reference **resolved_ref, git_referenc
* @param ref The reference * @param ref The reference
* @return a pointer to the repo * @return a pointer to the repo
*/ */
GIT_EXTERN(git_repository *) git_reference_owner(git_reference *ref); GIT_EXTERN(git_repository *) git_reference_owner(const git_reference *ref);
/** /**
* Set the symbolic target of a reference. * Set the symbolic target of a reference.
@ -194,9 +195,9 @@ GIT_EXTERN(git_repository *) git_reference_owner(git_reference *ref);
* *
* @param ref The reference * @param ref The reference
* @param target The new target for the reference * @param target The new target for the reference
* @return 0 or an error code * @return 0 or an error code (EINVALIDSPEC)
*/ */
GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const char *target); GIT_EXTERN(int) git_reference_symbolic_set_target(git_reference *ref, const char *target);
/** /**
* Set the OID target of a reference. * Set the OID target of a reference.
@ -209,7 +210,7 @@ GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const char *target)
* @param id The new target OID for the reference * @param id The new target OID for the reference
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_reference_set_oid(git_reference *ref, const git_oid *id); GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const git_oid *id);
/** /**
* Rename an existing reference. * Rename an existing reference.
@ -231,12 +232,12 @@ GIT_EXTERN(int) git_reference_set_oid(git_reference *ref, const git_oid *id);
* the reflog if it exists. * the reflog if it exists.
* *
* @param ref The reference to rename * @param ref The reference to rename
* @param new_name The new name for the reference * @param name The new name for the reference
* @param force Overwrite an existing reference * @param force Overwrite an existing reference
* @return 0 or an error code * @return 0 or an error code (EINVALIDSPEC, EEXISTS)
* *
*/ */
GIT_EXTERN(int) git_reference_rename(git_reference *ref, const char *new_name, int force); GIT_EXTERN(int) git_reference_rename(git_reference *ref, const char *name, int force);
/** /**
* Delete an existing reference. * Delete an existing reference.
@ -287,6 +288,8 @@ GIT_EXTERN(int) git_reference_packall(git_repository *repo);
*/ */
GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, unsigned int list_flags); GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, unsigned int list_flags);
typedef int (*git_reference_foreach_cb)(const char *refname, void *payload);
/** /**
* Perform a callback on each reference in the repository. * Perform a callback on each reference in the repository.
* *
@ -307,7 +310,11 @@ GIT_EXTERN(int) git_reference_list(git_strarray *array, git_repository *repo, un
* @param payload Additional data to pass to the callback * @param payload Additional data to pass to the callback
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
GIT_EXTERN(int) git_reference_foreach(git_repository *repo, unsigned int list_flags, int (*callback)(const char *, void *), void *payload); GIT_EXTERN(int) git_reference_foreach(
git_repository *repo,
unsigned int list_flags,
git_reference_foreach_cb callback,
void *payload);
/** /**
* Check if a reference has been loaded from a packfile. * Check if a reference has been loaded from a packfile.

33
include/git2/remote.h
View File

@ -24,6 +24,7 @@
*/ */
GIT_BEGIN_DECL GIT_BEGIN_DECL
typedef int (*git_remote_rename_problem_cb)(const char *problematic_refspec, void *payload);
/* /*
* TODO: This functions still need to be implemented: * TODO: This functions still need to be implemented:
* - _listcb/_foreach * - _listcb/_foreach
@ -71,7 +72,7 @@ GIT_EXTERN(int) git_remote_save(const git_remote *remote);
* @param remote the remote * @param remote the remote
* @return a pointer to the name * @return a pointer to the name
*/ */
GIT_EXTERN(const char *) git_remote_name(git_remote *remote); GIT_EXTERN(const char *) git_remote_name(const git_remote *remote);
/** /**
* Get the remote's url * Get the remote's url
@ -79,7 +80,7 @@ GIT_EXTERN(const char *) git_remote_name(git_remote *remote);
* @param remote the remote * @param remote the remote
* @return a pointer to the url * @return a pointer to the url
*/ */
GIT_EXTERN(const char *) git_remote_url(git_remote *remote); GIT_EXTERN(const char *) git_remote_url(const git_remote *remote);
/** /**
* Get the remote's url for pushing * Get the remote's url for pushing
@ -87,7 +88,7 @@ GIT_EXTERN(const char *) git_remote_url(git_remote *remote);
* @param remote the remote * @param remote the remote
* @return a pointer to the url or NULL if no special url for pushing is set * @return a pointer to the url or NULL if no special url for pushing is set
*/ */
GIT_EXTERN(const char *) git_remote_pushurl(git_remote *remote); GIT_EXTERN(const char *) git_remote_pushurl(const git_remote *remote);
/** /**
* Set the remote's url * Set the remote's url
@ -126,7 +127,7 @@ GIT_EXTERN(int) git_remote_set_fetchspec(git_remote *remote, const char *spec);
* @param remote the remote * @param remote the remote
* @return a pointer to the fetch refspec or NULL if it doesn't exist * @return a pointer to the fetch refspec or NULL if it doesn't exist
*/ */
GIT_EXTERN(const git_refspec *) git_remote_fetchspec(git_remote *remote); GIT_EXTERN(const git_refspec *) git_remote_fetchspec(const git_remote *remote);
/** /**
* Set the remote's push refspec * Set the remote's push refspec
@ -144,7 +145,7 @@ GIT_EXTERN(int) git_remote_set_pushspec(git_remote *remote, const char *spec);
* @return a pointer to the push refspec or NULL if it doesn't exist * @return a pointer to the push refspec or NULL if it doesn't exist
*/ */
GIT_EXTERN(const git_refspec *) git_remote_pushspec(git_remote *remote); GIT_EXTERN(const git_refspec *) git_remote_pushspec(const git_remote *remote);
/** /**
* Open a connection to a remote * Open a connection to a remote
@ -157,7 +158,7 @@ GIT_EXTERN(const git_refspec *) git_remote_pushspec(git_remote *remote);
* @param direction whether you want to receive or send data * @param direction whether you want to receive or send data
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_remote_connect(git_remote *remote, int direction); GIT_EXTERN(int) git_remote_connect(git_remote *remote, git_direction direction);
/** /**
* Get a list of refs at the remote * Get a list of refs at the remote
@ -194,7 +195,7 @@ GIT_EXTERN(int) git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void
GIT_EXTERN(int) git_remote_download( GIT_EXTERN(int) git_remote_download(
git_remote *remote, git_remote *remote,
git_transfer_progress_callback progress_cb, git_transfer_progress_callback progress_cb,
void *progress_payload); void *payload);
/** /**
* Check whether the remote is connected * Check whether the remote is connected
@ -266,11 +267,11 @@ GIT_EXTERN(int) git_remote_supported_url(const char* url);
* *
* The string array must be freed by the user. * The string array must be freed by the user.
* *
* @param remotes_list a string array with the names of the remotes * @param out a string array which receives the names of the remotes
* @param repo the repository to query * @param repo the repository to query
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_remote_list(git_strarray *remotes_list, git_repository *repo); GIT_EXTERN(int) git_remote_list(git_strarray *out, git_repository *repo);
/** /**
* Add a remote with the default fetch refspec to the repository's configuration * Add a remote with the default fetch refspec to the repository's configuration
@ -340,7 +341,7 @@ struct git_remote_callbacks {
void (*progress)(const char *str, int len, void *data); void (*progress)(const char *str, int len, void *data);
int (*completion)(git_remote_completion_type type, void *data); int (*completion)(git_remote_completion_type type, void *data);
int (*update_tips)(const char *refname, const git_oid *a, const git_oid *b, void *data); int (*update_tips)(const char *refname, const git_oid *a, const git_oid *b, void *data);
void *data; void *payload;
}; };
/** /**
@ -359,12 +360,12 @@ GIT_EXTERN(void) git_remote_set_callbacks(git_remote *remote, git_remote_callbac
*/ */
GIT_EXTERN(const git_transfer_progress *) git_remote_stats(git_remote *remote); GIT_EXTERN(const git_transfer_progress *) git_remote_stats(git_remote *remote);
enum { typedef enum {
GIT_REMOTE_DOWNLOAD_TAGS_UNSET, GIT_REMOTE_DOWNLOAD_TAGS_UNSET,
GIT_REMOTE_DOWNLOAD_TAGS_NONE, GIT_REMOTE_DOWNLOAD_TAGS_NONE,
GIT_REMOTE_DOWNLOAD_TAGS_AUTO, GIT_REMOTE_DOWNLOAD_TAGS_AUTO,
GIT_REMOTE_DOWNLOAD_TAGS_ALL GIT_REMOTE_DOWNLOAD_TAGS_ALL
}; } git_remote_autotag_option_t;
/** /**
* Retrieve the tag auto-follow setting * Retrieve the tag auto-follow setting
@ -372,7 +373,7 @@ enum {
* @param remote the remote to query * @param remote the remote to query
* @return the auto-follow setting * @return the auto-follow setting
*/ */
GIT_EXTERN(int) git_remote_autotag(git_remote *remote); GIT_EXTERN(git_remote_autotag_option_t) git_remote_autotag(git_remote *remote);
/** /**
* Set the tag auto-follow setting * Set the tag auto-follow setting
@ -380,7 +381,9 @@ GIT_EXTERN(int) git_remote_autotag(git_remote *remote);
* @param remote the remote to configure * @param remote the remote to configure
* @param value a GIT_REMOTE_DOWNLOAD_TAGS value * @param value a GIT_REMOTE_DOWNLOAD_TAGS value
*/ */
GIT_EXTERN(void) git_remote_set_autotag(git_remote *remote, int value); GIT_EXTERN(void) git_remote_set_autotag(
git_remote *remote,
git_remote_autotag_option_t value);
/** /**
* Give the remote a new name * Give the remote a new name
@ -398,7 +401,7 @@ GIT_EXTERN(void) git_remote_set_autotag(git_remote *remote, int value);
GIT_EXTERN(int) git_remote_rename( GIT_EXTERN(int) git_remote_rename(
git_remote *remote, git_remote *remote,
const char *new_name, const char *new_name,
int (*callback)(const char *problematic_refspec, void *payload), git_remote_rename_problem_cb callback,
void *payload); void *payload);
/** /**

58
include/git2/repository.h
View File

@ -29,11 +29,11 @@ GIT_BEGIN_DECL
* The method will automatically detect if 'path' is a normal * The method will automatically detect if 'path' is a normal
* or bare repository or fail is 'path' is neither. * or bare repository or fail is 'path' is neither.
* *
* @param repository pointer to the repo which will be opened * @param out pointer to the repo which will be opened
* @param path the path to the repository * @param path the path to the repository
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *path); GIT_EXTERN(int) git_repository_open(git_repository **out, const char *path);
/** /**
* Create a "fake" repository to wrap an object database * Create a "fake" repository to wrap an object database
@ -42,11 +42,11 @@ GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *pat
* with the API when all you have is an object database. This doesn't * with the API when all you have is an object database. This doesn't
* have any paths associated with it, so use with care. * have any paths associated with it, so use with care.
* *
* @param repository pointer to the repo * @param out pointer to the repo
* @param odb the object database to wrap * @param odb the object database to wrap
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_repository_wrap_odb(git_repository **repository, git_odb *odb); GIT_EXTERN(int) git_repository_wrap_odb(git_repository **out, git_odb *odb);
/** /**
* Look for a git repository and copy its path in the given buffer. * Look for a git repository and copy its path in the given buffer.
@ -58,10 +58,10 @@ GIT_EXTERN(int) git_repository_wrap_odb(git_repository **repository, git_odb *od
* The method will automatically detect if the repository is bare * The method will automatically detect if the repository is bare
* (if there is a repository). * (if there is a repository).
* *
* @param repository_path The user allocated buffer which will * @param path_out The user allocated buffer which will
* contain the found path. * contain the found path.
* *
* @param size repository_path size * @param path_size repository_path size
* *
* @param start_path The base path where the lookup starts. * @param start_path The base path where the lookup starts.
* *
@ -77,8 +77,8 @@ GIT_EXTERN(int) git_repository_wrap_odb(git_repository **repository, git_odb *od
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_repository_discover( GIT_EXTERN(int) git_repository_discover(
char *repository_path, char *path_out,
size_t size, size_t path_size,
const char *start_path, const char *start_path,
int across_fs, int across_fs,
const char *ceiling_dirs); const char *ceiling_dirs);
@ -95,18 +95,18 @@ GIT_EXTERN(int) git_repository_discover(
* directory "/home/user/source/" will not return "/.git/" as the found * directory "/home/user/source/" will not return "/.git/" as the found
* repo if "/" is a different filesystem than "/home".) * repo if "/" is a different filesystem than "/home".)
*/ */
enum { typedef enum {
GIT_REPOSITORY_OPEN_NO_SEARCH = (1 << 0), GIT_REPOSITORY_OPEN_NO_SEARCH = (1 << 0),
GIT_REPOSITORY_OPEN_CROSS_FS = (1 << 1), GIT_REPOSITORY_OPEN_CROSS_FS = (1 << 1),
}; } git_repository_open_flag_t;
/** /**
* Find and open a repository with extended controls. * Find and open a repository with extended controls.
* *
* @param repo_out Pointer to the repo which will be opened. This can * @param out Pointer to the repo which will be opened. This can
* actually be NULL if you only want to use the error code to * actually be NULL if you only want to use the error code to
* see if a repo at this path could be opened. * see if a repo at this path could be opened.
* @param start_path Path to open as git repository. If the flags * @param path Path to open as git repository. If the flags
* permit "searching", then this can be a path to a subdirectory * permit "searching", then this can be a path to a subdirectory
* inside the working directory of the repository. * inside the working directory of the repository.
* @param flags A combination of the GIT_REPOSITORY_OPEN flags above. * @param flags A combination of the GIT_REPOSITORY_OPEN flags above.
@ -118,9 +118,9 @@ enum {
* (such as repo corruption or system errors). * (such as repo corruption or system errors).
*/ */
GIT_EXTERN(int) git_repository_open_ext( GIT_EXTERN(int) git_repository_open_ext(
git_repository **repo, git_repository **out,
const char *start_path, const char *path,
uint32_t flags, unsigned int flags,
const char *ceiling_dirs); const char *ceiling_dirs);
/** /**
@ -142,7 +142,7 @@ GIT_EXTERN(void) git_repository_free(git_repository *repo);
* TODO: * TODO:
* - Reinit the repository * - Reinit the repository
* *
* @param repo_out pointer to the repo which will be created or reinitialized * @param out pointer to the repo which will be created or reinitialized
* @param path the path to the repository * @param path the path to the repository
* @param is_bare if true, a Git repository without a working directory is * @param is_bare if true, a Git repository without a working directory is
* created at the pointed path. If false, provided path will be * created at the pointed path. If false, provided path will be
@ -152,7 +152,7 @@ GIT_EXTERN(void) git_repository_free(git_repository *repo);
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_repository_init( GIT_EXTERN(int) git_repository_init(
git_repository **repo_out, git_repository **out,
const char *path, const char *path,
unsigned is_bare); unsigned is_bare);
@ -182,14 +182,14 @@ GIT_EXTERN(int) git_repository_init(
* `init.templatedir` global config if not, or falling back on * `init.templatedir` global config if not, or falling back on
* "/usr/share/git-core/templates" if it exists. * "/usr/share/git-core/templates" if it exists.
*/ */
enum { typedef enum {
GIT_REPOSITORY_INIT_BARE = (1u << 0), GIT_REPOSITORY_INIT_BARE = (1u << 0),
GIT_REPOSITORY_INIT_NO_REINIT = (1u << 1), GIT_REPOSITORY_INIT_NO_REINIT = (1u << 1),
GIT_REPOSITORY_INIT_NO_DOTGIT_DIR = (1u << 2), GIT_REPOSITORY_INIT_NO_DOTGIT_DIR = (1u << 2),
GIT_REPOSITORY_INIT_MKDIR = (1u << 3), GIT_REPOSITORY_INIT_MKDIR = (1u << 3),
GIT_REPOSITORY_INIT_MKPATH = (1u << 4), GIT_REPOSITORY_INIT_MKPATH = (1u << 4),
GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE = (1u << 5), GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE = (1u << 5),
}; } git_repository_init_flag_t;
/** /**
* Mode options for `git_repository_init_ext`. * Mode options for `git_repository_init_ext`.
@ -204,11 +204,11 @@ enum {
* * SHARED_ALL - Use "--shared=all" behavior, adding world readability. * * SHARED_ALL - Use "--shared=all" behavior, adding world readability.
* * Anything else - Set to custom value. * * Anything else - Set to custom value.
*/ */
enum { typedef enum {
GIT_REPOSITORY_INIT_SHARED_UMASK = 0, GIT_REPOSITORY_INIT_SHARED_UMASK = 0,
GIT_REPOSITORY_INIT_SHARED_GROUP = 0002775, GIT_REPOSITORY_INIT_SHARED_GROUP = 0002775,
GIT_REPOSITORY_INIT_SHARED_ALL = 0002777, GIT_REPOSITORY_INIT_SHARED_ALL = 0002777,
}; } git_repository_init_mode_t;
/** /**
* Extended options structure for `git_repository_init_ext`. * Extended options structure for `git_repository_init_ext`.
@ -256,26 +256,30 @@ typedef struct {
* auto-detect the case sensitivity of the file system and if the * auto-detect the case sensitivity of the file system and if the
* file system supports file mode bits correctly. * file system supports file mode bits correctly.
* *
* @param repo_out Pointer to the repo which will be created or reinitialized. * @param out Pointer to the repo which will be created or reinitialized.
* @param repo_path The path to the repository. * @param repo_path The path to the repository.
* @param opts Pointer to git_repository_init_options struct. * @param opts Pointer to git_repository_init_options struct.
* @return 0 or an error code on failure. * @return 0 or an error code on failure.
*/ */
GIT_EXTERN(int) git_repository_init_ext( GIT_EXTERN(int) git_repository_init_ext(
git_repository **repo_out, git_repository **out,
const char *repo_path, const char *repo_path,
git_repository_init_options *opts); git_repository_init_options *opts);
/** /**
* Retrieve and resolve the reference pointed at by HEAD. * Retrieve and resolve the reference pointed at by HEAD.
* *
* @param head_out pointer to the reference which will be retrieved * The returned `git_reference` will be owned by caller and
* `git_reference_free()` must be called when done with it to release the
* allocated memory and prevent a leak.
*
* @param out pointer to the reference which will be retrieved
* @param repo a repository object * @param repo a repository object
* *
* @return 0 on success, GIT_EORPHANEDHEAD when HEAD points to a non existing * @return 0 on success, GIT_EORPHANEDHEAD when HEAD points to a non existing
* branch, GIT_ENOTFOUND when HEAD is missing; an error code otherwise * branch, GIT_ENOTFOUND when HEAD is missing; an error code otherwise
*/ */
GIT_EXTERN(int) git_repository_head(git_reference **head_out, git_repository *repo); GIT_EXTERN(int) git_repository_head(git_reference **out, git_repository *repo);
/** /**
* Check if a repository's HEAD is detached * Check if a repository's HEAD is detached
@ -468,12 +472,12 @@ GIT_EXTERN(void) git_repository_set_index(git_repository *repo, git_index *index
* Use this function to get the contents of this file. Don't forget to * Use this function to get the contents of this file. Don't forget to
* remove the file after you create the commit. * remove the file after you create the commit.
* *
* @param buffer Buffer to write data into or NULL to just read required size * @param out Buffer to write data into or NULL to just read required size
* @param len Length of buffer in bytes * @param len Length of buffer in bytes
* @param repo Repository to read prepared message from * @param repo Repository to read prepared message from
* @return Bytes written to buffer, GIT_ENOTFOUND if no message, or -1 on error * @return Bytes written to buffer, GIT_ENOTFOUND if no message, or -1 on error
*/ */
GIT_EXTERN(int) git_repository_message(char *buffer, size_t len, git_repository *repo); GIT_EXTERN(int) git_repository_message(char *out, size_t len, git_repository *repo);
/** /**
* Remove git's prepared message. * Remove git's prepared message.

25
include/git2/reset.h
View File

@ -15,17 +15,27 @@
*/ */
GIT_BEGIN_DECL GIT_BEGIN_DECL
/**
* Kinds of reset operation
*/
typedef enum {
GIT_RESET_SOFT = 1, /** Move the head to the given commit */
GIT_RESET_MIXED = 2, /** SOFT plus reset index to the commit */
GIT_RESET_HARD = 3, /** MIXED plus changes in working tree discarded */
} git_reset_t;
/** /**
* Sets the current head to the specified commit oid and optionally * Sets the current head to the specified commit oid and optionally
* resets the index and working tree to match. * resets the index and working tree to match.
* *
* When specifying a Soft kind of reset, the head will be moved to the commit. * SOFT reset means the head will be moved to the commit.
* *
* Specifying a Mixed kind of reset will trigger a Soft reset and the index will * MIXED reset will trigger a SOFT reset, plus the index will be replaced
* be replaced with the content of the commit tree. * with the content of the commit tree.
* *
* Specifying a Hard kind of reset will trigger a Mixed reset and the working * HARD reset will trigger a MIXED reset and the working directory will be
* directory will be replaced with the content of the index. * replaced with the content of the index. (Untracked and ignored files
* will be left alone, however.)
* *
* TODO: Implement remaining kinds of resets. * TODO: Implement remaining kinds of resets.
* *
@ -38,9 +48,10 @@ GIT_BEGIN_DECL
* *
* @param reset_type Kind of reset operation to perform. * @param reset_type Kind of reset operation to perform.
* *
* @return GIT_SUCCESS or an error code * @return 0 on success or an error code < 0
*/ */
GIT_EXTERN(int) git_reset(git_repository *repo, git_object *target, git_reset_type reset_type); GIT_EXTERN(int) git_reset(
git_repository *repo, git_object *target, git_reset_t reset_type);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

16
include/git2/revwalk.h
View File

@ -63,11 +63,11 @@ GIT_BEGIN_DECL
* it is possible to have several revision walkers in * it is possible to have several revision walkers in
* several different threads walking the same repository. * several different threads walking the same repository.
* *
* @param walker pointer to the new revision walker * @param out pointer to the new revision walker
* @param repo the repo to walk through * @param repo the repo to walk through
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_revwalk_new(git_revwalk **walker, git_repository *repo); GIT_EXTERN(int) git_revwalk_new(git_revwalk **out, git_repository *repo);
/** /**
* Reset the revision walker for reuse. * Reset the revision walker for reuse.
@ -96,10 +96,10 @@ GIT_EXTERN(void) git_revwalk_reset(git_revwalk *walker);
* be started. * be started.
* *
* @param walk the walker being used for the traversal. * @param walk the walker being used for the traversal.
* @param oid the oid of the commit to start from. * @param id the oid of the commit to start from.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *oid); GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *id);
/** /**
* Push matching references * Push matching references
@ -134,10 +134,10 @@ GIT_EXTERN(int) git_revwalk_push_head(git_revwalk *walk);
* output on the revision walk. * output on the revision walk.
* *
* @param walk the walker being used for the traversal. * @param walk the walker being used for the traversal.
* @param oid the oid of commit that will be ignored during the traversal * @param commit_id the oid of commit that will be ignored during the traversal
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *oid); GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *commit_id);
/** /**
* Hide matching references. * Hide matching references.
@ -198,12 +198,12 @@ GIT_EXTERN(int) git_revwalk_hide_ref(git_revwalk *walk, const char *refname);
* *
* The revision walker is reset when the walk is over. * The revision walker is reset when the walk is over.
* *
* @param oid Pointer where to store the oid of the next commit * @param out Pointer where to store the oid of the next commit
* @param walk the walker to pop the commit from. * @param walk the walker to pop the commit from.
* @return 0 if the next commit was found; * @return 0 if the next commit was found;
* GIT_ITEROVER if there are no commits left to iterate * GIT_ITEROVER if there are no commits left to iterate
*/ */
GIT_EXTERN(int) git_revwalk_next(git_oid *oid, git_revwalk *walk); GIT_EXTERN(int) git_revwalk_next(git_oid *out, git_revwalk *walk);
/** /**
* Change the sorting mode when iterating through the * Change the sorting mode when iterating through the

30
include/git2/signature.h
View File

@ -20,44 +20,52 @@
GIT_BEGIN_DECL GIT_BEGIN_DECL
/** /**
* Create a new action signature. The signature must be freed * Create a new action signature.
* manually or using git_signature_free *
* Call `git_signature_free()` to free the data.
* *
* Note: angle brackets ('<' and '>') characters are not allowed * Note: angle brackets ('<' and '>') characters are not allowed
* to be used in either the `name` or the `email` parameter. * to be used in either the `name` or the `email` parameter.
* *
* @param sig_out new signature, in case of error NULL * @param out new signature, in case of error NULL
* @param name name of the person * @param name name of the person
* @param email email of the person * @param email email of the person
* @param time time when the action happened * @param time time when the action happened
* @param offset timezone offset in minutes for the time * @param offset timezone offset in minutes for the time
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_signature_new(git_signature **sig_out, const char *name, const char *email, git_time_t time, int offset); GIT_EXTERN(int) git_signature_new(git_signature **out, const char *name, const char *email, git_time_t time, int offset);
/** /**
* Create a new action signature with a timestamp of 'now'. The * Create a new action signature with a timestamp of 'now'.
* signature must be freed manually or using git_signature_free
* *
* @param sig_out new signature, in case of error NULL * Call `git_signature_free()` to free the data.
*
* @param out new signature, in case of error NULL
* @param name name of the person * @param name name of the person
* @param email email of the person * @param email email of the person
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_signature_now(git_signature **sig_out, const char *name, const char *email); GIT_EXTERN(int) git_signature_now(git_signature **out, const char *name, const char *email);
/** /**
* Create a copy of an existing signature. * Create a copy of an existing signature. All internal strings are also
* duplicated.
*
* Call `git_signature_free()` to free the data.
* *
* All internal strings are also duplicated.
* @param sig signature to duplicated * @param sig signature to duplicated
* @return a copy of sig, NULL on out of memory * @return a copy of sig, NULL on out of memory
*/ */
GIT_EXTERN(git_signature *) git_signature_dup(const git_signature *sig); GIT_EXTERN(git_signature *) git_signature_dup(const git_signature *sig);
/** /**
* Free an existing signature * Free an existing signature.
*
* Because the signature is not an opaque structure, it is legal to free it
* manually, but be sure to free the "name" and "email" strings in addition
* to the structure itself.
* *
* @param sig signature to free * @param sig signature to free
*/ */

17
include/git2/stash.h
View File

@ -18,7 +18,7 @@
*/ */
GIT_BEGIN_DECL GIT_BEGIN_DECL
enum { typedef enum {
GIT_STASH_DEFAULT = 0, GIT_STASH_DEFAULT = 0,
/* All changes already added to the index /* All changes already added to the index
@ -35,7 +35,7 @@ enum {
* cleaned up from the working directory * cleaned up from the working directory
*/ */
GIT_STASH_INCLUDE_IGNORED = (1 << 2), GIT_STASH_INCLUDE_IGNORED = (1 << 2),
}; } git_stash_flags;
/** /**
* Save the local modifications to a new stash. * Save the local modifications to a new stash.
@ -49,18 +49,17 @@ enum {
* *
* @param message Optional description along with the stashed state. * @param message Optional description along with the stashed state.
* *
* @param flags Flags to control the stashing process. * @param flags Flags to control the stashing process. (see GIT_STASH_* above)
* *
* @return 0 on success, GIT_ENOTFOUND where there's nothing to stash, * @return 0 on success, GIT_ENOTFOUND where there's nothing to stash,
* or error code. * or error code.
*/ */
GIT_EXTERN(int) git_stash_save( GIT_EXTERN(int) git_stash_save(
git_oid *out, git_oid *out,
git_repository *repo, git_repository *repo,
git_signature *stasher, git_signature *stasher,
const char *message, const char *message,
uint32_t flags); unsigned int flags);
/** /**
* When iterating over all the stashed states, callback that will be * When iterating over all the stashed states, callback that will be
@ -71,16 +70,16 @@ GIT_EXTERN(int) git_stash_save(
* *
* @param message The stash message. * @param message The stash message.
* *
* @param stash_oid The commit oid of the stashed state. * @param stash_id The commit oid of the stashed state.
* *
* @param payload Extra parameter to callback function. * @param payload Extra parameter to callback function.
* *
* @return 0 on success, GIT_EUSER on non-zero callback, or error code * @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/ */
typedef int (*stash_cb)( typedef int (*git_stash_cb)(
size_t index, size_t index,
const char* message, const char* message,
const git_oid *stash_oid, const git_oid *stash_id,
void *payload); void *payload);
/** /**
@ -99,7 +98,7 @@ typedef int (*stash_cb)(
*/ */
GIT_EXTERN(int) git_stash_foreach( GIT_EXTERN(int) git_stash_foreach(
git_repository *repo, git_repository *repo,
stash_cb callback, git_stash_cb callback,
void *payload); void *payload);
/** /**

17
include/git2/status.h
View File

@ -46,6 +46,18 @@ typedef enum {
GIT_STATUS_IGNORED = (1u << 14), GIT_STATUS_IGNORED = (1u << 14),
} git_status_t; } git_status_t;
/**
* Function pointer to receive status on individual files
*
* `path` is the relative path to the file from the root of the repository.
*
* `status_flags` is a combination of `git_status_t` values that apply.
*
* `payload` is the value you passed to the foreach function as payload.
*/
typedef int (*git_status_cb)(
const char *path, unsigned int status_flags, void *payload);
/** /**
* Gather file statuses and run a callback for each one. * Gather file statuses and run a callback for each one.
* *
@ -63,7 +75,7 @@ typedef enum {
*/ */
GIT_EXTERN(int) git_status_foreach( GIT_EXTERN(int) git_status_foreach(
git_repository *repo, git_repository *repo,
int (*callback)(const char *, unsigned int, void *), git_status_cb callback,
void *payload); void *payload);
/** /**
@ -146,6 +158,7 @@ typedef enum {
* `GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH` is specified in the flags. * `GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH` is specified in the flags.
*/ */
typedef struct { typedef struct {
unsigned int version;
git_status_show_t show; git_status_show_t show;
unsigned int flags; unsigned int flags;
git_strarray pathspec; git_strarray pathspec;
@ -168,7 +181,7 @@ typedef struct {
GIT_EXTERN(int) git_status_foreach_ext( GIT_EXTERN(int) git_status_foreach_ext(
git_repository *repo, git_repository *repo,
const git_status_options *opts, const git_status_options *opts,
int (*callback)(const char *, unsigned int, void *), git_status_cb callback,
void *payload); void *payload);
/** /**

13
include/git2/strarray.h
View File

@ -28,10 +28,16 @@ struct _git_strarray {
/** /**
* Close a string array object * Close a string array object
* *
* This method must always be called once a git_strarray is no * This method should be called on `git_strarray` objects where the strings
* longer needed, otherwise memory will leak. * array is allocated and contains allocated strings, such as what you
* would get from `git_strarray_copy()`. Not doing so, will result in a
* memory leak.
* *
* @param array array to close * This does not free the `git_strarray` itself, since the library will
* never allocate that object directly itself (it is more commonly embedded
* inside another struct or created on the stack).
*
* @param array git_strarray from which to free string data
*/ */
GIT_EXTERN(void) git_strarray_free(git_strarray *array); GIT_EXTERN(void) git_strarray_free(git_strarray *array);
@ -43,6 +49,7 @@ GIT_EXTERN(void) git_strarray_free(git_strarray *array);
* *
* @param tgt target * @param tgt target
* @param src source * @param src source
* @return 0 on success, < 0 on allocation failure
*/ */
GIT_EXTERN(int) git_strarray_copy(git_strarray *tgt, const git_strarray *src); GIT_EXTERN(int) git_strarray_copy(git_strarray *tgt, const git_strarray *src);

6
include/git2/submodule.h
View File

@ -318,7 +318,7 @@ GIT_EXTERN(int) git_submodule_set_url(git_submodule *submodule, const char *url)
* @param submodule Pointer to submodule object * @param submodule Pointer to submodule object
* @return Pointer to git_oid or NULL if submodule is not in index. * @return Pointer to git_oid or NULL if submodule is not in index.
*/ */
GIT_EXTERN(const git_oid *) git_submodule_index_oid(git_submodule *submodule); GIT_EXTERN(const git_oid *) git_submodule_index_id(git_submodule *submodule);
/** /**
* Get the OID for the submodule in the current HEAD tree. * Get the OID for the submodule in the current HEAD tree.
@ -326,7 +326,7 @@ GIT_EXTERN(const git_oid *) git_submodule_index_oid(git_submodule *submodule);
* @param submodule Pointer to submodule object * @param submodule Pointer to submodule object
* @return Pointer to git_oid or NULL if submodule is not in the HEAD. * @return Pointer to git_oid or NULL if submodule is not in the HEAD.
*/ */
GIT_EXTERN(const git_oid *) git_submodule_head_oid(git_submodule *submodule); GIT_EXTERN(const git_oid *) git_submodule_head_id(git_submodule *submodule);
/** /**
* Get the OID for the submodule in the current working directory. * Get the OID for the submodule in the current working directory.
@ -339,7 +339,7 @@ GIT_EXTERN(const git_oid *) git_submodule_head_oid(git_submodule *submodule);
* @param submodule Pointer to submodule object * @param submodule Pointer to submodule object
* @return Pointer to git_oid or NULL if submodule is not checked out. * @return Pointer to git_oid or NULL if submodule is not checked out.
*/ */
GIT_EXTERN(const git_oid *) git_submodule_wd_oid(git_submodule *submodule); GIT_EXTERN(const git_oid *) git_submodule_wd_id(git_submodule *submodule);
/** /**
* Get the ignore rule for the submodule. * Get the ignore rule for the submodule.

59
include/git2/tag.h
View File

@ -25,14 +25,16 @@ GIT_BEGIN_DECL
/** /**
* Lookup a tag object from the repository. * Lookup a tag object from the repository.
* *
* @param tag pointer to the looked up tag * @param out pointer to the looked up tag
* @param repo the repo to use when locating the tag. * @param repo the repo to use when locating the tag.
* @param id identity of the tag to locate. * @param id identity of the tag to locate.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oid *id) GIT_INLINE(int) git_tag_lookup(
git_tag **out, git_repository *repo, const git_oid *id)
{ {
return git_object_lookup((git_object **)tag, repo, id, (git_otype)GIT_OBJ_TAG); return git_object_lookup(
(git_object **)out, repo, id, (git_otype)GIT_OBJ_TAG);
} }
/** /**
@ -41,25 +43,26 @@ GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oi
* *
* @see git_object_lookup_prefix * @see git_object_lookup_prefix
* *
* @param tag pointer to the looked up tag * @param out pointer to the looked up tag
* @param repo the repo to use when locating the tag. * @param repo the repo to use when locating the tag.
* @param id identity of the tag to locate. * @param id identity of the tag to locate.
* @param len the length of the short identifier * @param len the length of the short identifier
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_INLINE(int) git_tag_lookup_prefix(git_tag **tag, git_repository *repo, const git_oid *id, size_t len) GIT_INLINE(int) git_tag_lookup_prefix(
git_tag **out, git_repository *repo, const git_oid *id, size_t len)
{ {
return git_object_lookup_prefix((git_object **)tag, repo, id, len, (git_otype)GIT_OBJ_TAG); return git_object_lookup_prefix(
(git_object **)out, repo, id, len, (git_otype)GIT_OBJ_TAG);
} }
/** /**
* Close an open tag * Close an open tag
* *
* This is a wrapper around git_object_free() * You can no longer use the git_tag pointer after this call.
* *
* IMPORTANT: * IMPORTANT: You MUST call this method when you are through with a tag to
* It *is* necessary to call this method when you stop * release memory. Failure to do so will cause a memory leak.
* using a tag. Failure to do so will cause a memory leak.
* *
* @param tag the tag to close * @param tag the tag to close
*/ */
@ -76,7 +79,7 @@ GIT_INLINE(void) git_tag_free(git_tag *tag)
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return object identity for the tag. * @return object identity for the tag.
*/ */
GIT_EXTERN(const git_oid *) git_tag_id(git_tag *tag); GIT_EXTERN(const git_oid *) git_tag_id(const git_tag *tag);
/** /**
* Get the tagged object of a tag * Get the tagged object of a tag
@ -84,11 +87,11 @@ GIT_EXTERN(const git_oid *) git_tag_id(git_tag *tag);
* This method performs a repository lookup for the * This method performs a repository lookup for the
* given object and returns it * given object and returns it
* *
* @param target pointer where to store the target * @param target_out pointer where to store the target
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_tag_target(git_object **target, git_tag *tag); GIT_EXTERN(int) git_tag_target(git_object **target_out, const git_tag *tag);
/** /**
* Get the OID of the tagged object of a tag * Get the OID of the tagged object of a tag
@ -96,7 +99,7 @@ GIT_EXTERN(int) git_tag_target(git_object **target, git_tag *tag);
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return pointer to the OID * @return pointer to the OID
*/ */
GIT_EXTERN(const git_oid *) git_tag_target_oid(git_tag *tag); GIT_EXTERN(const git_oid *) git_tag_target_id(const git_tag *tag);
/** /**
* Get the type of a tag's tagged object * Get the type of a tag's tagged object
@ -104,7 +107,7 @@ GIT_EXTERN(const git_oid *) git_tag_target_oid(git_tag *tag);
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return type of the tagged object * @return type of the tagged object
*/ */
GIT_EXTERN(git_otype) git_tag_target_type(git_tag *tag); GIT_EXTERN(git_otype) git_tag_target_type(const git_tag *tag);
/** /**
* Get the name of a tag * Get the name of a tag
@ -112,7 +115,7 @@ GIT_EXTERN(git_otype) git_tag_target_type(git_tag *tag);
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return name of the tag * @return name of the tag
*/ */
GIT_EXTERN(const char *) git_tag_name(git_tag *tag); GIT_EXTERN(const char *) git_tag_name(const git_tag *tag);
/** /**
* Get the tagger (author) of a tag * Get the tagger (author) of a tag
@ -120,7 +123,7 @@ GIT_EXTERN(const char *) git_tag_name(git_tag *tag);
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return reference to the tag's author * @return reference to the tag's author
*/ */
GIT_EXTERN(const git_signature *) git_tag_tagger(git_tag *tag); GIT_EXTERN(const git_signature *) git_tag_tagger(const git_tag *tag);
/** /**
* Get the message of a tag * Get the message of a tag
@ -128,7 +131,7 @@ GIT_EXTERN(const git_signature *) git_tag_tagger(git_tag *tag);
* @param tag a previously loaded tag. * @param tag a previously loaded tag.
* @return message of the tag * @return message of the tag
*/ */
GIT_EXTERN(const char *) git_tag_message(git_tag *tag); GIT_EXTERN(const char *) git_tag_message(const git_tag *tag);
/** /**
@ -279,34 +282,34 @@ GIT_EXTERN(int) git_tag_list_match(
git_repository *repo); git_repository *repo);
typedef int (*git_tag_foreach_cb)(const char *name, git_oid *oid, void *data); typedef int (*git_tag_foreach_cb)(const char *name, git_oid *oid, void *payload);
/** /**
* Call callback `cb' for each tag in the repository * Call callback `cb' for each tag in the repository
* *
* @param repo Repository * @param repo Repository
* @param cb Callback function * @param callback Callback function
* @param cb_data Pointer to callback data (optional) * @param payload Pointer to callback data (optional)
*/ */
GIT_EXTERN(int) git_tag_foreach( GIT_EXTERN(int) git_tag_foreach(
git_repository *repo, git_repository *repo,
git_tag_foreach_cb cb, git_tag_foreach_cb callback,
void *cb_data); void *payload);
/** /**
* Recursively peel a tag until a non tag git_object * Recursively peel a tag until a non tag git_object is found
* is met
* *
* The retrieved `tag_target` object is owned by the repository * The retrieved `tag_target` object is owned by the repository
* and should be closed with the `git_object_free` method. * and should be closed with the `git_object_free` method.
* *
* @param tag_target Pointer to the peeled git_object * @param tag_target_out Pointer to the peeled git_object
* @param tag The tag to be processed * @param tag The tag to be processed
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_tag_peel( GIT_EXTERN(int) git_tag_peel(
git_object **tag_target, git_object **tag_target_out,
git_tag *tag); const git_tag *tag);
/** @} */ /** @} */
GIT_END_DECL GIT_END_DECL

24
include/git2/transport.h
View File

@ -45,12 +45,12 @@ typedef struct git_cred_userpass_plaintext {
/** /**
* Creates a new plain-text username and password credential object. * Creates a new plain-text username and password credential object.
* *
* @param cred The newly created credential object. * @param out The newly created credential object.
* @param username The username of the credential. * @param username The username of the credential.
* @param password The password of the credential. * @param password The password of the credential.
*/ */
GIT_EXTERN(int) git_cred_userpass_plaintext_new( GIT_EXTERN(int) git_cred_userpass_plaintext_new(
git_cred **cred, git_cred **out,
const char *username, const char *username,
const char *password); const char *password);
@ -64,7 +64,7 @@ GIT_EXTERN(int) git_cred_userpass_plaintext_new(
typedef int (*git_cred_acquire_cb)( typedef int (*git_cred_acquire_cb)(
git_cred **cred, git_cred **cred,
const char *url, const char *url,
int allowed_types); unsigned int allowed_types);
/* /*
*** End interface for credentials acquisition *** *** End interface for credentials acquisition ***
@ -144,11 +144,11 @@ typedef struct git_transport {
* is scanned to find a transport that implements the scheme of the URI (i.e. * is scanned to find a transport that implements the scheme of the URI (i.e.
* git:// or http://) and a transport object is returned to the caller. * git:// or http://) and a transport object is returned to the caller.
* *
* @param transport The newly created transport (out) * @param out The newly created transport (out)
* @param url The URL to connect to * @param url The URL to connect to
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_transport_new(git_transport **transport, const char *url); GIT_EXTERN(int) git_transport_new(git_transport **out, const char *url);
/** /**
* Function which checks to see if a transport could be created for the * Function which checks to see if a transport could be created for the
@ -161,7 +161,7 @@ GIT_EXTERN(int) git_transport_new(git_transport **transport, const char *url);
GIT_EXTERN(int) git_transport_valid_url(const char *url); GIT_EXTERN(int) git_transport_valid_url(const char *url);
/* Signature of a function which creates a transport */ /* Signature of a function which creates a transport */
typedef int (*git_transport_cb)(git_transport **transport, void *param); typedef int (*git_transport_cb)(git_transport **out, void *payload);
/* Transports which come with libgit2 (match git_transport_cb). The expected /* Transports which come with libgit2 (match git_transport_cb). The expected
* value for "param" is listed in-line below. */ * value for "param" is listed in-line below. */
@ -170,34 +170,34 @@ typedef int (*git_transport_cb)(git_transport **transport, void *param);
* Create an instance of the dummy transport. * Create an instance of the dummy transport.
* *
* @param transport The newly created transport (out) * @param transport The newly created transport (out)
* @param param You must pass NULL for this parameter. * @param payload You must pass NULL for this parameter.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_transport_dummy( GIT_EXTERN(int) git_transport_dummy(
git_transport **transport, git_transport **transport,
/* NULL */ void *param); /* NULL */ void *payload);
/** /**
* Create an instance of the local transport. * Create an instance of the local transport.
* *
* @param transport The newly created transport (out) * @param transport The newly created transport (out)
* @param param You must pass NULL for this parameter. * @param payload You must pass NULL for this parameter.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_transport_local( GIT_EXTERN(int) git_transport_local(
git_transport **transport, git_transport **transport,
/* NULL */ void *param); /* NULL */ void *payload);
/** /**
* Create an instance of the smart transport. * Create an instance of the smart transport.
* *
* @param transport The newly created transport (out) * @param transport The newly created transport (out)
* @param param A pointer to a git_smart_subtransport_definition * @param payload A pointer to a git_smart_subtransport_definition
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_transport_smart( GIT_EXTERN(int) git_transport_smart(
git_transport **transport, git_transport **transport,
/* (git_smart_subtransport_definition *) */ void *param); /* (git_smart_subtransport_definition *) */ void *payload);
/* /*
*** End of base transport interface *** *** End of base transport interface ***

222
include/git2/tree.h
View File

@ -24,14 +24,15 @@ GIT_BEGIN_DECL
/** /**
* Lookup a tree object from the repository. * Lookup a tree object from the repository.
* *
* @param tree pointer to the looked up tree * @param out Pointer to the looked up tree
* @param repo the repo to use when locating the tree. * @param repo The repo to use when locating the tree.
* @param id identity of the tree to locate. * @param id Identity of the tree to locate.
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git_oid *id) GIT_INLINE(int) git_tree_lookup(
git_tree **out, git_repository *repo, const git_oid *id)
{ {
return git_object_lookup((git_object **)tree, repo, id, GIT_OBJ_TREE); return git_object_lookup((git_object **)out, repo, id, GIT_OBJ_TREE);
} }
/** /**
@ -47,53 +48,30 @@ GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_INLINE(int) git_tree_lookup_prefix( GIT_INLINE(int) git_tree_lookup_prefix(
git_tree **tree, git_tree **out,
git_repository *repo, git_repository *repo,
const git_oid *id, const git_oid *id,
size_t len) size_t len)
{ {
return git_object_lookup_prefix((git_object **)tree, repo, id, len, GIT_OBJ_TREE); return git_object_lookup_prefix(
(git_object **)out, repo, id, len, GIT_OBJ_TREE);
} }
/** /**
* Close an open tree * Close an open tree
* *
* This is a wrapper around git_object_free() * You can no longer use the git_tree pointer after this call.
* *
* IMPORTANT: * IMPORTANT: You MUST call this method when you stop using a tree to
* It *is* necessary to call this method when you stop * release memory. Failure to do so will cause a memory leak.
* using a tree. Failure to do so will cause a memory leak.
* *
* @param tree the tree to close * @param tree The tree to close
*/ */
GIT_INLINE(void) git_tree_free(git_tree *tree) GIT_INLINE(void) git_tree_free(git_tree *tree)
{ {
git_object_free((git_object *)tree); git_object_free((git_object *)tree);
} }
/**
* Free a tree entry
*
* IMPORTANT: This function is only needed for tree
* entries owned by the user, such as the ones returned
* by `git_tree_entry_dup`.
*
* @param entry The entry to free
*/
GIT_EXTERN(void) git_tree_entry_free(git_tree_entry *entry);
/**
* Duplicate a tree entry
*
* Create a copy of a tree entry. The returned copy is owned
* by the user, and must be freed manually with
* `git_tree_entry_free`.
*
* @param entry A tree entry to duplicate
* @return a copy of the original entry
*/
GIT_EXTERN(git_tree_entry *) git_tree_entry_dup(const git_tree_entry *entry);
/** /**
* Get the id of a tree. * Get the id of a tree.
* *
@ -108,44 +86,87 @@ GIT_EXTERN(const git_oid *) git_tree_id(const git_tree *tree);
* @param tree a previously loaded tree. * @param tree a previously loaded tree.
* @return the number of entries in the tree * @return the number of entries in the tree
*/ */
GIT_EXTERN(unsigned int) git_tree_entrycount(const git_tree *tree); GIT_EXTERN(size_t) git_tree_entrycount(const git_tree *tree);
/** /**
* Lookup a tree entry by its filename * Lookup a tree entry by its filename
* *
* This returns a git_tree_entry that is owned by the git_tree. You don't
* have to free it, but you must not use it after the git_tree is released.
*
* @param tree a previously loaded tree. * @param tree a previously loaded tree.
* @param filename the filename of the desired entry * @param filename the filename of the desired entry
* @return the tree entry; NULL if not found * @return the tree entry; NULL if not found
*/ */
GIT_EXTERN(const git_tree_entry *) git_tree_entry_byname(git_tree *tree, const char *filename); GIT_EXTERN(const git_tree_entry *) git_tree_entry_byname(
git_tree *tree, const char *filename);
/** /**
* Lookup a tree entry by its position in the tree * Lookup a tree entry by its position in the tree
* *
* This returns a git_tree_entry that is owned by the git_tree. You don't
* have to free it, but you must not use it after the git_tree is released.
*
* @param tree a previously loaded tree. * @param tree a previously loaded tree.
* @param idx the position in the entry list * @param idx the position in the entry list
* @return the tree entry; NULL if not found * @return the tree entry; NULL if not found
*/ */
GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(git_tree *tree, size_t idx); GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(
git_tree *tree, size_t idx);
/** /**
* Lookup a tree entry by SHA value. * Lookup a tree entry by SHA value.
* *
* This returns a git_tree_entry that is owned by the git_tree. You don't
* have to free it, but you must not use it after the git_tree is released.
*
* Warning: this must examine every entry in the tree, so it is not fast. * Warning: this must examine every entry in the tree, so it is not fast.
* *
* @param tree a previously loaded tree. * @param tree a previously loaded tree.
* @param oid the sha being looked for * @param oid the sha being looked for
* @return the tree entry; NULL if not found * @return the tree entry; NULL if not found
*/ */
GIT_EXTERN(const git_tree_entry *) git_tree_entry_byoid(git_tree *tree, const git_oid *oid); GIT_EXTERN(const git_tree_entry *) git_tree_entry_byoid(
const git_tree *tree, const git_oid *oid);
/** /**
* Get the UNIX file attributes of a tree entry * Retrieve a tree entry contained in a tree or in any of its subtrees,
* given its relative path.
* *
* @param entry a tree entry * Unlike the other lookup functions, the returned tree entry is owned by
* @return filemode as an integer * the user and must be freed explicitly with `git_tree_entry_free()`.
*
* @param out Pointer where to store the tree entry
* @param root Previously loaded tree which is the root of the relative path
* @param subtree_path Path to the contained entry
* @return 0 on success; GIT_ENOTFOUND if the path does not exist
*/ */
GIT_EXTERN(git_filemode_t) git_tree_entry_filemode(const git_tree_entry *entry); GIT_EXTERN(int) git_tree_entry_bypath(
git_tree_entry **out,
git_tree *root,
const char *path);
/**
* Duplicate a tree entry
*
* Create a copy of a tree entry. The returned copy is owned by the user,
* and must be freed explicitly with `git_tree_entry_free()`.
*
* @param entry A tree entry to duplicate
* @return a copy of the original entry or NULL on error (alloc failure)
*/
GIT_EXTERN(git_tree_entry *) git_tree_entry_dup(const git_tree_entry *entry);
/**
* Free a user-owned tree entry
*
* IMPORTANT: This function is only needed for tree entries owned by the
* user, such as the ones returned by `git_tree_entry_dup()` or
* `git_tree_entry_bypath()`.
*
* @param entry The entry to free
*/
GIT_EXTERN(void) git_tree_entry_free(git_tree_entry *entry);
/** /**
* Get the filename of a tree entry * Get the filename of a tree entry
@ -171,9 +192,19 @@ GIT_EXTERN(const git_oid *) git_tree_entry_id(const git_tree_entry *entry);
*/ */
GIT_EXTERN(git_otype) git_tree_entry_type(const git_tree_entry *entry); GIT_EXTERN(git_otype) git_tree_entry_type(const git_tree_entry *entry);
/**
* Get the UNIX file attributes of a tree entry
*
* @param entry a tree entry
* @return filemode as an integer
*/
GIT_EXTERN(git_filemode_t) git_tree_entry_filemode(const git_tree_entry *entry);
/** /**
* Convert a tree entry to the git_object it points too. * Convert a tree entry to the git_object it points too.
* *
* You must call `git_object_free()` on the object when you are done with it.
*
* @param object pointer to the converted object * @param object pointer to the converted object
* @param repo repository where to lookup the pointed object * @param repo repository where to lookup the pointed object
* @param entry a tree entry * @param entry a tree entry
@ -187,21 +218,21 @@ GIT_EXTERN(int) git_tree_entry_to_object(
/** /**
* Create a new tree builder. * Create a new tree builder.
* *
* The tree builder can be used to create or modify * The tree builder can be used to create or modify trees in memory and
* trees in memory and write them as tree objects to the * write them as tree objects to the database.
* database.
* *
* If the `source` parameter is not NULL, the tree builder * If the `source` parameter is not NULL, the tree builder will be
* will be initialized with the entries of the given tree. * initialized with the entries of the given tree.
* *
* If the `source` parameter is NULL, the tree builder will * If the `source` parameter is NULL, the tree builder will start with no
* have no entries and will have to be filled manually. * entries and will have to be filled manually.
* *
* @param builder_p Pointer where to store the tree builder * @param out Pointer where to store the tree builder
* @param source Source tree to initialize the builder (optional) * @param source Source tree to initialize the builder (optional)
* @return 0 on success; error code otherwise * @return 0 on success; error code otherwise
*/ */
GIT_EXTERN(int) git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source); GIT_EXTERN(int) git_treebuilder_create(
git_treebuilder **out, const git_tree *source);
/** /**
* Clear all the entires in the builder * Clear all the entires in the builder
@ -231,7 +262,8 @@ GIT_EXTERN(void) git_treebuilder_free(git_treebuilder *bld);
* @param filename Name of the entry * @param filename Name of the entry
* @return pointer to the entry; NULL if not found * @return pointer to the entry; NULL if not found
*/ */
GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(git_treebuilder *bld, const char *filename); GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(
git_treebuilder *bld, const char *filename);
/** /**
* Add or update an entry to the builder * Add or update an entry to the builder
@ -239,17 +271,17 @@ GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(git_treebuilder *bld, con
* Insert a new entry for `filename` in the builder with the * Insert a new entry for `filename` in the builder with the
* given attributes. * given attributes.
* *
* if an entry named `filename` already exists, its attributes * If an entry named `filename` already exists, its attributes
* will be updated with the given ones. * will be updated with the given ones.
* *
* The optional pointer `entry_out` can be used to retrieve a * The optional pointer `out` can be used to retrieve a pointer to
* pointer to the newly created/updated entry. * the newly created/updated entry. Pass NULL if you do not need it.
* *
* No attempt is being made to ensure that the provided oid points * No attempt is being made to ensure that the provided oid points
* to an existing git object in the object database, nor that the * to an existing git object in the object database, nor that the
* attributes make sense regarding the type of the pointed at object. * attributes make sense regarding the type of the pointed at object.
* *
* @param entry_out Pointer to store the entry (optional) * @param out Pointer to store the entry (optional)
* @param bld Tree builder * @param bld Tree builder
* @param filename Filename of the entry * @param filename Filename of the entry
* @param id SHA1 oid of the entry * @param id SHA1 oid of the entry
@ -259,7 +291,7 @@ GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(git_treebuilder *bld, con
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_treebuilder_insert( GIT_EXTERN(int) git_treebuilder_insert(
const git_tree_entry **entry_out, const git_tree_entry **out,
git_treebuilder *bld, git_treebuilder *bld,
const char *filename, const char *filename,
const git_oid *id, const git_oid *id,
@ -271,85 +303,75 @@ GIT_EXTERN(int) git_treebuilder_insert(
* @param bld Tree builder * @param bld Tree builder
* @param filename Filename of the entry to remove * @param filename Filename of the entry to remove
*/ */
GIT_EXTERN(int) git_treebuilder_remove(git_treebuilder *bld, const char *filename); GIT_EXTERN(int) git_treebuilder_remove(
git_treebuilder *bld, const char *filename);
typedef int (*git_treebuilder_filter_cb)(
const git_tree_entry *entry, void *payload);
/** /**
* Filter the entries in the tree * Filter the entries in the tree
* *
* The `filter` callback will be called for each entry * The `filter` callback will be called for each entry in the tree with a
* in the tree with a pointer to the entry and the * pointer to the entry and the provided `payload`; if the callback returns
* provided `payload`: if the callback returns 1, the * non-zero, the entry will be filtered (removed from the builder).
* entry will be filtered (removed from the builder).
* *
* @param bld Tree builder * @param bld Tree builder
* @param filter Callback to filter entries * @param filter Callback to filter entries
* @param payload Extra data to pass to filter
*/ */
GIT_EXTERN(void) git_treebuilder_filter( GIT_EXTERN(void) git_treebuilder_filter(
git_treebuilder *bld, git_treebuilder *bld,
int (*filter)(const git_tree_entry *, void *), git_treebuilder_filter_cb filter,
void *payload); void *payload);
/** /**
* Write the contents of the tree builder as a tree object * Write the contents of the tree builder as a tree object
* *
* The tree builder will be written to the given `repo`, and * The tree builder will be written to the given `repo`, and its
* it's identifying SHA1 hash will be stored in the `oid` * identifying SHA1 hash will be stored in the `id` pointer.
* pointer.
* *
* @param oid Pointer where to store the written OID * @param id Pointer to store the OID of the newly written tree
* @param repo Repository where to store the object * @param repo Repository in which to store the object
* @param bld Tree builder to write * @param bld Tree builder to write
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld); GIT_EXTERN(int) git_treebuilder_write(
git_oid *id, git_repository *repo, git_treebuilder *bld);
/**
* Retrieve a tree entry contained in a tree or in any
* of its subtrees, given its relative path.
*
* The returned tree entry is owned by the user and must
* be freed manually with `git_tree_entry_free`.
*
* @param entry Pointer where to store the tree entry
* @param root A previously loaded tree which will be the root of the relative path
* @param subtree_path Path to the contained entry
* @return 0 on success; GIT_ENOTFOUND if the path does not exist
*/
GIT_EXTERN(int) git_tree_entry_bypath(
git_tree_entry **entry,
git_tree *root,
const char *path);
/** Callback for the tree traversal method */ /** Callback for the tree traversal method */
typedef int (*git_treewalk_cb)(const char *root, const git_tree_entry *entry, void *payload); typedef int (*git_treewalk_cb)(
const char *root, const git_tree_entry *entry, void *payload);
/** Tree traversal modes */ /** Tree traversal modes */
enum git_treewalk_mode { typedef enum {
GIT_TREEWALK_PRE = 0, /* Pre-order */ GIT_TREEWALK_PRE = 0, /* Pre-order */
GIT_TREEWALK_POST = 1, /* Post-order */ GIT_TREEWALK_POST = 1, /* Post-order */
}; } git_treewalk_mode;
/** /**
* Traverse the entries in a tree and its subtrees in * Traverse the entries in a tree and its subtrees in post or pre order.
* post or pre order
* *
* The entries will be traversed in the specified order, * The entries will be traversed in the specified order, children subtrees
* children subtrees will be automatically loaded as required, * will be automatically loaded as required, and the `callback` will be
* and the `callback` will be called once per entry with * called once per entry with the current (relative) root for the entry and
* the current (relative) root for the entry and the entry * the entry data itself.
* data itself.
* *
* If the callback returns a positive value, the passed entry will be * If the callback returns a positive value, the passed entry will be
* skipped on the traversal (in pre mode). A negative value stops the * skipped on the traversal (in pre mode). A negative value stops the walk.
* walk.
* *
* @param tree The tree to walk * @param tree The tree to walk
* @param callback Function to call on each tree entry
* @param mode Traversal mode (pre or post-order) * @param mode Traversal mode (pre or post-order)
* @param callback Function to call on each tree entry
* @param payload Opaque pointer to be passed on each callback * @param payload Opaque pointer to be passed on each callback
* @return 0 or an error code * @return 0 or an error code
*/ */
GIT_EXTERN(int) git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload); GIT_EXTERN(int) git_tree_walk(
const git_tree *tree,
git_treewalk_mode mode,
git_treewalk_cb callback,
void *payload);
/** @} */ /** @} */

9
include/git2/types.h
View File

@ -129,7 +129,7 @@ typedef struct git_index git_index;
typedef struct git_config git_config; typedef struct git_config git_config;
/** Interface to access a configuration file */ /** Interface to access a configuration file */
typedef struct git_config_file git_config_file; typedef struct git_config_backend git_config_backend;
/** Representation of a reference log entry */ /** Representation of a reference log entry */
typedef struct git_reflog_entry git_reflog_entry; typedef struct git_reflog_entry git_reflog_entry;
@ -175,13 +175,6 @@ typedef enum {
GIT_BRANCH_REMOTE = 2, GIT_BRANCH_REMOTE = 2,
} git_branch_t; } git_branch_t;
/** Kinds of reset operation. */
typedef enum {
GIT_RESET_SOFT = 1,
GIT_RESET_MIXED = 2,
GIT_RESET_HARD = 3,
} git_reset_type;
/** Valid modes for index and tree entries. */ /** Valid modes for index and tree entries. */
typedef enum { typedef enum {
GIT_FILEMODE_NEW = 0000000, GIT_FILEMODE_NEW = 0000000,

2
src/attr.c
View File

@ -295,7 +295,7 @@ static int load_attr_blob_from_index(
{ {
int error; int error;
git_index *index; git_index *index;
git_index_entry *entry; const git_index_entry *entry;
if ((error = git_repository_index__weakptr(&index, repo)) < 0 || if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
(error = git_index_find(index, relfile)) < 0) (error = git_index_find(index, relfile)) < 0)

6
src/blob.c
View File

@ -19,10 +19,10 @@ const void *git_blob_rawcontent(git_blob *blob)
return blob->odb_object->raw.data; return blob->odb_object->raw.data;
} }
size_t git_blob_rawsize(git_blob *blob) git_off_t git_blob_rawsize(git_blob *blob)
{ {
assert(blob); assert(blob);
return blob->odb_object->raw.len; return (git_off_t)blob->odb_object->raw.len;
} }
int git_blob__getbuf(git_buf *buffer, git_blob *blob) int git_blob__getbuf(git_buf *buffer, git_blob *blob)
@ -205,7 +205,7 @@ static int blob_create_internal(git_oid *oid, git_repository *repo, const char *
return error; return error;
} }
int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path) int git_blob_create_fromworkdir(git_oid *oid, git_repository *repo, const char *path)
{ {
git_buf full_path = GIT_BUF_INIT; git_buf full_path = GIT_BUF_INIT;
const char *workdir; const char *workdir;

21
src/branch.c
View File

@ -44,12 +44,6 @@ cleanup:
return error; return error;
} }
static int create_error_invalid(const char *msg)
{
giterr_set(GITERR_INVALID, "Cannot create branch - %s", msg);
return -1;
}
static int not_a_local_branch(git_reference *ref) static int not_a_local_branch(git_reference *ref)
{ {
giterr_set(GITERR_INVALID, "Reference '%s' is not a local branch.", git_reference_name(ref)); giterr_set(GITERR_INVALID, "Reference '%s' is not a local branch.", git_reference_name(ref));
@ -60,31 +54,26 @@ int git_branch_create(
git_reference **ref_out, git_reference **ref_out,
git_repository *repository, git_repository *repository,
const char *branch_name, const char *branch_name,
const git_object *target, const git_commit *commit,
int force) int force)
{ {
git_object *commit = NULL;
git_reference *branch = NULL; git_reference *branch = NULL;
git_buf canonical_branch_name = GIT_BUF_INIT; git_buf canonical_branch_name = GIT_BUF_INIT;
int error = -1; int error = -1;
assert(branch_name && target && ref_out); assert(branch_name && commit && ref_out);
assert(git_object_owner(target) == repository); assert(git_object_owner((const git_object *)commit) == repository);
if (git_object_peel(&commit, (git_object *)target, GIT_OBJ_COMMIT) < 0)
return create_error_invalid("The given target does not resolve to a commit");
if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0) if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
goto cleanup; goto cleanup;
error = git_reference_create_oid(&branch, repository, error = git_reference_create(&branch, repository,
git_buf_cstr(&canonical_branch_name), git_object_id(commit), force); git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force);
if (!error) if (!error)
*ref_out = branch; *ref_out = branch;
cleanup: cleanup:
git_object_free(commit);
git_buf_free(&canonical_branch_name); git_buf_free(&canonical_branch_name);
return error; return error;
} }

2
src/checkout.c
View File

@ -693,7 +693,7 @@ cleanup:
int git_checkout_tree( int git_checkout_tree(
git_repository *repo, git_repository *repo,
git_object *treeish, const git_object *treeish,
git_checkout_opts *opts) git_checkout_opts *opts)
{ {
int error = 0; int error = 0;

14
src/clone.c
View File

@ -28,18 +28,18 @@ static int create_branch(
const git_oid *target, const git_oid *target,
const char *name) const char *name)
{ {
git_object *head_obj = NULL; git_commit *head_obj = NULL;
git_reference *branch_ref; git_reference *branch_ref;
int error; int error;
/* Find the target commit */ /* Find the target commit */
if ((error = git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY)) < 0) if ((error = git_commit_lookup(&head_obj, repo, target)) < 0)
return error; return error;
/* Create the new branch */ /* Create the new branch */
error = git_branch_create(&branch_ref, repo, name, head_obj, 0); error = git_branch_create(&branch_ref, repo, name, head_obj, 0);
git_object_free(head_obj); git_commit_free(head_obj);
if (!error) if (!error)
*branch = branch_ref; *branch = branch_ref;
@ -122,7 +122,7 @@ static int reference_matches_remote_head(
if (git_buf_len(&head_info->branchname) > 0) if (git_buf_len(&head_info->branchname) > 0)
return 0; return 0;
if (git_reference_name_to_oid( if (git_reference_name_to_id(
&oid, &oid,
head_info->repo, head_info->repo,
reference_name) < 0) { reference_name) < 0) {
@ -278,7 +278,7 @@ static int setup_remotes_and_fetch(
git_remote_set_update_fetchhead(origin, 0); git_remote_set_update_fetchhead(origin, 0);
/* Connect and download everything */ /* Connect and download everything */
if (!git_remote_connect(origin, GIT_DIR_FETCH)) { if (!git_remote_connect(origin, GIT_DIRECTION_FETCH)) {
if (!git_remote_download(origin, progress_cb, progress_payload)) { if (!git_remote_download(origin, progress_cb, progress_payload)) {
/* Create "origin/foo" branches for all remote branches */ /* Create "origin/foo" branches for all remote branches */
if (!git_remote_update_tips(origin)) { if (!git_remote_update_tips(origin)) {
@ -381,9 +381,9 @@ int git_clone(
git_repository **out, git_repository **out,
const char *origin_url, const char *origin_url,
const char *workdir_path, const char *workdir_path,
git_checkout_opts *checkout_opts,
git_transfer_progress_callback fetch_progress_cb, git_transfer_progress_callback fetch_progress_cb,
void *fetch_progress_payload, void *fetch_progress_payload)
git_checkout_opts *checkout_opts)
{ {
assert(out && origin_url && workdir_path); assert(out && origin_url && workdir_path);

53
src/commit.c
View File

@ -22,18 +22,18 @@ static void clear_parents(git_commit *commit)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < commit->parent_oids.length; ++i) { for (i = 0; i < commit->parent_ids.length; ++i) {
git_oid *parent = git_vector_get(&commit->parent_oids, i); git_oid *parent = git_vector_get(&commit->parent_ids, i);
git__free(parent); git__free(parent);
} }
git_vector_clear(&commit->parent_oids); git_vector_clear(&commit->parent_ids);
} }
void git_commit__free(git_commit *commit) void git_commit__free(git_commit *commit)
{ {
clear_parents(commit); clear_parents(commit);
git_vector_free(&commit->parent_oids); git_vector_free(&commit->parent_ids);
git_signature_free(commit->author); git_signature_free(commit->author);
git_signature_free(commit->committer); git_signature_free(commit->committer);
@ -43,11 +43,6 @@ void git_commit__free(git_commit *commit)
git__free(commit); git__free(commit);
} }
const git_oid *git_commit_id(git_commit *c)
{
return git_object_id((git_object *)c);
}
int git_commit_create_v( int git_commit_create_v(
git_oid *oid, git_oid *oid,
git_repository *repo, git_repository *repo,
@ -141,26 +136,26 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len)
const char *buffer = data; const char *buffer = data;
const char *buffer_end = (const char *)data + len; const char *buffer_end = (const char *)data + len;
git_oid parent_oid; git_oid parent_id;
git_vector_init(&commit->parent_oids, 4, NULL); git_vector_init(&commit->parent_ids, 4, NULL);
if (git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ") < 0) if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
goto bad_buffer; goto bad_buffer;
/* /*
* TODO: commit grafts! * TODO: commit grafts!
*/ */
while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == 0) { while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
git_oid *new_oid; git_oid *new_id;
new_oid = git__malloc(sizeof(git_oid)); new_id = git__malloc(sizeof(git_oid));
GITERR_CHECK_ALLOC(new_oid); GITERR_CHECK_ALLOC(new_id);
git_oid_cpy(new_oid, &parent_oid); git_oid_cpy(new_id, &parent_id);
if (git_vector_insert(&commit->parent_oids, new_oid) < 0) if (git_vector_insert(&commit->parent_ids, new_id) < 0)
return -1; return -1;
} }
@ -214,7 +209,7 @@ int git_commit__parse(git_commit *commit, git_odb_object *obj)
} }
#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \ #define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
_rvalue git_commit_##_name(git_commit *commit) \ _rvalue git_commit_##_name(const git_commit *commit) \
{\ {\
assert(commit); \ assert(commit); \
return _return; \ return _return; \
@ -226,34 +221,34 @@ GIT_COMMIT_GETTER(const char *, message, commit->message)
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding) GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time) GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset) GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_oids.length) GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_ids.length)
GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid); GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id);
int git_commit_tree(git_tree **tree_out, git_commit *commit) int git_commit_tree(git_tree **tree_out, const git_commit *commit)
{ {
assert(commit); assert(commit);
return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_oid); return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
} }
const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n) const git_oid *git_commit_parent_id(git_commit *commit, unsigned int n)
{ {
assert(commit); assert(commit);
return git_vector_get(&commit->parent_oids, n); return git_vector_get(&commit->parent_ids, n);
} }
int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n) int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
{ {
const git_oid *parent_oid; const git_oid *parent_id;
assert(commit); assert(commit);
parent_oid = git_commit_parent_oid(commit, n); parent_id = git_commit_parent_id(commit, n);
if (parent_oid == NULL) { if (parent_id == NULL) {
giterr_set(GITERR_INVALID, "Parent %u does not exist", n); giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
return GIT_ENOTFOUND; return GIT_ENOTFOUND;
} }
return git_commit_lookup(parent, commit->object.repo, parent_oid); return git_commit_lookup(parent, commit->object.repo, parent_id);
} }
int git_commit_nth_gen_ancestor( int git_commit_nth_gen_ancestor(

4
src/commit.h
View File

@ -17,8 +17,8 @@
struct git_commit { struct git_commit {
git_object object; git_object object;
git_vector parent_oids; git_vector parent_ids;
git_oid tree_oid; git_oid tree_id;
git_signature *author; git_signature *author;
git_signature *committer; git_signature *committer;

190
src/commit_list.c Normal file
View File

@ -0,0 +1,190 @@
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#include "commit_list.h"
#include "common.h"
#include "revwalk.h"
#include "pool.h"
#include "odb.h"
int git_commit_list_time_cmp(void *a, void *b)
{
git_commit_list_node *commit_a = (git_commit_list_node *)a;
git_commit_list_node *commit_b = (git_commit_list_node *)b;
return (commit_a->time < commit_b->time);
}
git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)
{
git_commit_list *new_list = git__malloc(sizeof(git_commit_list));
if (new_list != NULL) {
new_list->item = item;
new_list->next = *list_p;
}
*list_p = new_list;
return new_list;
}
git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p)
{
git_commit_list **pp = list_p;
git_commit_list *p;
while ((p = *pp) != NULL) {
if (git_commit_list_time_cmp(p->item, item) < 0)
break;
pp = &p->next;
}
return git_commit_list_insert(item, pp);
}
git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk)
{
return (git_commit_list_node *)git_pool_malloc(&walk->commit_pool, COMMIT_ALLOC);
}
static int commit_error(git_commit_list_node *commit, const char *msg)
{
char commit_oid[GIT_OID_HEXSZ + 1];
git_oid_fmt(commit_oid, &commit->oid);
commit_oid[GIT_OID_HEXSZ] = '\0';
giterr_set(GITERR_ODB, "Failed to parse commit %s - %s", commit_oid, msg);
return -1;
}
static git_commit_list_node **alloc_parents(
git_revwalk *walk, git_commit_list_node *commit, size_t n_parents)
{
if (n_parents <= PARENTS_PER_COMMIT)
return (git_commit_list_node **)((char *)commit + sizeof(git_commit_list_node));
return (git_commit_list_node **)git_pool_malloc(
&walk->commit_pool, (uint32_t)(n_parents * sizeof(git_commit_list_node *)));
}
void git_commit_list_free(git_commit_list **list_p)
{
git_commit_list *list = *list_p;
if (list == NULL)
return;
while (list) {
git_commit_list *temp = list;
list = temp->next;
git__free(temp);
}
*list_p = NULL;
}
git_commit_list_node *git_commit_list_pop(git_commit_list **stack)
{
git_commit_list *top = *stack;
git_commit_list_node *item = top ? top->item : NULL;
if (top) {
*stack = top->next;
git__free(top);
}
return item;
}
static int commit_quick_parse(git_revwalk *walk, git_commit_list_node *commit, git_rawobj *raw)
{
const size_t parent_len = strlen("parent ") + GIT_OID_HEXSZ + 1;
unsigned char *buffer = raw->data;
unsigned char *buffer_end = buffer + raw->len;
unsigned char *parents_start, *committer_start;
int i, parents = 0;
int commit_time;
buffer += strlen("tree ") + GIT_OID_HEXSZ + 1;
parents_start = buffer;
while (buffer + parent_len < buffer_end && memcmp(buffer, "parent ", strlen("parent ")) == 0) {
parents++;
buffer += parent_len;
}
commit->parents = alloc_parents(walk, commit, parents);
GITERR_CHECK_ALLOC(commit->parents);
buffer = parents_start;
for (i = 0; i < parents; ++i) {
git_oid oid;
if (git_oid_fromstr(&oid, (char *)buffer + strlen("parent ")) < 0)
return -1;
commit->parents[i] = commit_lookup(walk, &oid);
if (commit->parents[i] == NULL)
return -1;
buffer += parent_len;
}
commit->out_degree = (unsigned short)parents;
if ((committer_start = buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
return commit_error(commit, "object is corrupted");
buffer++;
if ((buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
return commit_error(commit, "object is corrupted");
/* Skip trailing spaces */
while (buffer > committer_start && git__isspace(*buffer))
buffer--;
/* Seek for the begining of the pack of digits */
while (buffer > committer_start && git__isdigit(*buffer))
buffer--;
/* Skip potential timezone offset */
if ((buffer > committer_start) && (*buffer == '+' || *buffer == '-')) {
buffer--;
while (buffer > committer_start && git__isspace(*buffer))
buffer--;
while (buffer > committer_start && git__isdigit(*buffer))
buffer--;
}
if ((buffer == committer_start) || (git__strtol32(&commit_time, (char *)(buffer + 1), NULL, 10) < 0))
return commit_error(commit, "cannot parse commit time");
commit->time = (time_t)commit_time;
commit->parsed = 1;
return 0;
}
int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
{
git_odb_object *obj;
int error;
if (commit->parsed)
return 0;
if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0)
return error;
assert(obj->raw.type == GIT_OBJ_COMMIT);
error = commit_quick_parse(walk, commit, &obj->raw);
git_odb_object_free(obj);
return error;
}

49
src/commit_list.h Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_commit_list_h__
#define INCLUDE_commit_list_h__
#include "git2/oid.h"
#define PARENT1 (1 << 0)
#define PARENT2 (1 << 1)
#define RESULT (1 << 2)
#define STALE (1 << 3)
#define PARENTS_PER_COMMIT 2
#define COMMIT_ALLOC \
(sizeof(git_commit_list_node) + PARENTS_PER_COMMIT * sizeof(git_commit_list_node *))
typedef struct git_commit_list_node {
git_oid oid;
uint32_t time;
unsigned int seen:1,
uninteresting:1,
topo_delay:1,
parsed:1,
flags : 4;
unsigned short in_degree;
unsigned short out_degree;
struct git_commit_list_node **parents;
} git_commit_list_node;
typedef struct git_commit_list {
git_commit_list_node *item;
struct git_commit_list *next;
} git_commit_list;
git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk);
int git_commit_list_time_cmp(void *a, void *b);
void git_commit_list_free(git_commit_list **list_p);
git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p);
git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p);
int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit);
git_commit_list_node *git_commit_list_pop(git_commit_list **stack);
#endif

74
src/config.c
View File

@ -19,13 +19,13 @@
typedef struct { typedef struct {
git_refcount rc; git_refcount rc;
git_config_file *file; git_config_backend *file;
unsigned int level; unsigned int level;
} file_internal; } file_internal;
static void file_internal_free(file_internal *internal) static void file_internal_free(file_internal *internal)
{ {
git_config_file *file; git_config_backend *file;
file = internal->file; file = internal->file;
file->free(file); file->free(file);
@ -87,7 +87,7 @@ int git_config_add_file_ondisk(
unsigned int level, unsigned int level,
int force) int force)
{ {
git_config_file *file = NULL; git_config_backend *file = NULL;
int res; int res;
assert(cfg && path); assert(cfg && path);
@ -100,7 +100,7 @@ int git_config_add_file_ondisk(
if (git_config_file__ondisk(&file, path) < 0) if (git_config_file__ondisk(&file, path) < 0)
return -1; return -1;
if ((res = git_config_add_file(cfg, file, level, force)) < 0) { if ((res = git_config_add_backend(cfg, file, level, force)) < 0) {
/* /*
* free manually; the file is not owned by the config * free manually; the file is not owned by the config
* instance yet and will not be freed on cleanup * instance yet and will not be freed on cleanup
@ -132,7 +132,7 @@ int git_config_open_ondisk(git_config **out, const char *path)
static int find_internal_file_by_level( static int find_internal_file_by_level(
file_internal **internal_out, file_internal **internal_out,
git_config *cfg, const git_config *cfg,
int level) int level)
{ {
int pos = -1; int pos = -1;
@ -224,7 +224,7 @@ static int git_config__add_internal(
int git_config_open_level( int git_config_open_level(
git_config **cfg_out, git_config **cfg_out,
git_config *cfg_parent, const git_config *cfg_parent,
unsigned int level) unsigned int level)
{ {
git_config *cfg; git_config *cfg;
@ -247,9 +247,9 @@ int git_config_open_level(
return 0; return 0;
} }
int git_config_add_file( int git_config_add_backend(
git_config *cfg, git_config *cfg,
git_config_file *file, git_config_backend *file,
unsigned int level, unsigned int level,
int force) int force)
{ {
@ -284,7 +284,7 @@ int git_config_refresh(git_config *cfg)
for (i = 0; i < cfg->files.length && !error; ++i) { for (i = 0; i < cfg->files.length && !error; ++i) {
file_internal *internal = git_vector_get(&cfg->files, i); file_internal *internal = git_vector_get(&cfg->files, i);
git_config_file *file = internal->file; git_config_backend *file = internal->file;
error = file->refresh(file); error = file->refresh(file);
} }
@ -296,34 +296,34 @@ int git_config_refresh(git_config *cfg)
*/ */
int git_config_foreach( int git_config_foreach(
git_config *cfg, int (*fn)(const git_config_entry *, void *), void *data) const git_config *cfg, git_config_foreach_cb cb, void *payload)
{ {
return git_config_foreach_match(cfg, NULL, fn, data); return git_config_foreach_match(cfg, NULL, cb, payload);
} }
int git_config_foreach_match( int git_config_foreach_match(
git_config *cfg, const git_config *cfg,
const char *regexp, const char *regexp,
int (*fn)(const git_config_entry *, void *), git_config_foreach_cb cb,
void *data) void *payload)
{ {
int ret = 0; int ret = 0;
unsigned int i; unsigned int i;
file_internal *internal; file_internal *internal;
git_config_file *file; git_config_backend *file;
for (i = 0; i < cfg->files.length && ret == 0; ++i) { for (i = 0; i < cfg->files.length && ret == 0; ++i) {
internal = git_vector_get(&cfg->files, i); internal = git_vector_get(&cfg->files, i);
file = internal->file; file = internal->file;
ret = file->foreach(file, regexp, fn, data); ret = file->foreach(file, regexp, cb, payload);
} }
return ret; return ret;
} }
int git_config_delete(git_config *cfg, const char *name) int git_config_delete_entry(git_config *cfg, const char *name)
{ {
git_config_file *file; git_config_backend *file;
file_internal *internal; file_internal *internal;
internal = git_vector_get(&cfg->files, 0); internal = git_vector_get(&cfg->files, 0);
@ -355,7 +355,7 @@ int git_config_set_bool(git_config *cfg, const char *name, int value)
int git_config_set_string(git_config *cfg, const char *name, const char *value) int git_config_set_string(git_config *cfg, const char *name, const char *value)
{ {
git_config_file *file; git_config_backend *file;
file_internal *internal; file_internal *internal;
internal = git_vector_get(&cfg->files, 0); internal = git_vector_get(&cfg->files, 0);
@ -369,9 +369,9 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
***********/ ***********/
int git_config_get_mapped( int git_config_get_mapped(
int *out, int *out,
git_config *cfg, const git_config *cfg,
const char *name, const char *name,
git_cvar_map *maps, const git_cvar_map *maps,
size_t map_n) size_t map_n)
{ {
const char *value; const char *value;
@ -383,7 +383,7 @@ int git_config_get_mapped(
return git_config_lookup_map_value(out, maps, map_n, value); return git_config_lookup_map_value(out, maps, map_n, value);
} }
int git_config_get_int64(int64_t *out, git_config *cfg, const char *name) int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
{ {
const char *value; const char *value;
int ret; int ret;
@ -394,7 +394,7 @@ int git_config_get_int64(int64_t *out, git_config *cfg, const char *name)
return git_config_parse_int64(out, value); return git_config_parse_int64(out, value);
} }
int git_config_get_int32(int32_t *out, git_config *cfg, const char *name) int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
{ {
const char *value; const char *value;
int ret; int ret;
@ -405,7 +405,7 @@ int git_config_get_int32(int32_t *out, git_config *cfg, const char *name)
return git_config_parse_int32(out, value); return git_config_parse_int32(out, value);
} }
static int get_string_at_file(const char **out, git_config_file *file, const char *name) static int get_string_at_file(const char **out, const git_config_backend *file, const char *name)
{ {
const git_config_entry *entry; const git_config_entry *entry;
int res; int res;
@ -417,7 +417,7 @@ static int get_string_at_file(const char **out, git_config_file *file, const cha
return res; return res;
} }
static int get_string(const char **out, git_config *cfg, const char *name) static int get_string(const char **out, const git_config *cfg, const char *name)
{ {
file_internal *internal; file_internal *internal;
unsigned int i; unsigned int i;
@ -434,7 +434,7 @@ static int get_string(const char **out, git_config *cfg, const char *name)
return GIT_ENOTFOUND; return GIT_ENOTFOUND;
} }
int git_config_get_bool(int *out, git_config *cfg, const char *name) int git_config_get_bool(int *out, const git_config *cfg, const char *name)
{ {
const char *value = NULL; const char *value = NULL;
int ret; int ret;
@ -445,7 +445,7 @@ int git_config_get_bool(int *out, git_config *cfg, const char *name)
return git_config_parse_bool(out, value); return git_config_parse_bool(out, value);
} }
int git_config_get_string(const char **out, git_config *cfg, const char *name) int git_config_get_string(const char **out, const git_config *cfg, const char *name)
{ {
int ret; int ret;
const char *str = NULL; const char *str = NULL;
@ -457,7 +457,7 @@ int git_config_get_string(const char **out, git_config *cfg, const char *name)
return 0; return 0;
} }
int git_config_get_entry(const git_config_entry **out, git_config *cfg, const char *name) int git_config_get_entry(const git_config_entry **out, const git_config *cfg, const char *name)
{ {
file_internal *internal; file_internal *internal;
unsigned int i; unsigned int i;
@ -467,7 +467,7 @@ int git_config_get_entry(const git_config_entry **out, git_config *cfg, const ch
*out = NULL; *out = NULL;
git_vector_foreach(&cfg->files, i, internal) { git_vector_foreach(&cfg->files, i, internal) {
git_config_file *file = internal->file; git_config_backend *file = internal->file;
int ret = file->get(file, name, out); int ret = file->get(file, name, out);
if (ret != GIT_ENOTFOUND) if (ret != GIT_ENOTFOUND)
return ret; return ret;
@ -476,11 +476,11 @@ int git_config_get_entry(const git_config_entry **out, git_config *cfg, const ch
return GIT_ENOTFOUND; return GIT_ENOTFOUND;
} }
int git_config_get_multivar(git_config *cfg, const char *name, const char *regexp, int git_config_get_multivar(const git_config *cfg, const char *name, const char *regexp,
int (*fn)(const git_config_entry *entry, void *data), void *data) git_config_foreach_cb cb, void *payload)
{ {
file_internal *internal; file_internal *internal;
git_config_file *file; git_config_backend *file;
int ret = GIT_ENOTFOUND; int ret = GIT_ENOTFOUND;
size_t i; size_t i;
@ -493,7 +493,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
for (i = cfg->files.length; i > 0; --i) { for (i = cfg->files.length; i > 0; --i) {
internal = git_vector_get(&cfg->files, i - 1); internal = git_vector_get(&cfg->files, i - 1);
file = internal->file; file = internal->file;
ret = file->get_multivar(file, name, regexp, fn, data); ret = file->get_multivar(file, name, regexp, cb, payload);
if (ret < 0 && ret != GIT_ENOTFOUND) if (ret < 0 && ret != GIT_ENOTFOUND)
return ret; return ret;
} }
@ -503,7 +503,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value) int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
{ {
git_config_file *file; git_config_backend *file;
file_internal *internal; file_internal *internal;
internal = git_vector_get(&cfg->files, 0); internal = git_vector_get(&cfg->files, 0);
@ -634,7 +634,7 @@ int git_config_open_default(git_config **out)
***********/ ***********/
int git_config_lookup_map_value( int git_config_lookup_map_value(
int *out, int *out,
git_cvar_map *maps, const git_cvar_map *maps,
size_t map_n, size_t map_n,
const char *value) const char *value)
{ {
@ -644,7 +644,7 @@ int git_config_lookup_map_value(
goto fail_parse; goto fail_parse;
for (i = 0; i < map_n; ++i) { for (i = 0; i < map_n; ++i) {
git_cvar_map *m = maps + i; const git_cvar_map *m = maps + i;
switch (m->cvar_type) { switch (m->cvar_type) {
case GIT_CVAR_FALSE: case GIT_CVAR_FALSE:
@ -790,7 +790,7 @@ static int rename_config_entries_cb(
return error; return error;
} }
return git_config_delete(data->config, entry->name); return git_config_delete_entry(data->config, entry->name);
} }
int git_config_rename_section( int git_config_rename_section(

2
src/config.h
View File

@ -43,6 +43,6 @@ extern int git_config_rename_section(
* @param out the new backend * @param out the new backend
* @param path where the config file is located * @param path where the config file is located
*/ */
extern int git_config_file__ondisk(struct git_config_file **out, const char *path); extern int git_config_file__ondisk(struct git_config_backend **out, const char *path);
#endif #endif

24
src/config_file.c
View File

@ -64,7 +64,7 @@ typedef struct cvar_t {
(iter) = (tmp)) (iter) = (tmp))
typedef struct { typedef struct {
git_config_file parent; git_config_backend parent;
git_strmap *values; git_strmap *values;
@ -149,7 +149,7 @@ static void free_vars(git_strmap *values)
git_strmap_free(values); git_strmap_free(values);
} }
static int config_open(git_config_file *cfg, unsigned int level) static int config_open(git_config_backend *cfg, unsigned int level)
{ {
int res; int res;
diskfile_backend *b = (diskfile_backend *)cfg; diskfile_backend *b = (diskfile_backend *)cfg;
@ -176,7 +176,7 @@ static int config_open(git_config_file *cfg, unsigned int level)
return res; return res;
} }
static int config_refresh(git_config_file *cfg) static int config_refresh(git_config_backend *cfg)
{ {
int res, updated = 0; int res, updated = 0;
diskfile_backend *b = (diskfile_backend *)cfg; diskfile_backend *b = (diskfile_backend *)cfg;
@ -203,7 +203,7 @@ static int config_refresh(git_config_file *cfg)
return res; return res;
} }
static void backend_free(git_config_file *_backend) static void backend_free(git_config_backend *_backend)
{ {
diskfile_backend *backend = (diskfile_backend *)_backend; diskfile_backend *backend = (diskfile_backend *)_backend;
@ -216,7 +216,7 @@ static void backend_free(git_config_file *_backend)
} }
static int file_foreach( static int file_foreach(
git_config_file *backend, git_config_backend *backend,
const char *regexp, const char *regexp,
int (*fn)(const git_config_entry *, void *), int (*fn)(const git_config_entry *, void *),
void *data) void *data)
@ -262,7 +262,7 @@ cleanup:
return result; return result;
} }
static int config_set(git_config_file *cfg, const char *name, const char *value) static int config_set(git_config_backend *cfg, const char *name, const char *value)
{ {
cvar_t *var = NULL, *old_var; cvar_t *var = NULL, *old_var;
diskfile_backend *b = (diskfile_backend *)cfg; diskfile_backend *b = (diskfile_backend *)cfg;
@ -346,7 +346,7 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
/* /*
* Internal function that actually gets the value in string form * Internal function that actually gets the value in string form
*/ */
static int config_get(git_config_file *cfg, const char *name, const git_config_entry **out) static int config_get(const git_config_backend *cfg, const char *name, const git_config_entry **out)
{ {
diskfile_backend *b = (diskfile_backend *)cfg; diskfile_backend *b = (diskfile_backend *)cfg;
char *key; char *key;
@ -368,7 +368,7 @@ static int config_get(git_config_file *cfg, const char *name, const git_config_e
} }
static int config_get_multivar( static int config_get_multivar(
git_config_file *cfg, git_config_backend *cfg,
const char *name, const char *name,
const char *regex_str, const char *regex_str,
int (*fn)(const git_config_entry *, void *), int (*fn)(const git_config_entry *, void *),
@ -431,7 +431,7 @@ static int config_get_multivar(
} }
static int config_set_multivar( static int config_set_multivar(
git_config_file *cfg, const char *name, const char *regexp, const char *value) git_config_backend *cfg, const char *name, const char *regexp, const char *value)
{ {
int replaced = 0; int replaced = 0;
cvar_t *var, *newvar; cvar_t *var, *newvar;
@ -506,7 +506,7 @@ static int config_set_multivar(
return result; return result;
} }
static int config_delete(git_config_file *cfg, const char *name) static int config_delete(git_config_backend *cfg, const char *name)
{ {
cvar_t *var; cvar_t *var;
diskfile_backend *b = (diskfile_backend *)cfg; diskfile_backend *b = (diskfile_backend *)cfg;
@ -540,7 +540,7 @@ static int config_delete(git_config_file *cfg, const char *name)
return result; return result;
} }
int git_config_file__ondisk(git_config_file **out, const char *path) int git_config_file__ondisk(git_config_backend **out, const char *path)
{ {
diskfile_backend *backend; diskfile_backend *backend;
@ -562,7 +562,7 @@ int git_config_file__ondisk(git_config_file **out, const char *path)
backend->parent.refresh = config_refresh; backend->parent.refresh = config_refresh;
backend->parent.free = backend_free; backend->parent.free = backend_free;
*out = (git_config_file *)backend; *out = (git_config_backend *)backend;
return 0; return 0;
} }

14
src/config_file.h
View File

@ -9,36 +9,36 @@
#include "git2/config.h" #include "git2/config.h"
GIT_INLINE(int) git_config_file_open(git_config_file *cfg, unsigned int level) GIT_INLINE(int) git_config_file_open(git_config_backend *cfg, unsigned int level)
{ {
return cfg->open(cfg, level); return cfg->open(cfg, level);
} }
GIT_INLINE(void) git_config_file_free(git_config_file *cfg) GIT_INLINE(void) git_config_file_free(git_config_backend *cfg)
{ {
cfg->free(cfg); cfg->free(cfg);
} }
GIT_INLINE(int) git_config_file_get_string( GIT_INLINE(int) git_config_file_get_string(
const git_config_entry **out, git_config_file *cfg, const char *name) const git_config_entry **out, git_config_backend *cfg, const char *name)
{ {
return cfg->get(cfg, name, out); return cfg->get(cfg, name, out);
} }
GIT_INLINE(int) git_config_file_set_string( GIT_INLINE(int) git_config_file_set_string(
git_config_file *cfg, const char *name, const char *value) git_config_backend *cfg, const char *name, const char *value)
{ {
return cfg->set(cfg, name, value); return cfg->set(cfg, name, value);
} }
GIT_INLINE(int) git_config_file_delete( GIT_INLINE(int) git_config_file_delete(
git_config_file *cfg, const char *name) git_config_backend *cfg, const char *name)
{ {
return cfg->del(cfg, name); return cfg->del(cfg, name);
} }
GIT_INLINE(int) git_config_file_foreach( GIT_INLINE(int) git_config_file_foreach(
git_config_file *cfg, git_config_backend *cfg,
int (*fn)(const git_config_entry *entry, void *data), int (*fn)(const git_config_entry *entry, void *data),
void *data) void *data)
{ {
@ -46,7 +46,7 @@ GIT_INLINE(int) git_config_file_foreach(
} }
GIT_INLINE(int) git_config_file_foreach_match( GIT_INLINE(int) git_config_file_foreach_match(
git_config_file *cfg, git_config_backend *cfg,
const char *regexp, const char *regexp,
int (*fn)(const git_config_entry *entry, void *data), int (*fn)(const git_config_entry *entry, void *data),
void *data) void *data)

21
src/delta.c
View File

@ -148,7 +148,7 @@ git_delta_create_index(const void *buf, unsigned long bufsize)
/* Determine index hash size. Note that indexing skips the /* Determine index hash size. Note that indexing skips the
first byte to allow for optimizing the Rabin's polynomial first byte to allow for optimizing the Rabin's polynomial
initialization in create_delta(). */ initialization in create_delta(). */
entries = (bufsize - 1) / RABIN_WINDOW; entries = (unsigned int)(bufsize - 1) / RABIN_WINDOW;
if (bufsize >= 0xffffffffUL) { if (bufsize >= 0xffffffffUL) {
/* /*
* Current delta format can't encode offsets into * Current delta format can't encode offsets into
@ -317,9 +317,12 @@ unsigned long git_delta_sizeof_index(struct git_delta_index *index)
#define MAX_OP_SIZE (5 + 5 + 1 + RABIN_WINDOW + 7) #define MAX_OP_SIZE (5 + 5 + 1 + RABIN_WINDOW + 7)
void * void *
git_delta_create(const struct git_delta_index *index, git_delta_create(
const void *trg_buf, unsigned long trg_size, const struct git_delta_index *index,
unsigned long *delta_size, unsigned long max_size) const void *trg_buf,
unsigned long trg_size,
unsigned long *delta_size,
unsigned long max_size)
{ {
unsigned int i, outpos, outsize, moff, msize, val; unsigned int i, outpos, outsize, moff, msize, val;
int inscnt; int inscnt;
@ -332,7 +335,7 @@ git_delta_create(const struct git_delta_index *index,
outpos = 0; outpos = 0;
outsize = 8192; outsize = 8192;
if (max_size && outsize >= max_size) if (max_size && outsize >= max_size)
outsize = max_size + MAX_OP_SIZE + 1; outsize = (unsigned int)(max_size + MAX_OP_SIZE + 1);
out = git__malloc(outsize); out = git__malloc(outsize);
if (!out) if (!out)
return NULL; return NULL;
@ -377,19 +380,19 @@ git_delta_create(const struct git_delta_index *index,
for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) { for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) {
const unsigned char *ref = entry->ptr; const unsigned char *ref = entry->ptr;
const unsigned char *src = data; const unsigned char *src = data;
unsigned int ref_size = ref_top - ref; unsigned int ref_size = (unsigned int)(ref_top - ref);
if (entry->val != val) if (entry->val != val)
continue; continue;
if (ref_size > (unsigned int)(top - src)) if (ref_size > (unsigned int)(top - src))
ref_size = top - src; ref_size = (unsigned int)(top - src);
if (ref_size <= msize) if (ref_size <= msize)
break; break;
while (ref_size-- && *src++ == *ref) while (ref_size-- && *src++ == *ref)
ref++; ref++;
if (msize < (unsigned int)(ref - entry->ptr)) { if (msize < (unsigned int)(ref - entry->ptr)) {
/* this is our best match so far */ /* this is our best match so far */
msize = ref - entry->ptr; msize = (unsigned int)(ref - entry->ptr);
moff = entry->ptr - ref_data; moff = (unsigned int)(entry->ptr - ref_data);
if (msize >= 4096) /* good enough */ if (msize >= 4096) /* good enough */
break; break;
} }

26
src/delta.h
View File

@ -46,9 +46,10 @@ extern unsigned long git_delta_sizeof_index(struct git_delta_index *index);
* returned and *delta_size is updated with its size. The returned buffer * returned and *delta_size is updated with its size. The returned buffer
* must be freed by the caller. * must be freed by the caller.
*/ */
extern void * extern void *git_delta_create(
git_delta_create(const struct git_delta_index *index, const struct git_delta_index *index,
const void *buf, unsigned long bufsize, const void *buf,
unsigned long bufsize,
unsigned long *delta_size, unsigned long *delta_size,
unsigned long max_delta_size); unsigned long max_delta_size);
@ -60,15 +61,16 @@ git_delta_create(const struct git_delta_index *index,
* pointer to the buffer with the delta data is returned and *delta_size is * pointer to the buffer with the delta data is returned and *delta_size is
* updated with its size. The returned buffer must be freed by the caller. * updated with its size. The returned buffer must be freed by the caller.
*/ */
GIT_INLINE(void *) GIT_INLINE(void *) git_delta(
git_delta(const void *src_buf, unsigned long src_bufsize, const void *src_buf, unsigned long src_bufsize,
const void *trg_buf, unsigned long trg_bufsize, const void *trg_buf, unsigned long trg_bufsize,
unsigned long *delta_size, unsigned long max_delta_size) unsigned long *delta_size,
unsigned long max_delta_size)
{ {
struct git_delta_index *index = git_delta_create_index(src_buf, src_bufsize); struct git_delta_index *index = git_delta_create_index(src_buf, src_bufsize);
if (index) { if (index) {
void *delta = git_delta_create(index, trg_buf, trg_bufsize, void *delta = git_delta_create(
delta_size, max_delta_size); index, trg_buf, trg_bufsize, delta_size, max_delta_size);
git_delta_free_index(index); git_delta_free_index(index);
return delta; return delta;
} }
@ -82,7 +84,8 @@ git_delta(const void *src_buf, unsigned long src_bufsize,
* *trg_bufsize is updated with its size. On failure a NULL pointer is * *trg_bufsize is updated with its size. On failure a NULL pointer is
* returned. The returned buffer must be freed by the caller. * returned. The returned buffer must be freed by the caller.
*/ */
extern void *git_delta_patch(const void *src_buf, unsigned long src_size, extern void *git_delta_patch(
const void *src_buf, unsigned long src_size,
const void *delta_buf, unsigned long delta_size, const void *delta_buf, unsigned long delta_size,
unsigned long *dst_size); unsigned long *dst_size);
@ -93,9 +96,8 @@ extern void *git_delta_patch(const void *src_buf, unsigned long src_size,
* This must be called twice on the delta data buffer, first to get the * This must be called twice on the delta data buffer, first to get the
* expected source buffer size, and again to get the target buffer size. * expected source buffer size, and again to get the target buffer size.
*/ */
GIT_INLINE(unsigned long) GIT_INLINE(unsigned long) git_delta_get_hdr_size(
git_delta_get_hdr_size(const unsigned char **datap, const unsigned char **datap, const unsigned char *top)
const unsigned char *top)
{ {
const unsigned char *data = *datap; const unsigned char *data = *datap;
unsigned long cmd, size = 0; unsigned long cmd, size = 0;

4
src/diff.c
View File

@ -363,7 +363,7 @@ int git_diff__oid_for_file(
const git_oid *sm_oid; const git_oid *sm_oid;
if (!git_submodule_lookup(&sm, repo, path) && if (!git_submodule_lookup(&sm, repo, path) &&
(sm_oid = git_submodule_wd_oid(sm)) != NULL) (sm_oid = git_submodule_wd_id(sm)) != NULL)
git_oid_cpy(oid, sm_oid); git_oid_cpy(oid, sm_oid);
else { else {
/* if submodule lookup failed probably just in an intermediate /* if submodule lookup failed probably just in an intermediate
@ -496,7 +496,7 @@ static int maybe_modified(
/* grab OID while we are here */ /* grab OID while we are here */
if (git_oid_iszero(&nitem->oid)) { if (git_oid_iszero(&nitem->oid)) {
const git_oid *sm_oid = git_submodule_wd_oid(sub); const git_oid *sm_oid = git_submodule_wd_id(sub);
if (sm_oid != NULL) { if (sm_oid != NULL) {
git_oid_cpy(&noid, sm_oid); git_oid_cpy(&noid, sm_oid);
use_noid = &noid; use_noid = &noid;

189
src/diff_output.c
View File

@ -262,7 +262,7 @@ static int get_blob_content(
return error; return error;
map->data = (void *)git_blob_rawcontent(*blob); map->data = (void *)git_blob_rawcontent(*blob);
map->len = git_blob_rawsize(*blob); map->len = (size_t)git_blob_rawsize(*blob);
return diff_delta_is_binary_by_content(ctxt, delta, file, map); return diff_delta_is_binary_by_content(ctxt, delta, file, map);
} }
@ -287,8 +287,8 @@ static int get_workdir_sm_content(
if ((file->flags & GIT_DIFF_FILE_VALID_OID) == 0) { if ((file->flags & GIT_DIFF_FILE_VALID_OID) == 0) {
const git_oid* sm_head; const git_oid* sm_head;
if ((sm_head = git_submodule_wd_oid(sm)) != NULL || if ((sm_head = git_submodule_wd_id(sm)) != NULL ||
(sm_head = git_submodule_head_oid(sm)) != NULL) (sm_head = git_submodule_head_id(sm)) != NULL)
{ {
git_oid_cpy(&file->oid, sm_head); git_oid_cpy(&file->oid, sm_head);
file->flags |= GIT_DIFF_FILE_VALID_OID; file->flags |= GIT_DIFF_FILE_VALID_OID;
@ -440,10 +440,10 @@ static void diff_context_init(
git_diff_list *diff, git_diff_list *diff,
git_repository *repo, git_repository *repo,
const git_diff_options *opts, const git_diff_options *opts,
void *data, git_diff_file_cb file_cb,
git_diff_file_fn file_cb, git_diff_hunk_cb hunk_cb,
git_diff_hunk_fn hunk_cb, git_diff_data_cb data_cb,
git_diff_data_fn data_cb) void *payload)
{ {
memset(ctxt, 0, sizeof(diff_context)); memset(ctxt, 0, sizeof(diff_context));
@ -453,8 +453,8 @@ static void diff_context_init(
ctxt->file_cb = file_cb; ctxt->file_cb = file_cb;
ctxt->hunk_cb = hunk_cb; ctxt->hunk_cb = hunk_cb;
ctxt->data_cb = data_cb; ctxt->data_cb = data_cb;
ctxt->cb_data = data; ctxt->payload = payload;
ctxt->cb_error = 0; ctxt->error = 0;
setup_xdiff_options(ctxt->opts, &ctxt->xdiff_config, &ctxt->xdiff_params); setup_xdiff_options(ctxt->opts, &ctxt->xdiff_config, &ctxt->xdiff_params);
} }
@ -469,10 +469,10 @@ static int diff_delta_file_callback(
progress = ctxt->diff ? ((float)idx / ctxt->diff->deltas.length) : 1.0f; progress = ctxt->diff ? ((float)idx / ctxt->diff->deltas.length) : 1.0f;
if (ctxt->file_cb(ctxt->cb_data, delta, progress) != 0) if (ctxt->file_cb(delta, progress, ctxt->payload) != 0)
ctxt->cb_error = GIT_EUSER; ctxt->error = GIT_EUSER;
return ctxt->cb_error; return ctxt->error;
} }
static void diff_patch_init( static void diff_patch_init(
@ -643,14 +643,14 @@ static int diff_patch_cb(void *priv, mmbuffer_t *bufs, int len)
diff_context *ctxt = patch->ctxt; diff_context *ctxt = patch->ctxt;
if (len == 1) { if (len == 1) {
ctxt->cb_error = parse_hunk_header(&ctxt->cb_range, bufs[0].ptr); ctxt->error = parse_hunk_header(&ctxt->range, bufs[0].ptr);
if (ctxt->cb_error < 0) if (ctxt->error < 0)
return ctxt->cb_error; return ctxt->error;
if (ctxt->hunk_cb != NULL && if (ctxt->hunk_cb != NULL &&
ctxt->hunk_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range, ctxt->hunk_cb(patch->delta, &ctxt->range,
bufs[0].ptr, bufs[0].size)) bufs[0].ptr, bufs[0].size, ctxt->payload))
ctxt->cb_error = GIT_EUSER; ctxt->error = GIT_EUSER;
} }
if (len == 2 || len == 3) { if (len == 2 || len == 3) {
@ -661,12 +661,12 @@ static int diff_patch_cb(void *priv, mmbuffer_t *bufs, int len)
GIT_DIFF_LINE_CONTEXT; GIT_DIFF_LINE_CONTEXT;
if (ctxt->data_cb != NULL && if (ctxt->data_cb != NULL &&
ctxt->data_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range, ctxt->data_cb(patch->delta, &ctxt->range,
origin, bufs[1].ptr, bufs[1].size)) origin, bufs[1].ptr, bufs[1].size, ctxt->payload))
ctxt->cb_error = GIT_EUSER; ctxt->error = GIT_EUSER;
} }
if (len == 3 && !ctxt->cb_error) { if (len == 3 && !ctxt->error) {
/* If we have a '+' and a third buf, then we have added a line /* If we have a '+' and a third buf, then we have added a line
* without a newline and the old code had one, so DEL_EOFNL. * without a newline and the old code had one, so DEL_EOFNL.
* If we have a '-' and a third buf, then we have removed a line * If we have a '-' and a third buf, then we have removed a line
@ -678,12 +678,12 @@ static int diff_patch_cb(void *priv, mmbuffer_t *bufs, int len)
GIT_DIFF_LINE_CONTEXT; GIT_DIFF_LINE_CONTEXT;
if (ctxt->data_cb != NULL && if (ctxt->data_cb != NULL &&
ctxt->data_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range, ctxt->data_cb(patch->delta, &ctxt->range,
origin, bufs[2].ptr, bufs[2].size)) origin, bufs[2].ptr, bufs[2].size, ctxt->payload))
ctxt->cb_error = GIT_EUSER; ctxt->error = GIT_EUSER;
} }
return ctxt->cb_error; return ctxt->error;
} }
static int diff_patch_generate( static int diff_patch_generate(
@ -720,7 +720,7 @@ static int diff_patch_generate(
xdl_diff(&old_xdiff_data, &new_xdiff_data, xdl_diff(&old_xdiff_data, &new_xdiff_data,
&ctxt->xdiff_params, &ctxt->xdiff_config, &xdiff_callback); &ctxt->xdiff_params, &ctxt->xdiff_config, &xdiff_callback);
error = ctxt->cb_error; error = ctxt->error;
if (!error) if (!error)
patch->flags |= GIT_DIFF_PATCH_DIFFED; patch->flags |= GIT_DIFF_PATCH_DIFFED;
@ -775,13 +775,13 @@ static void diff_patch_free(git_diff_patch *patch)
#define MIN_LINE_STEP 8 #define MIN_LINE_STEP 8
static int diff_patch_hunk_cb( static int diff_patch_hunk_cb(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
const char *header, const char *header,
size_t header_len) size_t header_len,
void *payload)
{ {
git_diff_patch *patch = cb_data; git_diff_patch *patch = payload;
diff_patch_hunk *hunk; diff_patch_hunk *hunk;
GIT_UNUSED(delta); GIT_UNUSED(delta);
@ -822,14 +822,14 @@ static int diff_patch_hunk_cb(
} }
static int diff_patch_line_cb( static int diff_patch_line_cb(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
char line_origin, char line_origin,
const char *content, const char *content,
size_t content_len) size_t content_len,
void *payload)
{ {
git_diff_patch *patch = cb_data; git_diff_patch *patch = payload;
diff_patch_hunk *hunk; diff_patch_hunk *hunk;
diff_patch_line *last, *line; diff_patch_line *last, *line;
@ -904,10 +904,10 @@ static int diff_patch_line_cb(
int git_diff_foreach( int git_diff_foreach(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_file_cb file_cb,
git_diff_file_fn file_cb, git_diff_hunk_cb hunk_cb,
git_diff_hunk_fn hunk_cb, git_diff_data_cb data_cb,
git_diff_data_fn data_cb) void *payload)
{ {
int error = 0; int error = 0;
diff_context ctxt; diff_context ctxt;
@ -916,7 +916,7 @@ int git_diff_foreach(
diff_context_init( diff_context_init(
&ctxt, diff, diff->repo, &diff->opts, &ctxt, diff, diff->repo, &diff->opts,
cb_data, file_cb, hunk_cb, data_cb); file_cb, hunk_cb, data_cb, payload);
diff_patch_init(&ctxt, &patch); diff_patch_init(&ctxt, &patch);
@ -951,8 +951,8 @@ int git_diff_foreach(
typedef struct { typedef struct {
git_diff_list *diff; git_diff_list *diff;
git_diff_data_fn print_cb; git_diff_data_cb print_cb;
void *cb_data; void *payload;
git_buf *buf; git_buf *buf;
} diff_print_info; } diff_print_info;
@ -986,7 +986,7 @@ char git_diff_status_char(git_delta_t status)
} }
static int print_compact( static int print_compact(
void *data, const git_diff_delta *delta, float progress) const git_diff_delta *delta, float progress, void *data)
{ {
diff_print_info *pi = data; diff_print_info *pi = data;
char old_suffix, new_suffix, code = git_diff_status_char(delta->status); char old_suffix, new_suffix, code = git_diff_status_char(delta->status);
@ -1017,8 +1017,8 @@ static int print_compact(
if (git_buf_oom(pi->buf)) if (git_buf_oom(pi->buf))
return -1; return -1;
if (pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_FILE_HDR, if (pi->print_cb(delta, NULL, GIT_DIFF_LINE_FILE_HDR,
git_buf_cstr(pi->buf), git_buf_len(pi->buf))) git_buf_cstr(pi->buf), git_buf_len(pi->buf), pi->payload))
{ {
giterr_clear(); giterr_clear();
return GIT_EUSER; return GIT_EUSER;
@ -1029,8 +1029,8 @@ static int print_compact(
int git_diff_print_compact( int git_diff_print_compact(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb) void *payload)
{ {
int error; int error;
git_buf buf = GIT_BUF_INIT; git_buf buf = GIT_BUF_INIT;
@ -1038,10 +1038,10 @@ int git_diff_print_compact(
pi.diff = diff; pi.diff = diff;
pi.print_cb = print_cb; pi.print_cb = print_cb;
pi.cb_data = cb_data; pi.payload = payload;
pi.buf = &buf; pi.buf = &buf;
error = git_diff_foreach(diff, &pi, print_compact, NULL, NULL); error = git_diff_foreach(diff, print_compact, NULL, NULL, &pi);
git_buf_free(&buf); git_buf_free(&buf);
@ -1079,7 +1079,7 @@ static int print_oid_range(diff_print_info *pi, const git_diff_delta *delta)
} }
static int print_patch_file( static int print_patch_file(
void *data, const git_diff_delta *delta, float progress) const git_diff_delta *delta, float progress, void *data)
{ {
diff_print_info *pi = data; diff_print_info *pi = data;
const char *oldpfx = pi->diff->opts.old_prefix; const char *oldpfx = pi->diff->opts.old_prefix;
@ -1121,7 +1121,8 @@ static int print_patch_file(
if (git_buf_oom(pi->buf)) if (git_buf_oom(pi->buf))
return -1; return -1;
if (pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_FILE_HDR, git_buf_cstr(pi->buf), git_buf_len(pi->buf))) if (pi->print_cb(delta, NULL, GIT_DIFF_LINE_FILE_HDR,
git_buf_cstr(pi->buf), git_buf_len(pi->buf), pi->payload))
{ {
giterr_clear(); giterr_clear();
return GIT_EUSER; return GIT_EUSER;
@ -1137,8 +1138,8 @@ static int print_patch_file(
if (git_buf_oom(pi->buf)) if (git_buf_oom(pi->buf))
return -1; return -1;
if (pi->print_cb(pi->cb_data, delta, NULL, GIT_DIFF_LINE_BINARY, if (pi->print_cb(delta, NULL, GIT_DIFF_LINE_BINARY,
git_buf_cstr(pi->buf), git_buf_len(pi->buf))) git_buf_cstr(pi->buf), git_buf_len(pi->buf), pi->payload))
{ {
giterr_clear(); giterr_clear();
return GIT_EUSER; return GIT_EUSER;
@ -1148,11 +1149,11 @@ static int print_patch_file(
} }
static int print_patch_hunk( static int print_patch_hunk(
void *data,
const git_diff_delta *d, const git_diff_delta *d,
const git_diff_range *r, const git_diff_range *r,
const char *header, const char *header,
size_t header_len) size_t header_len,
void *data)
{ {
diff_print_info *pi = data; diff_print_info *pi = data;
@ -1163,8 +1164,8 @@ static int print_patch_hunk(
if (git_buf_printf(pi->buf, "%.*s", (int)header_len, header) < 0) if (git_buf_printf(pi->buf, "%.*s", (int)header_len, header) < 0)
return -1; return -1;
if (pi->print_cb(pi->cb_data, d, r, GIT_DIFF_LINE_HUNK_HDR, if (pi->print_cb(d, r, GIT_DIFF_LINE_HUNK_HDR,
git_buf_cstr(pi->buf), git_buf_len(pi->buf))) git_buf_cstr(pi->buf), git_buf_len(pi->buf), pi->payload))
{ {
giterr_clear(); giterr_clear();
return GIT_EUSER; return GIT_EUSER;
@ -1174,12 +1175,12 @@ static int print_patch_hunk(
} }
static int print_patch_line( static int print_patch_line(
void *data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
char line_origin, /* GIT_DIFF_LINE value from above */ char line_origin, /* GIT_DIFF_LINE value from above */
const char *content, const char *content,
size_t content_len) size_t content_len,
void *data)
{ {
diff_print_info *pi = data; diff_print_info *pi = data;
@ -1198,8 +1199,8 @@ static int print_patch_line(
if (git_buf_oom(pi->buf)) if (git_buf_oom(pi->buf))
return -1; return -1;
if (pi->print_cb(pi->cb_data, delta, range, line_origin, if (pi->print_cb(delta, range, line_origin,
git_buf_cstr(pi->buf), git_buf_len(pi->buf))) git_buf_cstr(pi->buf), git_buf_len(pi->buf), pi->payload))
{ {
giterr_clear(); giterr_clear();
return GIT_EUSER; return GIT_EUSER;
@ -1210,8 +1211,8 @@ static int print_patch_line(
int git_diff_print_patch( int git_diff_print_patch(
git_diff_list *diff, git_diff_list *diff,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb) void *payload)
{ {
int error; int error;
git_buf buf = GIT_BUF_INIT; git_buf buf = GIT_BUF_INIT;
@ -1219,11 +1220,11 @@ int git_diff_print_patch(
pi.diff = diff; pi.diff = diff;
pi.print_cb = print_cb; pi.print_cb = print_cb;
pi.cb_data = cb_data; pi.payload = payload;
pi.buf = &buf; pi.buf = &buf;
error = git_diff_foreach( error = git_diff_foreach(
diff, &pi, print_patch_file, print_patch_hunk, print_patch_line); diff, print_patch_file, print_patch_hunk, print_patch_line, &pi);
git_buf_free(&buf); git_buf_free(&buf);
@ -1235,14 +1236,18 @@ static void set_data_from_blob(
git_blob *blob, git_map *map, git_diff_file *file) git_blob *blob, git_map *map, git_diff_file *file)
{ {
if (blob) { if (blob) {
map->data = (char *)git_blob_rawcontent(blob); file->size = git_blob_rawsize(blob);
file->size = map->len = git_blob_rawsize(blob);
git_oid_cpy(&file->oid, git_object_id((const git_object *)blob)); git_oid_cpy(&file->oid, git_object_id((const git_object *)blob));
file->mode = 0644; file->mode = 0644;
map->len = (size_t)file->size;
map->data = (char *)git_blob_rawcontent(blob);
} else { } else {
map->data = ""; file->size = 0;
file->size = map->len = 0;
file->flags |= GIT_DIFF_FILE_NO_DATA; file->flags |= GIT_DIFF_FILE_NO_DATA;
map->len = 0;
map->data = "";
} }
} }
@ -1250,10 +1255,10 @@ int git_diff_blobs(
git_blob *old_blob, git_blob *old_blob,
git_blob *new_blob, git_blob *new_blob,
const git_diff_options *options, const git_diff_options *options,
void *cb_data, git_diff_file_cb file_cb,
git_diff_file_fn file_cb, git_diff_hunk_cb hunk_cb,
git_diff_hunk_fn hunk_cb, git_diff_data_cb data_cb,
git_diff_data_fn data_cb) void *payload)
{ {
int error; int error;
git_repository *repo; git_repository *repo;
@ -1276,7 +1281,7 @@ int git_diff_blobs(
diff_context_init( diff_context_init(
&ctxt, NULL, repo, options, &ctxt, NULL, repo, options,
cb_data, file_cb, hunk_cb, data_cb); file_cb, hunk_cb, data_cb, payload);
diff_patch_init(&ctxt, &patch); diff_patch_init(&ctxt, &patch);
@ -1374,7 +1379,7 @@ int git_diff_get_patch(
diff_context_init( diff_context_init(
&ctxt, diff, diff->repo, &diff->opts, &ctxt, diff, diff->repo, &diff->opts,
NULL, NULL, diff_patch_hunk_cb, diff_patch_line_cb); NULL, diff_patch_hunk_cb, diff_patch_line_cb, NULL);
if (git_diff_delta__should_skip(ctxt.opts, delta)) if (git_diff_delta__should_skip(ctxt.opts, delta))
return 0; return 0;
@ -1384,12 +1389,12 @@ int git_diff_get_patch(
return -1; return -1;
if (!(error = diff_patch_load(&ctxt, patch))) { if (!(error = diff_patch_load(&ctxt, patch))) {
ctxt.cb_data = patch; ctxt.payload = patch;
error = diff_patch_generate(&ctxt, patch); error = diff_patch_generate(&ctxt, patch);
if (error == GIT_EUSER) if (error == GIT_EUSER)
error = ctxt.cb_error; error = ctxt.error;
} }
if (error) if (error)
@ -1503,22 +1508,22 @@ notfound:
} }
static int print_to_buffer_cb( static int print_to_buffer_cb(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
const git_diff_range *range, const git_diff_range *range,
char line_origin, char line_origin,
const char *content, const char *content,
size_t content_len) size_t content_len,
void *payload)
{ {
git_buf *output = cb_data; git_buf *output = payload;
GIT_UNUSED(delta); GIT_UNUSED(range); GIT_UNUSED(line_origin); GIT_UNUSED(delta); GIT_UNUSED(range); GIT_UNUSED(line_origin);
return git_buf_put(output, content, content_len); return git_buf_put(output, content, content_len);
} }
int git_diff_patch_print( int git_diff_patch_print(
git_diff_patch *patch, git_diff_patch *patch,
void *cb_data, git_diff_data_cb print_cb,
git_diff_data_fn print_cb) void *payload)
{ {
int error; int error;
git_buf temp = GIT_BUF_INIT; git_buf temp = GIT_BUF_INIT;
@ -1529,23 +1534,23 @@ int git_diff_patch_print(
pi.diff = patch->diff; pi.diff = patch->diff;
pi.print_cb = print_cb; pi.print_cb = print_cb;
pi.cb_data = cb_data; pi.payload = payload;
pi.buf = &temp; pi.buf = &temp;
error = print_patch_file(&pi, patch->delta, 0); error = print_patch_file(patch->delta, 0, &pi);
for (h = 0; h < patch->hunks_size && !error; ++h) { for (h = 0; h < patch->hunks_size && !error; ++h) {
diff_patch_hunk *hunk = &patch->hunks[h]; diff_patch_hunk *hunk = &patch->hunks[h];
error = print_patch_hunk(&pi, patch->delta, error = print_patch_hunk(
&hunk->range, hunk->header, hunk->header_len); patch->delta, &hunk->range, hunk->header, hunk->header_len, &pi);
for (l = 0; l < hunk->line_count && !error; ++l) { for (l = 0; l < hunk->line_count && !error; ++l) {
diff_patch_line *line = &patch->lines[hunk->line_start + l]; diff_patch_line *line = &patch->lines[hunk->line_start + l];
error = print_patch_line( error = print_patch_line(
&pi, patch->delta, &hunk->range, patch->delta, &hunk->range,
line->origin, line->ptr, line->len); line->origin, line->ptr, line->len, &pi);
} }
} }
@ -1561,7 +1566,7 @@ int git_diff_patch_to_str(
int error; int error;
git_buf output = GIT_BUF_INIT; git_buf output = GIT_BUF_INIT;
error = git_diff_patch_print(patch, &output, print_to_buffer_cb); error = git_diff_patch_print(patch, print_to_buffer_cb, &output);
/* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1, /* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1,
* meaning a memory allocation failure, so just map to -1... * meaning a memory allocation failure, so just map to -1...
@ -1577,8 +1582,8 @@ int git_diff_patch_to_str(
int git_diff__paired_foreach( int git_diff__paired_foreach(
git_diff_list *idx2head, git_diff_list *idx2head,
git_diff_list *wd2idx, git_diff_list *wd2idx,
int (*cb)(void *cbref, git_diff_delta *i2h, git_diff_delta *w2i), int (*cb)(git_diff_delta *i2h, git_diff_delta *w2i, void *payload),
void *cbref) void *payload)
{ {
int cmp; int cmp;
git_diff_delta *i2h, *w2i; git_diff_delta *i2h, *w2i;
@ -1611,15 +1616,15 @@ int git_diff__paired_foreach(
STRCMP_CASESELECT(icase, i2h->old_file.path, w2i->old_file.path); STRCMP_CASESELECT(icase, i2h->old_file.path, w2i->old_file.path);
if (cmp < 0) { if (cmp < 0) {
if (cb(cbref, i2h, NULL)) if (cb(i2h, NULL, payload))
return GIT_EUSER; return GIT_EUSER;
i++; i++;
} else if (cmp > 0) { } else if (cmp > 0) {
if (cb(cbref, NULL, w2i)) if (cb(NULL, w2i, payload))
return GIT_EUSER; return GIT_EUSER;
j++; j++;
} else { } else {
if (cb(cbref, i2h, w2i)) if (cb(i2h, w2i, payload))
return GIT_EUSER; return GIT_EUSER;
i++; j++; i++; j++;
} }

16
src/diff_output.h
View File

@ -27,12 +27,12 @@ typedef struct {
git_repository *repo; git_repository *repo;
git_diff_list *diff; git_diff_list *diff;
const git_diff_options *opts; const git_diff_options *opts;
git_diff_file_fn file_cb; git_diff_file_cb file_cb;
git_diff_hunk_fn hunk_cb; git_diff_hunk_cb hunk_cb;
git_diff_data_fn data_cb; git_diff_data_cb data_cb;
void *cb_data; void *payload;
int cb_error; int error;
git_diff_range cb_range; git_diff_range range;
xdemitconf_t xdiff_config; xdemitconf_t xdiff_config;
xpparam_t xdiff_params; xpparam_t xdiff_params;
} diff_context; } diff_context;
@ -86,7 +86,7 @@ typedef struct {
extern int git_diff__paired_foreach( extern int git_diff__paired_foreach(
git_diff_list *idx2head, git_diff_list *idx2head,
git_diff_list *wd2idx, git_diff_list *wd2idx,
int (*cb)(void *cbref, git_diff_delta *i2h, git_diff_delta *w2i), int (*cb)(git_diff_delta *i2h, git_diff_delta *w2i, void *payload),
void *cbref); void *payload);
#endif #endif

4
src/hash/hash_win32.c
View File

@ -155,7 +155,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *data, size_
{ {
assert(ctx->ctx.cryptoapi.valid); assert(ctx->ctx.cryptoapi.valid);
if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, (const BYTE *)data, len, 0)) if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, (const BYTE *)data, (DWORD)len, 0))
return -1; return -1;
return 0; return 0;
@ -219,7 +219,7 @@ GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *data, size_t len) GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *data, size_t len)
{ {
if (ctx->prov->prov.cng.hash_data(ctx->ctx.cng.hash_handle, (PBYTE)data, len, 0) < 0) if (ctx->prov->prov.cng.hash_data(ctx->ctx.cng.hash_handle, (PBYTE)data, (ULONG)len, 0) < 0)
return -1; return -1;
return 0; return 0;

71
src/index.c
View File

@ -94,7 +94,7 @@ static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffe
static int read_header(struct index_header *dest, const void *buffer); static int read_header(struct index_header *dest, const void *buffer);
static int parse_index(git_index *index, const char *buffer, size_t buffer_size); static int parse_index(git_index *index, const char *buffer, size_t buffer_size);
static int is_index_extended(git_index *index); static bool is_index_extended(git_index *index);
static int write_index(git_index *index, git_filebuf *file); static int write_index(git_index *index, git_filebuf *file);
static int index_find(git_index *index, const char *path, int stage); static int index_find(git_index *index, const char *path, int stage);
@ -298,7 +298,7 @@ static void index_free(git_index *index)
{ {
git_index_entry *e; git_index_entry *e;
git_index_reuc_entry *reuc; git_index_reuc_entry *reuc;
unsigned int i; size_t i;
git_index_clear(index); git_index_clear(index);
git_vector_foreach(&index->entries, i, e) { git_vector_foreach(&index->entries, i, e) {
@ -488,20 +488,22 @@ int git_index_write_tree_to(git_oid *oid, git_index *index, git_repository *repo
return git_tree__write_index(oid, index, repo); return git_tree__write_index(oid, index, repo);
} }
unsigned int git_index_entrycount(git_index *index) size_t git_index_entrycount(const git_index *index)
{ {
assert(index); assert(index);
return (unsigned int)index->entries.length; return index->entries.length;
} }
git_index_entry *git_index_get_byindex(git_index *index, size_t n) const git_index_entry *git_index_get_byindex(
git_index *index, size_t n)
{ {
assert(index); assert(index);
git_vector_sort(&index->entries); git_vector_sort(&index->entries);
return git_vector_get(&index->entries, n); return git_vector_get(&index->entries, n);
} }
git_index_entry *git_index_get_bypath(git_index *index, const char *path, int stage) const git_index_entry *git_index_get_bypath(
git_index *index, const char *path, int stage)
{ {
int pos; int pos;
@ -580,7 +582,7 @@ static int index_entry_init(git_index_entry **entry_out, git_index *index, const
*/ */
/* write the blob to disk and get the oid */ /* write the blob to disk and get the oid */
if ((error = git_blob_create_fromfile(&oid, INDEX_OWNER(index), rel_path)) < 0) if ((error = git_blob_create_fromworkdir(&oid, INDEX_OWNER(index), rel_path)) < 0)
return error; return error;
entry = git__calloc(1, sizeof(git_index_entry)); entry = git__calloc(1, sizeof(git_index_entry));
@ -810,13 +812,15 @@ int git_index_find(git_index *index, const char *path)
assert(index && path); assert(index && path);
if ((pos = git_vector_bsearch2(&index->entries, index->entries_search_path, path)) < 0) if ((pos = git_vector_bsearch2(
&index->entries, index->entries_search_path, path)) < 0)
return pos; return pos;
/* Since our binary search only looked at path, we may be in the /* Since our binary search only looked at path, we may be in the
* middle of a list of stages. */ * middle of a list of stages.
*/
while (pos > 0) { while (pos > 0) {
git_index_entry *prev = git_vector_get(&index->entries, pos-1); const git_index_entry *prev = git_vector_get(&index->entries, pos-1);
if (index->entries_cmp_path(prev->path, path) != 0) if (index->entries_cmp_path(prev->path, path) != 0)
break; break;
@ -827,10 +831,10 @@ int git_index_find(git_index *index, const char *path)
return pos; return pos;
} }
unsigned int git_index__prefix_position(git_index *index, const char *path) size_t git_index__prefix_position(git_index *index, const char *path)
{ {
struct entry_srch_key srch_key; struct entry_srch_key srch_key;
unsigned int pos; size_t pos;
srch_key.path = path; srch_key.path = path;
srch_key.stage = 0; srch_key.stage = 0;
@ -848,7 +852,7 @@ int git_index_conflict_add(git_index *index,
const git_index_entry *their_entry) const git_index_entry *their_entry)
{ {
git_index_entry *entries[3] = { 0 }; git_index_entry *entries[3] = { 0 };
size_t i; unsigned short i;
int ret = 0; int ret = 0;
assert (index); assert (index);
@ -886,7 +890,7 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
git_index_entry **their_out, git_index_entry **their_out,
git_index *index, const char *path) git_index *index, const char *path)
{ {
int pos, stage; int pos, posmax, stage;
git_index_entry *conflict_entry; git_index_entry *conflict_entry;
int error = GIT_ENOTFOUND; int error = GIT_ENOTFOUND;
@ -899,7 +903,8 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
if ((pos = git_index_find(index, path)) < 0) if ((pos = git_index_find(index, path)) < 0)
return pos; return pos;
while ((unsigned int)pos < git_index_entrycount(index)) { for (posmax = (int)git_index_entrycount(index); pos < posmax; ++pos) {
conflict_entry = git_vector_get(&index->entries, pos); conflict_entry = git_vector_get(&index->entries, pos);
if (index->entries_cmp_path(conflict_entry->path, path) != 0) if (index->entries_cmp_path(conflict_entry->path, path) != 0)
@ -923,8 +928,6 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
default: default:
break; break;
}; };
++pos;
} }
return error; return error;
@ -932,7 +935,7 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
int git_index_conflict_remove(git_index *index, const char *path) int git_index_conflict_remove(git_index *index, const char *path)
{ {
int pos; int pos, posmax;
git_index_entry *conflict_entry; git_index_entry *conflict_entry;
int error = 0; int error = 0;
@ -941,7 +944,9 @@ int git_index_conflict_remove(git_index *index, const char *path)
if ((pos = git_index_find(index, path)) < 0) if ((pos = git_index_find(index, path)) < 0)
return pos; return pos;
while ((unsigned int)pos < git_index_entrycount(index)) { posmax = (int)git_index_entrycount(index);
while (pos < posmax) {
conflict_entry = git_vector_get(&index->entries, pos); conflict_entry = git_vector_get(&index->entries, pos);
if (index->entries_cmp_path(conflict_entry->path, path) != 0) if (index->entries_cmp_path(conflict_entry->path, path) != 0)
@ -961,7 +966,7 @@ int git_index_conflict_remove(git_index *index, const char *path)
return error; return error;
} }
static int index_conflicts_match(git_vector *v, size_t idx) static int index_conflicts_match(const git_vector *v, size_t idx)
{ {
git_index_entry *entry = git_vector_get(v, idx); git_index_entry *entry = git_vector_get(v, idx);
@ -979,9 +984,9 @@ void git_index_conflict_cleanup(git_index *index)
git_vector_remove_matching(&index->entries, index_conflicts_match); git_vector_remove_matching(&index->entries, index_conflicts_match);
} }
int git_index_has_conflicts(git_index *index) int git_index_has_conflicts(const git_index *index)
{ {
unsigned int i; size_t i;
git_index_entry *entry; git_index_entry *entry;
assert(index); assert(index);
@ -1072,7 +1077,7 @@ const git_index_reuc_entry *git_index_reuc_get_byindex(
return git_vector_get(&index->reuc, n); return git_vector_get(&index->reuc, n);
} }
int git_index_reuc_remove(git_index *index, int position) int git_index_reuc_remove(git_index *index, size_t position)
{ {
int error; int error;
git_index_reuc_entry *reuc; git_index_reuc_entry *reuc;
@ -1359,9 +1364,9 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
return 0; return 0;
} }
static int is_index_extended(git_index *index) static bool is_index_extended(git_index *index)
{ {
unsigned int i, extended; size_t i, extended;
git_index_entry *entry; git_index_entry *entry;
extended = 0; extended = 0;
@ -1374,7 +1379,7 @@ static int is_index_extended(git_index *index)
} }
} }
return extended; return (extended > 0);
} }
static int write_disk_entry(git_filebuf *file, git_index_entry *entry) static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
@ -1440,7 +1445,7 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
static int write_entries(git_index *index, git_filebuf *file) static int write_entries(git_index *index, git_filebuf *file)
{ {
int error = 0; int error = 0;
unsigned int i; size_t i;
git_vector case_sorted; git_vector case_sorted;
git_index_entry *entry; git_index_entry *entry;
git_vector *out = &index->entries; git_vector *out = &index->entries;
@ -1506,7 +1511,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file)
git_vector *out = &index->reuc; git_vector *out = &index->reuc;
git_index_reuc_entry *reuc; git_index_reuc_entry *reuc;
struct index_extension extension; struct index_extension extension;
unsigned int i; size_t i;
int error = 0; int error = 0;
git_vector_foreach(out, i, reuc) { git_vector_foreach(out, i, reuc) {
@ -1516,7 +1521,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file)
memset(&extension, 0x0, sizeof(struct index_extension)); memset(&extension, 0x0, sizeof(struct index_extension));
memcpy(&extension.signature, INDEX_EXT_UNMERGED_SIG, 4); memcpy(&extension.signature, INDEX_EXT_UNMERGED_SIG, 4);
extension.extension_size = reuc_buf.size; extension.extension_size = (uint32_t)reuc_buf.size;
error = write_extension(file, &extension, &reuc_buf); error = write_extension(file, &extension, &reuc_buf);
@ -1529,10 +1534,8 @@ done:
static int write_index(git_index *index, git_filebuf *file) static int write_index(git_index *index, git_filebuf *file)
{ {
git_oid hash_final; git_oid hash_final;
struct index_header header; struct index_header header;
bool is_extended;
int is_extended;
assert(index && file); assert(index && file);
@ -1599,11 +1602,11 @@ static int read_tree_cb(const char *root, const git_tree_entry *tentry, void *da
return 0; return 0;
} }
int git_index_read_tree(git_index *index, git_tree *tree) int git_index_read_tree(git_index *index, const git_tree *tree)
{ {
git_index_clear(index); git_index_clear(index);
return git_tree_walk(tree, read_tree_cb, GIT_TREEWALK_POST, index); return git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, index);
} }
git_repository *git_index_owner(const git_index *index) git_repository *git_index_owner(const git_index *index)

2
src/index.h
View File

@ -43,7 +43,7 @@ struct git_index {
extern void git_index_entry__init_from_stat(git_index_entry *entry, struct stat *st); extern void git_index_entry__init_from_stat(git_index_entry *entry, struct stat *st);
extern unsigned int git_index__prefix_position(git_index *index, const char *path); extern size_t git_index__prefix_position(git_index *index, const char *path);
extern int git_index_entry__cmp(const void *a, const void *b); extern int git_index_entry__cmp(const void *a, const void *b);
extern int git_index_entry__cmp_icase(const void *a, const void *b); extern int git_index_entry__cmp_icase(const void *a, const void *b);

4
src/indexer.c
View File

@ -56,12 +56,12 @@ struct delta_info {
git_off_t delta_off; git_off_t delta_off;
}; };
const git_oid *git_indexer_hash(git_indexer *idx) const git_oid *git_indexer_hash(const git_indexer *idx)
{ {
return &idx->hash; return &idx->hash;
} }
const git_oid *git_indexer_stream_hash(git_indexer_stream *idx) const git_oid *git_indexer_stream_hash(const git_indexer_stream *idx)
{ {
return &idx->hash; return &idx->hash;
} }

14
src/iterator.c
View File

@ -85,7 +85,7 @@ struct tree_iterator_frame {
tree_iterator_frame *next, *prev; tree_iterator_frame *next, *prev;
git_tree *tree; git_tree *tree;
char *start; char *start;
unsigned int index; size_t index;
}; };
typedef struct { typedef struct {
@ -329,7 +329,7 @@ int git_iterator_for_tree_range(
typedef struct { typedef struct {
git_iterator base; git_iterator base;
git_index *index; git_index *index;
unsigned int current; size_t current;
bool free_index; bool free_index;
} index_iterator; } index_iterator;
@ -337,7 +337,7 @@ static int index_iterator__current(
git_iterator *self, const git_index_entry **entry) git_iterator *self, const git_index_entry **entry)
{ {
index_iterator *ii = (index_iterator *)self; index_iterator *ii = (index_iterator *)self;
git_index_entry *ie = git_index_get_byindex(ii->index, ii->current); const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
if (ie != NULL && if (ie != NULL &&
ii->base.end != NULL && ii->base.end != NULL &&
@ -434,7 +434,7 @@ typedef struct workdir_iterator_frame workdir_iterator_frame;
struct workdir_iterator_frame { struct workdir_iterator_frame {
workdir_iterator_frame *next; workdir_iterator_frame *next;
git_vector entries; git_vector entries;
unsigned int index; size_t index;
char *start; char *start;
}; };
@ -761,7 +761,8 @@ static int spoolandsort_iterator__current(
spoolandsort_iterator *si = (spoolandsort_iterator *)self; spoolandsort_iterator *si = (spoolandsort_iterator *)self;
if (si->position < si->entries.length) if (si->position < si->entries.length)
*entry = (const git_index_entry *)git_vector_get_const(&si->entries, si->position); *entry = (const git_index_entry *)git_vector_get(
&si->entries, si->position);
else else
*entry = NULL; *entry = NULL;
@ -781,7 +782,8 @@ static int spoolandsort_iterator__advance(
spoolandsort_iterator *si = (spoolandsort_iterator *)self; spoolandsort_iterator *si = (spoolandsort_iterator *)self;
if (si->position < si->entries.length) if (si->position < si->entries.length)
*entry = (const git_index_entry *)git_vector_get_const(&si->entries, ++si->position); *entry = (const git_index_entry *)git_vector_get(
&si->entries, ++si->position);
else else
*entry = NULL; *entry = NULL;

196
src/merge.c
View File

@ -6,12 +6,14 @@
*/ */
#include "repository.h" #include "repository.h"
#include "revwalk.h"
#include "buffer.h" #include "buffer.h"
#include "merge.h" #include "merge.h"
#include "refs.h" #include "refs.h"
#include "git2/repository.h" #include "git2/repository.h"
#include "git2/merge.h" #include "git2/merge.h"
#include "git2/reset.h" #include "git2/reset.h"
#include "commit_list.h"
int git_merge__cleanup(git_repository *repo) int git_merge__cleanup(git_repository *repo)
{ {
@ -46,3 +48,197 @@ cleanup:
return error; return error;
} }
int git_merge_base_many(git_oid *out, git_repository *repo, const git_oid input_array[], size_t length)
{
git_revwalk *walk;
git_vector list;
git_commit_list *result = NULL;
int error = -1;
unsigned int i;
git_commit_list_node *commit;
assert(out && repo && input_array);
if (length < 2) {
giterr_set(GITERR_INVALID, "At least two commits are required to find an ancestor. Provided 'length' was %u.", length);
return -1;
}
if (git_vector_init(&list, length - 1, NULL) < 0)
return -1;
if (git_revwalk_new(&walk, repo) < 0)
goto cleanup;
for (i = 1; i < length; i++) {
commit = commit_lookup(walk, &input_array[i]);
if (commit == NULL)
goto cleanup;
git_vector_insert(&list, commit);
}
commit = commit_lookup(walk, &input_array[0]);
if (commit == NULL)
goto cleanup;
if (git_merge__bases_many(&result, walk, commit, &list) < 0)
goto cleanup;
if (!result) {
error = GIT_ENOTFOUND;
goto cleanup;
}
git_oid_cpy(out, &result->item->oid);
error = 0;
cleanup:
git_commit_list_free(&result);
git_revwalk_free(walk);
git_vector_free(&list);
return error;
}
int git_merge_base(git_oid *out, git_repository *repo, const git_oid *one, const git_oid *two)
{
git_revwalk *walk;
git_vector list;
git_commit_list *result = NULL;
git_commit_list_node *commit;
void *contents[1];
if (git_revwalk_new(&walk, repo) < 0)
return -1;
commit = commit_lookup(walk, two);
if (commit == NULL)
goto on_error;
/* This is just one value, so we can do it on the stack */
memset(&list, 0x0, sizeof(git_vector));
contents[0] = commit;
list.length = 1;
list.contents = contents;
commit = commit_lookup(walk, one);
if (commit == NULL)
goto on_error;
if (git_merge__bases_many(&result, walk, commit, &list) < 0)
goto on_error;
if (!result) {
git_revwalk_free(walk);
giterr_clear();
return GIT_ENOTFOUND;
}
git_oid_cpy(out, &result->item->oid);
git_commit_list_free(&result);
git_revwalk_free(walk);
return 0;
on_error:
git_revwalk_free(walk);
return -1;
}
static int interesting(git_pqueue *list)
{
unsigned int i;
/* element 0 isn't used - we need to start at 1 */
for (i = 1; i < list->size; i++) {
git_commit_list_node *commit = list->d[i];
if ((commit->flags & STALE) == 0)
return 1;
}
return 0;
}
int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos)
{
int error;
unsigned int i;
git_commit_list_node *two;
git_commit_list *result = NULL, *tmp = NULL;
git_pqueue list;
/* if the commit is repeated, we have a our merge base already */
git_vector_foreach(twos, i, two) {
if (one == two)
return git_commit_list_insert(one, out) ? 0 : -1;
}
if (git_pqueue_init(&list, twos->length * 2, git_commit_list_time_cmp) < 0)
return -1;
if (git_commit_list_parse(walk, one) < 0)
return -1;
one->flags |= PARENT1;
if (git_pqueue_insert(&list, one) < 0)
return -1;
git_vector_foreach(twos, i, two) {
git_commit_list_parse(walk, two);
two->flags |= PARENT2;
if (git_pqueue_insert(&list, two) < 0)
return -1;
}
/* as long as there are non-STALE commits */
while (interesting(&list)) {
git_commit_list_node *commit;
int flags;
commit = git_pqueue_pop(&list);
flags = commit->flags & (PARENT1 | PARENT2 | STALE);
if (flags == (PARENT1 | PARENT2)) {
if (!(commit->flags & RESULT)) {
commit->flags |= RESULT;
if (git_commit_list_insert(commit, &result) == NULL)
return -1;
}
/* we mark the parents of a merge stale */
flags |= STALE;
}
for (i = 0; i < commit->out_degree; i++) {
git_commit_list_node *p = commit->parents[i];
if ((p->flags & flags) == flags)
continue;
if ((error = git_commit_list_parse(walk, p)) < 0)
return error;
p->flags |= flags;
if (git_pqueue_insert(&list, p) < 0)
return -1;
}
}
git_pqueue_free(&list);
/* filter out any stale commits in the results */
tmp = result;
result = NULL;
while (tmp) {
struct git_commit_list *next = tmp->next;
if (!(tmp->item->flags & STALE))
if (git_commit_list_insert_by_date(tmp->item, &result) == NULL)
return -1;
git__free(tmp);
tmp = next;
}
*out = result;
return 0;
}

3
src/merge.h
View File

@ -8,6 +8,8 @@
#define INCLUDE_merge_h__ #define INCLUDE_merge_h__
#include "git2/types.h" #include "git2/types.h"
#include "git2/merge.h"
#include "commit_list.h"
#define GIT_MERGE_MSG_FILE "MERGE_MSG" #define GIT_MERGE_MSG_FILE "MERGE_MSG"
#define GIT_MERGE_MODE_FILE "MERGE_MODE" #define GIT_MERGE_MODE_FILE "MERGE_MODE"
@ -15,5 +17,6 @@
#define MERGE_CONFIG_FILE_MODE 0666 #define MERGE_CONFIG_FILE_MODE 0666
int git_merge__cleanup(git_repository *repo); int git_merge__cleanup(git_repository *repo);
int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos);
#endif #endif

40
src/notes.c
View File

@ -19,7 +19,7 @@ static int find_subtree_in_current_level(
const char *annotated_object_sha, const char *annotated_object_sha,
int fanout) int fanout)
{ {
unsigned int i; size_t i;
const git_tree_entry *entry; const git_tree_entry *entry;
*out = NULL; *out = NULL;
@ -71,7 +71,7 @@ static int find_subtree_r(git_tree **out, git_tree *root,
static int find_blob(git_oid *blob, git_tree *tree, const char *target) static int find_blob(git_oid *blob, git_tree *tree, const char *target)
{ {
unsigned int i; size_t i;
const git_tree_entry *entry; const git_tree_entry *entry;
for (i=0; i<git_tree_entrycount(tree); i++) { for (i=0; i<git_tree_entrycount(tree); i++) {
@ -263,8 +263,8 @@ static int insert_note_in_tree_enotfound_cb(git_tree **out,
static int note_write(git_oid *out, static int note_write(git_oid *out,
git_repository *repo, git_repository *repo,
git_signature *author, const git_signature *author,
git_signature *committer, const git_signature *committer,
const char *notes_ref, const char *notes_ref,
const char *note, const char *note,
git_tree *commit_tree, git_tree *commit_tree,
@ -343,7 +343,7 @@ cleanup:
} }
static int note_remove(git_repository *repo, static int note_remove(git_repository *repo,
git_signature *author, git_signature *committer, const git_signature *author, const git_signature *committer,
const char *notes_ref, git_tree *tree, const char *notes_ref, git_tree *tree,
const char *target, git_commit **parents) const char *target, git_commit **parents)
{ {
@ -406,7 +406,7 @@ static int retrieve_note_tree_and_commit(
if ((error = normalize_namespace(notes_ref, repo)) < 0) if ((error = normalize_namespace(notes_ref, repo)) < 0)
return error; return error;
if ((error = git_reference_name_to_oid(&oid, repo, *notes_ref)) < 0) if ((error = git_reference_name_to_id(&oid, repo, *notes_ref)) < 0)
return error; return error;
if (git_commit_lookup(commit_out, repo, &oid) < 0) if (git_commit_lookup(commit_out, repo, &oid) < 0)
@ -442,9 +442,12 @@ cleanup:
} }
int git_note_create( int git_note_create(
git_oid *out, git_repository *repo, git_oid *out,
git_signature *author, git_signature *committer, git_repository *repo,
const char *notes_ref, const git_oid *oid, const git_signature *author,
const git_signature *committer,
const char *notes_ref,
const git_oid *oid,
const char *note) const char *note)
{ {
int error; int error;
@ -471,7 +474,7 @@ cleanup:
} }
int git_note_remove(git_repository *repo, const char *notes_ref, int git_note_remove(git_repository *repo, const char *notes_ref,
git_signature *author, git_signature *committer, const git_signature *author, const git_signature *committer,
const git_oid *oid) const git_oid *oid)
{ {
int error; int error;
@ -501,13 +504,13 @@ int git_note_default_ref(const char **out, git_repository *repo)
return note_get_default_ref(out, repo); return note_get_default_ref(out, repo);
} }
const char * git_note_message(git_note *note) const char * git_note_message(const git_note *note)
{ {
assert(note); assert(note);
return note->message; return note->message;
} }
const git_oid * git_note_oid(git_note *note) const git_oid * git_note_oid(const git_note *note)
{ {
assert(note); assert(note);
return &note->oid; return &note->oid;
@ -525,13 +528,13 @@ void git_note_free(git_note *note)
static int process_entry_path( static int process_entry_path(
const char* entry_path, const char* entry_path,
const git_oid *note_oid, const git_oid *note_oid,
int (*note_cb)(git_note_data *note_data, void *payload), git_note_foreach_cb note_cb,
void *payload) void *payload)
{ {
int error = -1; int error = -1;
size_t i = 0, j = 0, len; size_t i = 0, j = 0, len;
git_buf buf = GIT_BUF_INIT; git_buf buf = GIT_BUF_INIT;
git_note_data note_data; git_oid annotated_object_id;
if ((error = git_buf_puts(&buf, entry_path)) < 0) if ((error = git_buf_puts(&buf, entry_path)) < 0)
goto cleanup; goto cleanup;
@ -564,13 +567,10 @@ static int process_entry_path(
goto cleanup; goto cleanup;
} }
if ((error = git_oid_fromstr( if ((error = git_oid_fromstr(&annotated_object_id, buf.ptr)) < 0)
&note_data.annotated_object_oid, buf.ptr)) < 0)
goto cleanup; goto cleanup;
git_oid_cpy(&note_data.blob_oid, note_oid); if (note_cb(note_oid, &annotated_object_id, payload))
if (note_cb(&note_data, payload))
error = GIT_EUSER; error = GIT_EUSER;
cleanup: cleanup:
@ -581,7 +581,7 @@ cleanup:
int git_note_foreach( int git_note_foreach(
git_repository *repo, git_repository *repo,
const char *notes_ref, const char *notes_ref,
int (*note_cb)(git_note_data *note_data, void *payload), git_note_foreach_cb note_cb,
void *payload) void *payload)
{ {
int error; int error;

6
src/object.c
View File

@ -334,7 +334,7 @@ static int dereference_object(git_object **dereferenced, git_object *obj)
int git_object_peel( int git_object_peel(
git_object **peeled, git_object **peeled,
git_object *object, const git_object *object,
git_otype target_type) git_otype target_type)
{ {
git_object *source, *deref = NULL; git_object *source, *deref = NULL;
@ -342,9 +342,9 @@ int git_object_peel(
assert(object && peeled); assert(object && peeled);
if (git_object_type(object) == target_type) if (git_object_type(object) == target_type)
return git_object__dup(peeled, object); return git_object__dup(peeled, (git_object *)object);
source = object; source = (git_object *)object;
while (!dereference_object(&deref, source)) { while (!dereference_object(&deref, source)) {

4
src/odb.c
View File

@ -683,14 +683,14 @@ int git_odb_read_prefix(
return 0; return 0;
} }
int git_odb_foreach(git_odb *db, int (*cb)(git_oid *oid, void *data), void *data) int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
{ {
unsigned int i; unsigned int i;
backend_internal *internal; backend_internal *internal;
git_vector_foreach(&db->backends, i, internal) { git_vector_foreach(&db->backends, i, internal) {
git_odb_backend *b = internal->backend; git_odb_backend *b = internal->backend;
int error = b->foreach(b, cb, data); int error = b->foreach(b, cb, payload);
if (error < 0) if (error < 0)
return error; return error;
} }

4
src/odb_loose.c
View File

@ -678,7 +678,7 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid)
struct foreach_state { struct foreach_state {
size_t dir_len; size_t dir_len;
int (*cb)(git_oid *oid, void *data); git_odb_foreach_cb cb;
void *data; void *data;
int cb_error; int cb_error;
}; };
@ -734,7 +734,7 @@ static int foreach_cb(void *_state, git_buf *path)
return git_path_direach(path, foreach_object_dir_cb, state); return git_path_direach(path, foreach_object_dir_cb, state);
} }
static int loose_backend__foreach(git_odb_backend *_backend, int (*cb)(git_oid *oid, void *data), void *data) static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb cb, void *data)
{ {
char *objects_dir; char *objects_dir;
int error; int error;

2
src/odb_pack.c
View File

@ -458,7 +458,7 @@ static int pack_backend__exists(git_odb_backend *backend, const git_oid *oid)
return pack_entry_find(&e, (struct pack_backend *)backend, oid) == 0; return pack_entry_find(&e, (struct pack_backend *)backend, oid) == 0;
} }
static int pack_backend__foreach(git_odb_backend *_backend, int (*cb)(git_oid *oid, void *data), void *data) static int pack_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb cb, void *data)
{ {
int error; int error;
struct git_pack_file *p; struct git_pack_file *p;

28
src/pack-objects.c
View File

@ -136,10 +136,11 @@ on_error:
return -1; return -1;
} }
void git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n) unsigned int git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n)
{ {
assert(pb); assert(pb);
pb->nr_threads = n; pb->nr_threads = n;
return pb->nr_threads;
} }
static void rehash(git_packbuilder *pb) static void rehash(git_packbuilder *pb)
@ -228,7 +229,7 @@ static int gen_pack_object_header(
} }
*hdr++ = c; *hdr++ = c;
return hdr - hdr_base; return (int)(hdr - hdr_base);
} }
static int get_delta(void **out, git_odb *odb, git_pobject *po) static int get_delta(void **out, git_odb *odb, git_pobject *po)
@ -243,8 +244,9 @@ static int get_delta(void **out, git_odb *odb, git_pobject *po)
git_odb_read(&trg, odb, &po->id) < 0) git_odb_read(&trg, odb, &po->id) < 0)
goto on_error; goto on_error;
delta_buf = git_delta(git_odb_object_data(src), git_odb_object_size(src), delta_buf = git_delta(
git_odb_object_data(trg), git_odb_object_size(trg), git_odb_object_data(src), (unsigned long)git_odb_object_size(src),
git_odb_object_data(trg), (unsigned long)git_odb_object_size(trg),
&delta_size, 0); &delta_size, 0);
if (!delta_buf || delta_size != po->delta_size) { if (!delta_buf || delta_size != po->delta_size) {
@ -286,7 +288,7 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
goto on_error; goto on_error;
data = (void *)git_odb_object_data(obj); data = (void *)git_odb_object_data(obj);
size = git_odb_object_size(obj); size = (unsigned long)git_odb_object_size(obj);
type = git_odb_object_type(obj); type = git_odb_object_type(obj);
} }
@ -314,7 +316,7 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
if (po->delta) if (po->delta)
git__free(data); git__free(data);
data = zbuf.ptr; data = zbuf.ptr;
size = zbuf.size; size = (unsigned long)zbuf.size;
} }
if (git_buf_put(buf, data, size) < 0 || if (git_buf_put(buf, data, size) < 0 ||
@ -706,7 +708,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
return 0; return 0;
/* Now some size filtering heuristics. */ /* Now some size filtering heuristics. */
trg_size = trg_object->size; trg_size = (unsigned long)trg_object->size;
if (!trg_object->delta) { if (!trg_object->delta) {
max_size = trg_size/2 - 20; max_size = trg_size/2 - 20;
ref_depth = 1; ref_depth = 1;
@ -720,7 +722,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
if (max_size == 0) if (max_size == 0)
return 0; return 0;
src_size = src_object->size; src_size = (unsigned long)src_object->size;
sizediff = src_size < trg_size ? trg_size - src_size : 0; sizediff = src_size < trg_size ? trg_size - src_size : 0;
if (sizediff >= max_size) if (sizediff >= max_size)
return 0; return 0;
@ -732,7 +734,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
if (git_odb_read(&obj, pb->odb, &trg_object->id) < 0) if (git_odb_read(&obj, pb->odb, &trg_object->id) < 0)
return -1; return -1;
sz = git_odb_object_size(obj); sz = (unsigned long)git_odb_object_size(obj);
trg->data = git__malloc(sz); trg->data = git__malloc(sz);
GITERR_CHECK_ALLOC(trg->data); GITERR_CHECK_ALLOC(trg->data);
memcpy(trg->data, git_odb_object_data(obj), sz); memcpy(trg->data, git_odb_object_data(obj), sz);
@ -751,7 +753,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
if (git_odb_read(&obj, pb->odb, &src_object->id) < 0) if (git_odb_read(&obj, pb->odb, &src_object->id) < 0)
return -1; return -1;
sz = git_odb_object_size(obj); sz = (unsigned long)git_odb_object_size(obj);
src->data = git__malloc(sz); src->data = git__malloc(sz);
GITERR_CHECK_ALLOC(src->data); GITERR_CHECK_ALLOC(src->data);
memcpy(src->data, git_odb_object_data(obj), sz); memcpy(src->data, git_odb_object_data(obj), sz);
@ -834,7 +836,7 @@ static unsigned long free_unpacked(struct unpacked *n)
git_delta_free_index(n->index); git_delta_free_index(n->index);
n->index = NULL; n->index = NULL;
if (n->data) { if (n->data) {
freed_mem += n->object->size; freed_mem += (unsigned long)n->object->size;
git__free(n->data); git__free(n->data);
n->data = NULL; n->data = NULL;
} }
@ -940,7 +942,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
GITERR_CHECK_ALLOC(po->delta_data); GITERR_CHECK_ALLOC(po->delta_data);
memcpy(po->delta_data, zbuf.ptr, zbuf.size); memcpy(po->delta_data, zbuf.ptr, zbuf.size);
po->z_delta_size = zbuf.size; po->z_delta_size = (unsigned long)zbuf.size;
git_buf_clear(&zbuf); git_buf_clear(&zbuf);
git_packbuilder__cache_lock(pb); git_packbuilder__cache_lock(pb);
@ -1283,7 +1285,7 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
git_packbuilder_insert(pb, oid, NULL) < 0) git_packbuilder_insert(pb, oid, NULL) < 0)
return -1; return -1;
if (git_tree_walk(tree, cb_tree_walk, GIT_TREEWALK_PRE, pb) < 0) { if (git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, pb) < 0) {
git_tree_free(tree); git_tree_free(tree);
return -1; return -1;
} }

2
src/pack.c
View File

@ -698,7 +698,7 @@ static int git__memcmp4(const void *a, const void *b) {
int git_pack_foreach_entry( int git_pack_foreach_entry(
struct git_pack_file *p, struct git_pack_file *p,
int (*cb)(git_oid *oid, void *data), git_odb_foreach_cb cb,
void *data) void *data)
{ {
const unsigned char *index = p->index_map.data, *current; const unsigned char *index = p->index_map.data, *current;

2
src/pack.h
View File

@ -105,7 +105,7 @@ int git_pack_entry_find(
size_t len); size_t len);
int git_pack_foreach_entry( int git_pack_foreach_entry(
struct git_pack_file *p, struct git_pack_file *p,
int (*cb)(git_oid *oid, void *data), git_odb_foreach_cb cb,
void *data); void *data);
#endif #endif

37
src/reflog.c
View File

@ -10,7 +10,7 @@
#include "filebuf.h" #include "filebuf.h"
#include "signature.h" #include "signature.h"
static int reflog_init(git_reflog **reflog, git_reference *ref) static int reflog_init(git_reflog **reflog, const git_reference *ref)
{ {
git_reflog *log; git_reflog *log;
@ -180,7 +180,7 @@ void git_reflog_free(git_reflog *reflog)
git__free(reflog); git__free(reflog);
} }
static int retrieve_reflog_path(git_buf *path, git_reference *ref) static int retrieve_reflog_path(git_buf *path, const git_reference *ref)
{ {
return git_buf_join_n(path, '/', 3, return git_buf_join_n(path, '/', 3,
git_reference_owner(ref)->path_repository, GIT_REFLOG_DIR, ref->name); git_reference_owner(ref)->path_repository, GIT_REFLOG_DIR, ref->name);
@ -201,7 +201,7 @@ static int create_new_reflog_file(const char *filepath)
return p_close(fd); return p_close(fd);
} }
int git_reflog_read(git_reflog **reflog, git_reference *ref) int git_reflog_read(git_reflog **reflog, const git_reference *ref)
{ {
int error = -1; int error = -1;
git_buf log_path = GIT_BUF_INIT; git_buf log_path = GIT_BUF_INIT;
@ -405,45 +405,47 @@ int git_reflog_delete(git_reference *ref)
return error; return error;
} }
unsigned int git_reflog_entrycount(git_reflog *reflog) size_t git_reflog_entrycount(git_reflog *reflog)
{ {
assert(reflog); assert(reflog);
return (unsigned int)reflog->entries.length; return reflog->entries.length;
}
GIT_INLINE(size_t) reflog_inverse_index(size_t idx, size_t total)
{
return (total - 1) - idx;
} }
const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, size_t idx) const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, size_t idx)
{ {
int pos;
assert(reflog); assert(reflog);
pos = git_reflog_entrycount(reflog) - (idx + 1); if (idx >= reflog->entries.length)
if (pos < 0)
return NULL; return NULL;
return git_vector_get(&reflog->entries, pos); return git_vector_get(
&reflog->entries, reflog_inverse_index(idx, reflog->entries.length));
} }
const git_oid * git_reflog_entry_oidold(const git_reflog_entry *entry) const git_oid * git_reflog_entry_id_old(const git_reflog_entry *entry)
{ {
assert(entry); assert(entry);
return &entry->oid_old; return &entry->oid_old;
} }
const git_oid * git_reflog_entry_oidnew(const git_reflog_entry *entry) const git_oid * git_reflog_entry_id_new(const git_reflog_entry *entry)
{ {
assert(entry); assert(entry);
return &entry->oid_cur; return &entry->oid_cur;
} }
git_signature * git_reflog_entry_committer(const git_reflog_entry *entry) const git_signature * git_reflog_entry_committer(const git_reflog_entry *entry)
{ {
assert(entry); assert(entry);
return entry->committer; return entry->committer;
} }
char * git_reflog_entry_msg(const git_reflog_entry *entry) const char * git_reflog_entry_message(const git_reflog_entry *entry)
{ {
assert(entry); assert(entry);
return entry->msg; return entry->msg;
@ -454,7 +456,7 @@ int git_reflog_drop(
size_t idx, size_t idx,
int rewrite_previous_entry) int rewrite_previous_entry)
{ {
unsigned int entrycount; size_t entrycount;
git_reflog_entry *entry, *previous; git_reflog_entry *entry, *previous;
assert(reflog); assert(reflog);
@ -468,7 +470,8 @@ int git_reflog_drop(
reflog_entry_free(entry); reflog_entry_free(entry);
if (git_vector_remove(&reflog->entries, entrycount - (idx + 1)) < 0) if (git_vector_remove(
&reflog->entries, reflog_inverse_index(idx, entrycount)) < 0)
return -1; return -1;
if (!rewrite_previous_entry) if (!rewrite_previous_entry)

50
src/refs.c
View File

@ -647,7 +647,7 @@ static int packed_find_peel(git_repository *repo, struct packref *ref)
/* /*
* Find the object pointed at by this tag * Find the object pointed at by this tag
*/ */
git_oid_cpy(&ref->peel, git_tag_target_oid(tag)); git_oid_cpy(&ref->peel, git_tag_target_id(tag));
ref->flags |= GIT_PACKREF_HAS_PEEL; ref->flags |= GIT_PACKREF_HAS_PEEL;
/* /*
@ -1074,7 +1074,7 @@ int git_reference_lookup(git_reference **ref_out,
return git_reference_lookup_resolved(ref_out, repo, name, 0); return git_reference_lookup_resolved(ref_out, repo, name, 0);
} }
int git_reference_name_to_oid( int git_reference_name_to_id(
git_oid *out, git_repository *repo, const char *name) git_oid *out, git_repository *repo, const char *name)
{ {
int error; int error;
@ -1083,7 +1083,7 @@ int git_reference_name_to_oid(
if ((error = git_reference_lookup_resolved(&ref, repo, name, -1)) < 0) if ((error = git_reference_lookup_resolved(&ref, repo, name, -1)) < 0)
return error; return error;
git_oid_cpy(out, git_reference_oid(ref)); git_oid_cpy(out, git_reference_target(ref));
git_reference_free(ref); git_reference_free(ref);
return 0; return 0;
} }
@ -1153,7 +1153,7 @@ int git_reference_lookup_resolved(
/** /**
* Getters * Getters
*/ */
git_ref_t git_reference_type(git_reference *ref) git_ref_t git_reference_type(const git_reference *ref)
{ {
assert(ref); assert(ref);
@ -1172,19 +1172,19 @@ int git_reference_is_packed(git_reference *ref)
return !!(ref->flags & GIT_REF_PACKED); return !!(ref->flags & GIT_REF_PACKED);
} }
const char *git_reference_name(git_reference *ref) const char *git_reference_name(const git_reference *ref)
{ {
assert(ref); assert(ref);
return ref->name; return ref->name;
} }
git_repository *git_reference_owner(git_reference *ref) git_repository *git_reference_owner(const git_reference *ref)
{ {
assert(ref); assert(ref);
return ref->owner; return ref->owner;
} }
const git_oid *git_reference_oid(git_reference *ref) const git_oid *git_reference_target(const git_reference *ref)
{ {
assert(ref); assert(ref);
@ -1194,7 +1194,7 @@ const git_oid *git_reference_oid(git_reference *ref)
return &ref->target.oid; return &ref->target.oid;
} }
const char *git_reference_target(git_reference *ref) const char *git_reference_symbolic_target(const git_reference *ref)
{ {
assert(ref); assert(ref);
@ -1204,7 +1204,7 @@ const char *git_reference_target(git_reference *ref)
return ref->target.symbolic; return ref->target.symbolic;
} }
int git_reference_create_symbolic( int git_reference_symbolic_create(
git_reference **ref_out, git_reference **ref_out,
git_repository *repo, git_repository *repo,
const char *name, const char *name,
@ -1231,7 +1231,7 @@ int git_reference_create_symbolic(
/* set the target; this will normalize the name automatically /* set the target; this will normalize the name automatically
* and write the reference on disk */ * and write the reference on disk */
if (git_reference_set_target(ref, target) < 0) { if (git_reference_symbolic_set_target(ref, target) < 0) {
git_reference_free(ref); git_reference_free(ref);
return -1; return -1;
} }
@ -1244,7 +1244,7 @@ int git_reference_create_symbolic(
return 0; return 0;
} }
int git_reference_create_oid( int git_reference_create(
git_reference **ref_out, git_reference **ref_out,
git_repository *repo, git_repository *repo,
const char *name, const char *name,
@ -1270,7 +1270,7 @@ int git_reference_create_oid(
ref->flags |= GIT_REF_OID; ref->flags |= GIT_REF_OID;
/* set the oid; this will write the reference on disk */ /* set the oid; this will write the reference on disk */
if (git_reference_set_oid(ref, id) < 0) { if (git_reference_set_target(ref, id) < 0) {
git_reference_free(ref); git_reference_free(ref);
return -1; return -1;
} }
@ -1292,7 +1292,7 @@ int git_reference_create_oid(
* We do not repack packed references because of performance * We do not repack packed references because of performance
* reasons. * reasons.
*/ */
int git_reference_set_oid(git_reference *ref, const git_oid *id) int git_reference_set_target(git_reference *ref, const git_oid *id)
{ {
git_odb *odb = NULL; git_odb *odb = NULL;
@ -1328,7 +1328,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id)
* a pack. We just change the target in memory * a pack. We just change the target in memory
* and overwrite the file on disk. * and overwrite the file on disk.
*/ */
int git_reference_set_target(git_reference *ref, const char *target) int git_reference_symbolic_set_target(git_reference *ref, const char *target)
{ {
char normalized[GIT_REFNAME_MAX]; char normalized[GIT_REFNAME_MAX];
@ -1397,10 +1397,10 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
* Finally we can create the new reference. * Finally we can create the new reference.
*/ */
if (ref->flags & GIT_REF_SYMBOLIC) { if (ref->flags & GIT_REF_SYMBOLIC) {
result = git_reference_create_symbolic( result = git_reference_symbolic_create(
NULL, ref->owner, new_name, ref->target.symbolic, force); NULL, ref->owner, new_name, ref->target.symbolic, force);
} else { } else {
result = git_reference_create_oid( result = git_reference_create(
NULL, ref->owner, new_name, &ref->target.oid, force); NULL, ref->owner, new_name, &ref->target.oid, force);
} }
@ -1444,10 +1444,10 @@ rollback:
* Try to create the old reference again, ignore failures * Try to create the old reference again, ignore failures
*/ */
if (ref->flags & GIT_REF_SYMBOLIC) if (ref->flags & GIT_REF_SYMBOLIC)
git_reference_create_symbolic( git_reference_symbolic_create(
NULL, ref->owner, ref->name, ref->target.symbolic, 0); NULL, ref->owner, ref->name, ref->target.symbolic, 0);
else else
git_reference_create_oid( git_reference_create(
NULL, ref->owner, ref->name, &ref->target.oid, 0); NULL, ref->owner, ref->name, &ref->target.oid, 0);
/* The reference is no longer packed */ /* The reference is no longer packed */
@ -1457,7 +1457,7 @@ rollback:
return -1; return -1;
} }
int git_reference_resolve(git_reference **ref_out, git_reference *ref) int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
{ {
if (ref->flags & GIT_REF_OID) if (ref->flags & GIT_REF_OID)
return git_reference_lookup(ref_out, ref->owner, ref->name); return git_reference_lookup(ref_out, ref->owner, ref->name);
@ -1478,7 +1478,7 @@ int git_reference_packall(git_repository *repo)
int git_reference_foreach( int git_reference_foreach(
git_repository *repo, git_repository *repo,
unsigned int list_flags, unsigned int list_flags,
int (*callback)(const char *, void *), git_reference_foreach_cb callback,
void *payload) void *payload)
{ {
int result; int result;
@ -1797,7 +1797,7 @@ int git_reference__update(git_repository *repo, const git_oid *oid, const char *
* a new reference and that's it */ * a new reference and that's it */
if (res == GIT_ENOTFOUND) { if (res == GIT_ENOTFOUND) {
giterr_clear(); giterr_clear();
return git_reference_create_oid(NULL, repo, ref_name, oid, 1); return git_reference_create(NULL, repo, ref_name, oid, 1);
} }
if (res < 0) if (res < 0)
@ -1810,7 +1810,7 @@ int git_reference__update(git_repository *repo, const git_oid *oid, const char *
const char *sym_target; const char *sym_target;
/* The target pointed at by this reference */ /* The target pointed at by this reference */
sym_target = git_reference_target(ref); sym_target = git_reference_symbolic_target(ref);
/* resolve the reference to the target it points to */ /* resolve the reference to the target it points to */
res = git_reference_resolve(&aux, ref); res = git_reference_resolve(&aux, ref);
@ -1822,7 +1822,7 @@ int git_reference__update(git_repository *repo, const git_oid *oid, const char *
*/ */
if (res == GIT_ENOTFOUND) { if (res == GIT_ENOTFOUND) {
giterr_clear(); giterr_clear();
res = git_reference_create_oid(NULL, repo, sym_target, oid, 1); res = git_reference_create(NULL, repo, sym_target, oid, 1);
git_reference_free(ref); git_reference_free(ref);
return res; return res;
} }
@ -1840,7 +1840,7 @@ int git_reference__update(git_repository *repo, const git_oid *oid, const char *
/* ref is made to point to `oid`: ref is either the original reference, /* ref is made to point to `oid`: ref is either the original reference,
* or the target of the symbolic reference we've looked up */ * or the target of the symbolic reference we've looked up */
res = git_reference_set_oid(ref, oid); res = git_reference_set_target(ref, oid);
git_reference_free(ref); git_reference_free(ref);
return res; return res;
} }
@ -1923,7 +1923,7 @@ static int reference_target(git_object **object, git_reference *ref)
{ {
const git_oid *oid; const git_oid *oid;
oid = git_reference_oid(ref); oid = git_reference_target(ref);
return git_object_lookup(object, git_reference_owner(ref), oid, GIT_OBJ_ANY); return git_object_lookup(object, git_reference_owner(ref), oid, GIT_OBJ_ANY);
} }

46
src/remote.c
View File

@ -252,7 +252,7 @@ static int update_config_refspec(
&name, &name,
"remote.%s.%s", "remote.%s.%s",
remote_name, remote_name,
git_direction == GIT_DIR_FETCH ? "fetch" : "push") < 0) git_direction == GIT_DIRECTION_FETCH ? "fetch" : "push") < 0)
goto cleanup; goto cleanup;
if (git_refspec__serialize(&value, refspec) < 0) if (git_refspec__serialize(&value, refspec) < 0)
@ -303,7 +303,7 @@ int git_remote_save(const git_remote *remote)
return -1; return -1;
} }
} else { } else {
int error = git_config_delete(config, git_buf_cstr(&buf)); int error = git_config_delete_entry(config, git_buf_cstr(&buf));
if (error == GIT_ENOTFOUND) { if (error == GIT_ENOTFOUND) {
error = 0; error = 0;
giterr_clear(); giterr_clear();
@ -318,14 +318,14 @@ int git_remote_save(const git_remote *remote)
config, config,
remote->name, remote->name,
&remote->fetch, &remote->fetch,
GIT_DIR_FETCH) < 0) GIT_DIRECTION_FETCH) < 0)
goto on_error; goto on_error;
if (update_config_refspec( if (update_config_refspec(
config, config,
remote->name, remote->name,
&remote->push, &remote->push,
GIT_DIR_PUSH) < 0) GIT_DIRECTION_PUSH) < 0)
goto on_error; goto on_error;
/* /*
@ -356,7 +356,7 @@ int git_remote_save(const git_remote *remote)
if (git_config_set_string(config, git_buf_cstr(&buf), "--no-tags") < 0) if (git_config_set_string(config, git_buf_cstr(&buf), "--no-tags") < 0)
goto on_error; goto on_error;
} else if (tagopt) { } else if (tagopt) {
if (git_config_delete(config, git_buf_cstr(&buf)) < 0) if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
goto on_error; goto on_error;
} }
@ -369,13 +369,13 @@ on_error:
return -1; return -1;
} }
const char *git_remote_name(git_remote *remote) const char *git_remote_name(const git_remote *remote)
{ {
assert(remote); assert(remote);
return remote->name; return remote->name;
} }
const char *git_remote_url(git_remote *remote) const char *git_remote_url(const git_remote *remote)
{ {
assert(remote); assert(remote);
return remote->url; return remote->url;
@ -393,7 +393,7 @@ int git_remote_set_url(git_remote *remote, const char* url)
return 0; return 0;
} }
const char *git_remote_pushurl(git_remote *remote) const char *git_remote_pushurl(const git_remote *remote)
{ {
assert(remote); assert(remote);
return remote->pushurl; return remote->pushurl;
@ -429,7 +429,7 @@ int git_remote_set_fetchspec(git_remote *remote, const char *spec)
return 0; return 0;
} }
const git_refspec *git_remote_fetchspec(git_remote *remote) const git_refspec *git_remote_fetchspec(const git_remote *remote)
{ {
assert(remote); assert(remote);
return &remote->fetch; return &remote->fetch;
@ -451,7 +451,7 @@ int git_remote_set_pushspec(git_remote *remote, const char *spec)
return 0; return 0;
} }
const git_refspec *git_remote_pushspec(git_remote *remote) const git_refspec *git_remote_pushspec(const git_remote *remote)
{ {
assert(remote); assert(remote);
return &remote->push; return &remote->push;
@ -461,18 +461,18 @@ const char* git_remote__urlfordirection(git_remote *remote, int direction)
{ {
assert(remote); assert(remote);
if (direction == GIT_DIR_FETCH) { if (direction == GIT_DIRECTION_FETCH) {
return remote->url; return remote->url;
} }
if (direction == GIT_DIR_PUSH) { if (direction == GIT_DIRECTION_PUSH) {
return remote->pushurl ? remote->pushurl : remote->url; return remote->pushurl ? remote->pushurl : remote->url;
} }
return NULL; return NULL;
} }
int git_remote_connect(git_remote *remote, int direction) int git_remote_connect(git_remote *remote, git_direction direction)
{ {
git_transport *t; git_transport *t;
const char *url; const char *url;
@ -492,7 +492,7 @@ int git_remote_connect(git_remote *remote, int direction)
return -1; return -1;
if (t->set_callbacks && if (t->set_callbacks &&
t->set_callbacks(t, remote->callbacks.progress, NULL, remote->callbacks.data) < 0) t->set_callbacks(t, remote->callbacks.progress, NULL, remote->callbacks.payload) < 0)
goto on_error; goto on_error;
if (!remote->check_cert) if (!remote->check_cert)
@ -695,7 +695,7 @@ int git_remote_update_tips(git_remote *remote)
head = (git_remote_head *)refs.contents[0]; head = (git_remote_head *)refs.contents[0];
if (!strcmp(head->name, GIT_HEAD_FILE)) { if (!strcmp(head->name, GIT_HEAD_FILE)) {
if (git_reference_create_oid(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1) < 0) if (git_reference_create(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1) < 0)
goto on_error; goto on_error;
i = 1; i = 1;
@ -735,7 +735,7 @@ int git_remote_update_tips(git_remote *remote)
if (git_vector_insert(&update_heads, head) < 0) if (git_vector_insert(&update_heads, head) < 0)
goto on_error; goto on_error;
error = git_reference_name_to_oid(&old, remote->repo, refname.ptr); error = git_reference_name_to_id(&old, remote->repo, refname.ptr);
if (error < 0 && error != GIT_ENOTFOUND) if (error < 0 && error != GIT_ENOTFOUND)
goto on_error; goto on_error;
@ -746,14 +746,14 @@ int git_remote_update_tips(git_remote *remote)
continue; continue;
/* In autotag mode, don't overwrite any locally-existing tags */ /* In autotag mode, don't overwrite any locally-existing tags */
error = git_reference_create_oid(&ref, remote->repo, refname.ptr, &head->oid, !autotag); error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag);
if (error < 0 && error != GIT_EEXISTS) if (error < 0 && error != GIT_EEXISTS)
goto on_error; goto on_error;
git_reference_free(ref); git_reference_free(ref);
if (remote->callbacks.update_tips != NULL) { if (remote->callbacks.update_tips != NULL) {
if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.data) < 0) if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.payload) < 0)
goto on_error; goto on_error;
} }
} }
@ -936,7 +936,7 @@ void git_remote_set_callbacks(git_remote *remote, git_remote_callbacks *callback
remote->transport->set_callbacks(remote->transport, remote->transport->set_callbacks(remote->transport,
remote->callbacks.progress, remote->callbacks.progress,
NULL, NULL,
remote->callbacks.data); remote->callbacks.payload);
} }
void git_remote_set_cred_acquire_cb( void git_remote_set_cred_acquire_cb(
@ -967,12 +967,12 @@ const git_transfer_progress* git_remote_stats(git_remote *remote)
return &remote->stats; return &remote->stats;
} }
int git_remote_autotag(git_remote *remote) git_remote_autotag_option_t git_remote_autotag(git_remote *remote)
{ {
return remote->download_tags; return remote->download_tags;
} }
void git_remote_set_autotag(git_remote *remote, int value) void git_remote_set_autotag(git_remote *remote, git_remote_autotag_option_t value)
{ {
remote->download_tags = value; remote->download_tags = value;
} }
@ -1194,7 +1194,7 @@ static int rename_fetch_refspecs(
if (git_repository_config__weakptr(&config, remote->repo) < 0) if (git_repository_config__weakptr(&config, remote->repo) < 0)
goto cleanup; goto cleanup;
error = update_config_refspec(config, new_name, &remote->fetch, GIT_DIR_FETCH); error = update_config_refspec(config, new_name, &remote->fetch, GIT_DIRECTION_FETCH);
cleanup: cleanup:
git_buf_free(&serialized); git_buf_free(&serialized);
@ -1205,7 +1205,7 @@ cleanup:
int git_remote_rename( int git_remote_rename(
git_remote *remote, git_remote *remote,
const char *new_name, const char *new_name,
int (*callback)(const char *problematic_refspec, void *payload), git_remote_rename_problem_cb callback,
void *payload) void *payload)
{ {
int error; int error;

8
src/remote.h
View File

@ -27,10 +27,10 @@ struct git_remote {
git_repository *repo; git_repository *repo;
git_remote_callbacks callbacks; git_remote_callbacks callbacks;
git_transfer_progress stats; git_transfer_progress stats;
unsigned int need_pack:1, unsigned int need_pack;
download_tags:2, /* There are four possible values */ git_remote_autotag_option_t download_tags;
check_cert:1, unsigned int check_cert;
update_fetchhead:1; unsigned int update_fetchhead;
}; };
const char* git_remote__urlfordirection(struct git_remote *remote, int direction); const char* git_remote__urlfordirection(struct git_remote *remote, int direction);

32
src/repository.c
View File

@ -361,7 +361,7 @@ static int find_repo(
int git_repository_open_ext( int git_repository_open_ext(
git_repository **repo_ptr, git_repository **repo_ptr,
const char *start_path, const char *start_path,
uint32_t flags, unsigned int flags,
const char *ceiling_dirs) const char *ceiling_dirs)
{ {
int error; int error;
@ -824,7 +824,7 @@ static int repo_init_config(
SET_REPO_CONFIG(string, "core.worktree", work_dir); SET_REPO_CONFIG(string, "core.worktree", work_dir);
} }
else if ((opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0) { else if ((opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0) {
if (git_config_delete(config, "core.worktree") < 0) if (git_config_delete_entry(config, "core.worktree") < 0)
giterr_clear(); giterr_clear();
} }
} else { } else {
@ -1162,14 +1162,14 @@ int git_repository_init(
} }
int git_repository_init_ext( int git_repository_init_ext(
git_repository **repo_out, git_repository **out,
const char *given_repo, const char *given_repo,
git_repository_init_options *opts) git_repository_init_options *opts)
{ {
int error; int error;
git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT; git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;
assert(repo_out && given_repo && opts); assert(out && given_repo && opts);
error = repo_init_directories(&repo_path, &wd_path, given_repo, opts); error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
if (error < 0) if (error < 0)
@ -1202,10 +1202,10 @@ int git_repository_init_ext(
if (error < 0) if (error < 0)
goto cleanup; goto cleanup;
error = git_repository_open(repo_out, git_buf_cstr(&repo_path)); error = git_repository_open(out, git_buf_cstr(&repo_path));
if (!error && opts->origin_url) if (!error && opts->origin_url)
error = repo_init_create_origin(*repo_out, opts->origin_url); error = repo_init_create_origin(*out, opts->origin_url);
cleanup: cleanup:
git_buf_free(&repo_path); git_buf_free(&repo_path);
@ -1231,7 +1231,7 @@ int git_repository_head_detached(git_repository *repo)
return 0; return 0;
} }
exists = git_odb_exists(odb, git_reference_oid(ref)); exists = git_odb_exists(odb, git_reference_target(ref));
git_reference_free(ref); git_reference_free(ref);
return exists; return exists;
@ -1250,7 +1250,7 @@ int git_repository_head(git_reference **head_out, git_repository *repo)
return 0; return 0;
} }
error = git_reference_lookup_resolved(head_out, repo, git_reference_target(head), -1); error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
git_reference_free(head); git_reference_free(head);
return error == GIT_ENOTFOUND ? GIT_EORPHANEDHEAD : error; return error == GIT_ENOTFOUND ? GIT_EORPHANEDHEAD : error;
@ -1305,7 +1305,7 @@ int git_repository_is_empty(git_repository *repo)
goto cleanup; goto cleanup;
if (!(error = strcmp( if (!(error = strcmp(
git_reference_target(head), git_reference_symbolic_target(head),
GIT_REFS_HEADS_DIR "master") == 0)) GIT_REFS_HEADS_DIR "master") == 0))
goto cleanup; goto cleanup;
@ -1356,7 +1356,7 @@ int git_repository_set_workdir(
/* passthrough error means gitlink is unnecessary */ /* passthrough error means gitlink is unnecessary */
if (error == GIT_PASSTHROUGH) if (error == GIT_PASSTHROUGH)
error = git_config_delete(config, "core.worktree"); error = git_config_delete_entry(config, "core.worktree");
else if (!error) else if (!error)
error = git_config_set_string(config, "core.worktree", path.ptr); error = git_config_set_string(config, "core.worktree", path.ptr);
@ -1531,11 +1531,11 @@ int git_repository_set_head(
if (!error) { if (!error) {
if (git_reference_is_branch(ref)) if (git_reference_is_branch(ref))
error = git_reference_create_symbolic(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1); error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1);
else else
error = git_repository_set_head_detached(repo, git_reference_oid(ref)); error = git_repository_set_head_detached(repo, git_reference_target(ref));
} else if (looks_like_a_branch(refname)) } else if (looks_like_a_branch(refname))
error = git_reference_create_symbolic(&new_head, repo, GIT_HEAD_FILE, refname, 1); error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname, 1);
git_reference_free(ref); git_reference_free(ref);
git_reference_free(new_head); git_reference_free(new_head);
@ -1559,7 +1559,7 @@ int git_repository_set_head_detached(
if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0) if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
goto cleanup; goto cleanup;
error = git_reference_create_oid(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1); error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1);
cleanup: cleanup:
git_object_free(object); git_object_free(object);
@ -1581,10 +1581,10 @@ int git_repository_detach_head(
if ((error = git_repository_head(&old_head, repo)) < 0) if ((error = git_repository_head(&old_head, repo)) < 0)
return error; return error;
if ((error = git_object_lookup(&object, repo, git_reference_oid(old_head), GIT_OBJ_COMMIT)) < 0) if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
goto cleanup; goto cleanup;
error = git_reference_create_oid(&new_head, repo, GIT_HEAD_FILE, git_reference_oid(old_head), 1); error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), 1);
cleanup: cleanup:
git_object_free(object); git_object_free(object);

8
src/reset.c
View File

@ -41,14 +41,14 @@ static int update_head(git_repository *repo, git_object *commit)
if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0) if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
goto cleanup; goto cleanup;
if ((error = git_reference_create_oid( if ((error = git_reference_create(
&target, &target,
repo, repo,
git_reference_target(head), git_reference_symbolic_target(head),
git_object_id(commit), 0)) < 0) git_object_id(commit), 0)) < 0)
goto cleanup; goto cleanup;
} else { } else {
if ((error = git_reference_set_oid(head, git_object_id(commit))) < 0) if ((error = git_reference_set_target(head, git_object_id(commit))) < 0)
goto cleanup; goto cleanup;
} }
@ -63,7 +63,7 @@ cleanup:
int git_reset( int git_reset(
git_repository *repo, git_repository *repo,
git_object *target, git_object *target,
git_reset_type reset_type) git_reset_t reset_type)
{ {
git_object *commit = NULL; git_object *commit = NULL;
git_index *index = NULL; git_index *index = NULL;

39
src/revparse.c
View File

@ -140,7 +140,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
error = disambiguate_refname(&ref, repo, spec); error = disambiguate_refname(&ref, repo, spec);
if (!error) { if (!error) {
error = git_object_lookup(out, repo, git_reference_oid(ref), GIT_OBJ_ANY); error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
git_reference_free(ref); git_reference_free(ref);
return error; return error;
} }
@ -161,7 +161,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
static int try_parse_numeric(int *n, const char *curly_braces_content) static int try_parse_numeric(int *n, const char *curly_braces_content)
{ {
int content; int32_t content;
const char *end_ptr; const char *end_ptr;
if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0) if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0)
@ -170,16 +170,17 @@ static int try_parse_numeric(int *n, const char *curly_braces_content)
if (*end_ptr != '\0') if (*end_ptr != '\0')
return -1; return -1;
*n = content; *n = (int)content;
return 0; return 0;
} }
static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *spec, const char *identifier, unsigned int position) static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *spec, const char *identifier, size_t position)
{ {
git_reference *ref = NULL; git_reference *ref = NULL;
git_reflog *reflog = NULL; git_reflog *reflog = NULL;
regex_t preg; regex_t preg;
int numentries, i, cur, error = -1; int error = -1;
size_t i, numentries, cur;
const git_reflog_entry *entry; const git_reflog_entry *entry;
const char *msg; const char *msg;
regmatch_t regexmatches[2]; regmatch_t regexmatches[2];
@ -203,7 +204,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
for (i = 0; i < numentries; i++) { for (i = 0; i < numentries; i++) {
entry = git_reflog_entry_byindex(reflog, i); entry = git_reflog_entry_byindex(reflog, i);
msg = git_reflog_entry_msg(entry); msg = git_reflog_entry_message(entry);
if (regexec(&preg, msg, 2, regexmatches, 0)) if (regexec(&preg, msg, 2, regexmatches, 0))
continue; continue;
@ -236,11 +237,11 @@ cleanup:
return error; return error;
} }
static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned int identifier) static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier)
{ {
git_reflog *reflog; git_reflog *reflog;
int error = -1; int error = -1;
unsigned int numentries; size_t numentries;
const git_reflog_entry *entry; const git_reflog_entry *entry;
bool search_by_pos = (identifier <= 100000000); bool search_by_pos = (identifier <= 100000000);
@ -253,32 +254,30 @@ static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned i
if (numentries < identifier + 1) { if (numentries < identifier + 1) {
giterr_set( giterr_set(
GITERR_REFERENCE, GITERR_REFERENCE,
"Reflog for '%s' has only %d entries, asked for %d", "Reflog for '%s' has only "PRIuZ" entries, asked for "PRIuZ,
git_reference_name(ref), git_reference_name(ref), numentries, identifier);
numentries,
identifier);
error = GIT_ENOTFOUND; error = GIT_ENOTFOUND;
goto cleanup; goto cleanup;
} }
entry = git_reflog_entry_byindex(reflog, identifier); entry = git_reflog_entry_byindex(reflog, identifier);
git_oid_cpy(oid, git_reflog_entry_oidnew(entry)); git_oid_cpy(oid, git_reflog_entry_id_new(entry));
error = 0; error = 0;
goto cleanup; goto cleanup;
} else { } else {
unsigned int i; size_t i;
git_time commit_time; git_time commit_time;
for (i = 0; i < numentries; i++) { for (i = 0; i < numentries; i++) {
entry = git_reflog_entry_byindex(reflog, i); entry = git_reflog_entry_byindex(reflog, i);
commit_time = git_reflog_entry_committer(entry)->when; commit_time = git_reflog_entry_committer(entry)->when;
if (commit_time.time - identifier > 0) if (commit_time.time > (git_time_t)identifier)
continue; continue;
git_oid_cpy(oid, git_reflog_entry_oidnew(entry)); git_oid_cpy(oid, git_reflog_entry_id_new(entry));
error = 0; error = 0;
goto cleanup; goto cleanup;
} }
@ -291,7 +290,7 @@ cleanup:
return error; return error;
} }
static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, unsigned int position) static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
{ {
git_reference *ref; git_reference *ref;
git_oid oid; git_oid oid;
@ -306,7 +305,7 @@ static int retrieve_revobject_from_reflog(git_object **out, git_reference **base
} }
if (position == 0) { if (position == 0) {
error = git_object_lookup(out, repo, git_reference_oid(ref), GIT_OBJ_ANY); error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
goto cleanup; goto cleanup;
} }
@ -380,7 +379,7 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s
if (git__date_parse(&timestamp, curly_braces_content) < 0) if (git__date_parse(&timestamp, curly_braces_content) < 0)
goto cleanup; goto cleanup;
error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (unsigned int)timestamp); error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp);
cleanup: cleanup:
git_buf_free(&identifier); git_buf_free(&identifier);
@ -632,7 +631,7 @@ static int object_from_reference(git_object **object, git_reference *reference)
if (git_reference_resolve(&resolved, reference) < 0) if (git_reference_resolve(&resolved, reference) < 0)
return -1; return -1;
error = git_object_lookup(object, reference->owner, git_reference_oid(resolved), GIT_OBJ_ANY); error = git_object_lookup(object, reference->owner, git_reference_target(resolved), GIT_OBJ_ANY);
git_reference_free(resolved); git_reference_free(resolved);
return error; return error;

507
src/revwalk.c
View File

@ -8,149 +8,16 @@
#include "common.h" #include "common.h"
#include "commit.h" #include "commit.h"
#include "odb.h" #include "odb.h"
#include "pqueue.h"
#include "pool.h" #include "pool.h"
#include "oidmap.h"
#include "git2/revwalk.h" #include "revwalk.h"
#include "git2/merge.h" #include "merge.h"
#include <regex.h> #include <regex.h>
GIT__USE_OIDMAP; git_commit_list_node *commit_lookup(git_revwalk *walk, const git_oid *oid)
#define PARENT1 (1 << 0)
#define PARENT2 (1 << 1)
#define RESULT (1 << 2)
#define STALE (1 << 3)
typedef struct commit_object {
git_oid oid;
uint32_t time;
unsigned int seen:1,
uninteresting:1,
topo_delay:1,
parsed:1,
flags : 4;
unsigned short in_degree;
unsigned short out_degree;
struct commit_object **parents;
} commit_object;
typedef struct commit_list {
commit_object *item;
struct commit_list *next;
} commit_list;
struct git_revwalk {
git_repository *repo;
git_odb *odb;
git_oidmap *commits;
git_pool commit_pool;
commit_list *iterator_topo;
commit_list *iterator_rand;
commit_list *iterator_reverse;
git_pqueue iterator_time;
int (*get_next)(commit_object **, git_revwalk *);
int (*enqueue)(git_revwalk *, commit_object *);
unsigned walking:1;
unsigned int sorting;
/* merge base calculation */
commit_object *one;
git_vector twos;
};
static int commit_time_cmp(void *a, void *b)
{ {
commit_object *commit_a = (commit_object *)a; git_commit_list_node *commit;
commit_object *commit_b = (commit_object *)b;
return (commit_a->time < commit_b->time);
}
static commit_list *commit_list_insert(commit_object *item, commit_list **list_p)
{
commit_list *new_list = git__malloc(sizeof(commit_list));
if (new_list != NULL) {
new_list->item = item;
new_list->next = *list_p;
}
*list_p = new_list;
return new_list;
}
static commit_list *commit_list_insert_by_date(commit_object *item, commit_list **list_p)
{
commit_list **pp = list_p;
commit_list *p;
while ((p = *pp) != NULL) {
if (commit_time_cmp(p->item, item) < 0)
break;
pp = &p->next;
}
return commit_list_insert(item, pp);
}
static void commit_list_free(commit_list **list_p)
{
commit_list *list = *list_p;
if (list == NULL)
return;
while (list) {
commit_list *temp = list;
list = temp->next;
git__free(temp);
}
*list_p = NULL;
}
static commit_object *commit_list_pop(commit_list **stack)
{
commit_list *top = *stack;
commit_object *item = top ? top->item : NULL;
if (top) {
*stack = top->next;
git__free(top);
}
return item;
}
#define PARENTS_PER_COMMIT 2
#define COMMIT_ALLOC \
(sizeof(commit_object) + PARENTS_PER_COMMIT * sizeof(commit_object *))
static commit_object *alloc_commit(git_revwalk *walk)
{
return (commit_object *)git_pool_malloc(&walk->commit_pool, COMMIT_ALLOC);
}
static commit_object **alloc_parents(
git_revwalk *walk, commit_object *commit, size_t n_parents)
{
if (n_parents <= PARENTS_PER_COMMIT)
return (commit_object **)((char *)commit + sizeof(commit_object));
return (commit_object **)git_pool_malloc(
&walk->commit_pool, (uint32_t)(n_parents * sizeof(commit_object *)));
}
static commit_object *commit_lookup(git_revwalk *walk, const git_oid *oid)
{
commit_object *commit;
khiter_t pos; khiter_t pos;
int ret; int ret;
@ -159,7 +26,7 @@ static commit_object *commit_lookup(git_revwalk *walk, const git_oid *oid)
if (pos != kh_end(walk->commits)) if (pos != kh_end(walk->commits))
return kh_value(walk->commits, pos); return kh_value(walk->commits, pos);
commit = alloc_commit(walk); commit = git_commit_list_alloc_node(walk);
if (commit == NULL) if (commit == NULL)
return NULL; return NULL;
@ -172,300 +39,7 @@ static commit_object *commit_lookup(git_revwalk *walk, const git_oid *oid)
return commit; return commit;
} }
static int commit_error(commit_object *commit, const char *msg) static void mark_uninteresting(git_commit_list_node *commit)
{
char commit_oid[GIT_OID_HEXSZ + 1];
git_oid_fmt(commit_oid, &commit->oid);
commit_oid[GIT_OID_HEXSZ] = '\0';
giterr_set(GITERR_ODB, "Failed to parse commit %s - %s", commit_oid, msg);
return -1;
}
static int commit_quick_parse(git_revwalk *walk, commit_object *commit, git_rawobj *raw)
{
const size_t parent_len = strlen("parent ") + GIT_OID_HEXSZ + 1;
unsigned char *buffer = raw->data;
unsigned char *buffer_end = buffer + raw->len;
unsigned char *parents_start, *committer_start;
int i, parents = 0;
int commit_time;
buffer += strlen("tree ") + GIT_OID_HEXSZ + 1;
parents_start = buffer;
while (buffer + parent_len < buffer_end && memcmp(buffer, "parent ", strlen("parent ")) == 0) {
parents++;
buffer += parent_len;
}
commit->parents = alloc_parents(walk, commit, parents);
GITERR_CHECK_ALLOC(commit->parents);
buffer = parents_start;
for (i = 0; i < parents; ++i) {
git_oid oid;
if (git_oid_fromstr(&oid, (char *)buffer + strlen("parent ")) < 0)
return -1;
commit->parents[i] = commit_lookup(walk, &oid);
if (commit->parents[i] == NULL)
return -1;
buffer += parent_len;
}
commit->out_degree = (unsigned short)parents;
if ((committer_start = buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
return commit_error(commit, "object is corrupted");
buffer++;
if ((buffer = memchr(buffer, '\n', buffer_end - buffer)) == NULL)
return commit_error(commit, "object is corrupted");
/* Skip trailing spaces */
while (buffer > committer_start && git__isspace(*buffer))
buffer--;
/* Seek for the begining of the pack of digits */
while (buffer > committer_start && git__isdigit(*buffer))
buffer--;
/* Skip potential timezone offset */
if ((buffer > committer_start) && (*buffer == '+' || *buffer == '-')) {
buffer--;
while (buffer > committer_start && git__isspace(*buffer))
buffer--;
while (buffer > committer_start && git__isdigit(*buffer))
buffer--;
}
if ((buffer == committer_start) || (git__strtol32(&commit_time, (char *)(buffer + 1), NULL, 10) < 0))
return commit_error(commit, "cannot parse commit time");
commit->time = (time_t)commit_time;
commit->parsed = 1;
return 0;
}
static int commit_parse(git_revwalk *walk, commit_object *commit)
{
git_odb_object *obj;
int error;
if (commit->parsed)
return 0;
if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0)
return error;
assert(obj->raw.type == GIT_OBJ_COMMIT);
error = commit_quick_parse(walk, commit, &obj->raw);
git_odb_object_free(obj);
return error;
}
static int interesting(git_pqueue *list)
{
unsigned int i;
/* element 0 isn't used - we need to start at 1 */
for (i = 1; i < list->size; i++) {
commit_object *commit = list->d[i];
if ((commit->flags & STALE) == 0)
return 1;
}
return 0;
}
static int merge_bases_many(commit_list **out, git_revwalk *walk, commit_object *one, git_vector *twos)
{
int error;
unsigned int i;
commit_object *two;
commit_list *result = NULL, *tmp = NULL;
git_pqueue list;
/* if the commit is repeated, we have a our merge base already */
git_vector_foreach(twos, i, two) {
if (one == two)
return commit_list_insert(one, out) ? 0 : -1;
}
if (git_pqueue_init(&list, twos->length * 2, commit_time_cmp) < 0)
return -1;
if (commit_parse(walk, one) < 0)
return -1;
one->flags |= PARENT1;
if (git_pqueue_insert(&list, one) < 0)
return -1;
git_vector_foreach(twos, i, two) {
commit_parse(walk, two);
two->flags |= PARENT2;
if (git_pqueue_insert(&list, two) < 0)
return -1;
}
/* as long as there are non-STALE commits */
while (interesting(&list)) {
commit_object *commit;
int flags;
commit = git_pqueue_pop(&list);
flags = commit->flags & (PARENT1 | PARENT2 | STALE);
if (flags == (PARENT1 | PARENT2)) {
if (!(commit->flags & RESULT)) {
commit->flags |= RESULT;
if (commit_list_insert(commit, &result) == NULL)
return -1;
}
/* we mark the parents of a merge stale */
flags |= STALE;
}
for (i = 0; i < commit->out_degree; i++) {
commit_object *p = commit->parents[i];
if ((p->flags & flags) == flags)
continue;
if ((error = commit_parse(walk, p)) < 0)
return error;
p->flags |= flags;
if (git_pqueue_insert(&list, p) < 0)
return -1;
}
}
git_pqueue_free(&list);
/* filter out any stale commits in the results */
tmp = result;
result = NULL;
while (tmp) {
struct commit_list *next = tmp->next;
if (!(tmp->item->flags & STALE))
if (commit_list_insert_by_date(tmp->item, &result) == NULL)
return -1;
git__free(tmp);
tmp = next;
}
*out = result;
return 0;
}
int git_merge_base_many(git_oid *out, git_repository *repo, const git_oid input_array[], size_t length)
{
git_revwalk *walk;
git_vector list;
commit_list *result = NULL;
int error = -1;
unsigned int i;
commit_object *commit;
assert(out && repo && input_array);
if (length < 2) {
giterr_set(GITERR_INVALID, "At least two commits are required to find an ancestor. Provided 'length' was %u.", length);
return -1;
}
if (git_vector_init(&list, length - 1, NULL) < 0)
return -1;
if (git_revwalk_new(&walk, repo) < 0)
goto cleanup;
for (i = 1; i < length; i++) {
commit = commit_lookup(walk, &input_array[i]);
if (commit == NULL)
goto cleanup;
git_vector_insert(&list, commit);
}
commit = commit_lookup(walk, &input_array[0]);
if (commit == NULL)
goto cleanup;
if (merge_bases_many(&result, walk, commit, &list) < 0)
goto cleanup;
if (!result) {
error = GIT_ENOTFOUND;
goto cleanup;
}
git_oid_cpy(out, &result->item->oid);
error = 0;
cleanup:
commit_list_free(&result);
git_revwalk_free(walk);
git_vector_free(&list);
return error;
}
int git_merge_base(git_oid *out, git_repository *repo, const git_oid *one, const git_oid *two)
{
git_revwalk *walk;
git_vector list;
commit_list *result = NULL;
commit_object *commit;
void *contents[1];
if (git_revwalk_new(&walk, repo) < 0)
return -1;
commit = commit_lookup(walk, two);
if (commit == NULL)
goto on_error;
/* This is just one value, so we can do it on the stack */
memset(&list, 0x0, sizeof(git_vector));
contents[0] = commit;
list.length = 1;
list.contents = contents;
commit = commit_lookup(walk, one);
if (commit == NULL)
goto on_error;
if (merge_bases_many(&result, walk, commit, &list) < 0)
goto on_error;
if (!result) {
git_revwalk_free(walk);
giterr_clear();
return GIT_ENOTFOUND;
}
git_oid_cpy(out, &result->item->oid);
commit_list_free(&result);
git_revwalk_free(walk);
return 0;
on_error:
git_revwalk_free(walk);
return -1;
}
static void mark_uninteresting(commit_object *commit)
{ {
unsigned short i; unsigned short i;
assert(commit); assert(commit);
@ -481,7 +55,7 @@ static void mark_uninteresting(commit_object *commit)
mark_uninteresting(commit->parents[i]); mark_uninteresting(commit->parents[i]);
} }
static int process_commit(git_revwalk *walk, commit_object *commit, int hide) static int process_commit(git_revwalk *walk, git_commit_list_node *commit, int hide)
{ {
int error; int error;
@ -493,13 +67,13 @@ static int process_commit(git_revwalk *walk, commit_object *commit, int hide)
commit->seen = 1; commit->seen = 1;
if ((error = commit_parse(walk, commit)) < 0) if ((error = git_commit_list_parse(walk, commit)) < 0)
return error; return error;
return walk->enqueue(walk, commit); return walk->enqueue(walk, commit);
} }
static int process_commit_parents(git_revwalk *walk, commit_object *commit) static int process_commit_parents(git_revwalk *walk, git_commit_list_node *commit)
{ {
unsigned short i; unsigned short i;
int error = 0; int error = 0;
@ -514,7 +88,7 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
{ {
git_object *obj; git_object *obj;
git_otype type; git_otype type;
commit_object *commit; git_commit_list_node *commit;
if (git_object_lookup(&obj, walk->repo, oid, GIT_OBJ_ANY) < 0) if (git_object_lookup(&obj, walk->repo, oid, GIT_OBJ_ANY) < 0)
return -1; return -1;
@ -559,7 +133,7 @@ static int push_ref(git_revwalk *walk, const char *refname, int hide)
{ {
git_oid oid; git_oid oid;
if (git_reference_name_to_oid(&oid, walk->repo, refname) < 0) if (git_reference_name_to_id(&oid, walk->repo, refname) < 0)
return -1; return -1;
return push_commit(walk, &oid, hide); return push_commit(walk, &oid, hide);
@ -659,20 +233,20 @@ int git_revwalk_hide_ref(git_revwalk *walk, const char *refname)
return push_ref(walk, refname, 1); return push_ref(walk, refname, 1);
} }
static int revwalk_enqueue_timesort(git_revwalk *walk, commit_object *commit) static int revwalk_enqueue_timesort(git_revwalk *walk, git_commit_list_node *commit)
{ {
return git_pqueue_insert(&walk->iterator_time, commit); return git_pqueue_insert(&walk->iterator_time, commit);
} }
static int revwalk_enqueue_unsorted(git_revwalk *walk, commit_object *commit) static int revwalk_enqueue_unsorted(git_revwalk *walk, git_commit_list_node *commit)
{ {
return commit_list_insert(commit, &walk->iterator_rand) ? 0 : -1; return git_commit_list_insert(commit, &walk->iterator_rand) ? 0 : -1;
} }
static int revwalk_next_timesort(commit_object **object_out, git_revwalk *walk) static int revwalk_next_timesort(git_commit_list_node **object_out, git_revwalk *walk)
{ {
int error; int error;
commit_object *next; git_commit_list_node *next;
while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL) { while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL) {
if ((error = process_commit_parents(walk, next)) < 0) if ((error = process_commit_parents(walk, next)) < 0)
@ -688,12 +262,12 @@ static int revwalk_next_timesort(commit_object **object_out, git_revwalk *walk)
return GIT_ITEROVER; return GIT_ITEROVER;
} }
static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk) static int revwalk_next_unsorted(git_commit_list_node **object_out, git_revwalk *walk)
{ {
int error; int error;
commit_object *next; git_commit_list_node *next;
while ((next = commit_list_pop(&walk->iterator_rand)) != NULL) { while ((next = git_commit_list_pop(&walk->iterator_rand)) != NULL) {
if ((error = process_commit_parents(walk, next)) < 0) if ((error = process_commit_parents(walk, next)) < 0)
return error; return error;
@ -707,13 +281,13 @@ static int revwalk_next_unsorted(commit_object **object_out, git_revwalk *walk)
return GIT_ITEROVER; return GIT_ITEROVER;
} }
static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk) static int revwalk_next_toposort(git_commit_list_node **object_out, git_revwalk *walk)
{ {
commit_object *next; git_commit_list_node *next;
unsigned short i; unsigned short i;
for (;;) { for (;;) {
next = commit_list_pop(&walk->iterator_topo); next = git_commit_list_pop(&walk->iterator_topo);
if (next == NULL) { if (next == NULL) {
giterr_clear(); giterr_clear();
return GIT_ITEROVER; return GIT_ITEROVER;
@ -725,11 +299,11 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk)
} }
for (i = 0; i < next->out_degree; ++i) { for (i = 0; i < next->out_degree; ++i) {
commit_object *parent = next->parents[i]; git_commit_list_node *parent = next->parents[i];
if (--parent->in_degree == 0 && parent->topo_delay) { if (--parent->in_degree == 0 && parent->topo_delay) {
parent->topo_delay = 0; parent->topo_delay = 0;
if (commit_list_insert(parent, &walk->iterator_topo) == NULL) if (git_commit_list_insert(parent, &walk->iterator_topo) == NULL)
return -1; return -1;
} }
} }
@ -739,9 +313,9 @@ static int revwalk_next_toposort(commit_object **object_out, git_revwalk *walk)
} }
} }
static int revwalk_next_reverse(commit_object **object_out, git_revwalk *walk) static int revwalk_next_reverse(git_commit_list_node **object_out, git_revwalk *walk)
{ {
*object_out = commit_list_pop(&walk->iterator_reverse); *object_out = git_commit_list_pop(&walk->iterator_reverse);
return *object_out ? 0 : GIT_ITEROVER; return *object_out ? 0 : GIT_ITEROVER;
} }
@ -750,8 +324,8 @@ static int prepare_walk(git_revwalk *walk)
{ {
int error; int error;
unsigned int i; unsigned int i;
commit_object *next, *two; git_commit_list_node *next, *two;
commit_list *bases = NULL; git_commit_list *bases = NULL;
/* /*
* If walk->one is NULL, there were no positive references, * If walk->one is NULL, there were no positive references,
@ -763,10 +337,10 @@ static int prepare_walk(git_revwalk *walk)
} }
/* first figure out what the merge bases are */ /* first figure out what the merge bases are */
if (merge_bases_many(&bases, walk, walk->one, &walk->twos) < 0) if (git_merge__bases_many(&bases, walk, walk->one, &walk->twos) < 0)
return -1; return -1;
commit_list_free(&bases); git_commit_list_free(&bases);
if (process_commit(walk, walk->one, walk->one->uninteresting) < 0) if (process_commit(walk, walk->one, walk->one->uninteresting) < 0)
return -1; return -1;
@ -780,11 +354,11 @@ static int prepare_walk(git_revwalk *walk)
while ((error = walk->get_next(&next, walk)) == 0) { while ((error = walk->get_next(&next, walk)) == 0) {
for (i = 0; i < next->out_degree; ++i) { for (i = 0; i < next->out_degree; ++i) {
commit_object *parent = next->parents[i]; git_commit_list_node *parent = next->parents[i];
parent->in_degree++; parent->in_degree++;
} }
if (commit_list_insert(next, &walk->iterator_topo) == NULL) if (git_commit_list_insert(next, &walk->iterator_topo) == NULL)
return -1; return -1;
} }
@ -797,7 +371,7 @@ static int prepare_walk(git_revwalk *walk)
if (walk->sorting & GIT_SORT_REVERSE) { if (walk->sorting & GIT_SORT_REVERSE) {
while ((error = walk->get_next(&next, walk)) == 0) while ((error = walk->get_next(&next, walk)) == 0)
if (commit_list_insert(next, &walk->iterator_reverse) == NULL) if (git_commit_list_insert(next, &walk->iterator_reverse) == NULL)
return -1; return -1;
if (error != GIT_ITEROVER) if (error != GIT_ITEROVER)
@ -811,9 +385,6 @@ static int prepare_walk(git_revwalk *walk)
} }
int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo) int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
{ {
git_revwalk *walk; git_revwalk *walk;
@ -826,7 +397,7 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
walk->commits = git_oidmap_alloc(); walk->commits = git_oidmap_alloc();
GITERR_CHECK_ALLOC(walk->commits); GITERR_CHECK_ALLOC(walk->commits);
if (git_pqueue_init(&walk->iterator_time, 8, commit_time_cmp) < 0 || if (git_pqueue_init(&walk->iterator_time, 8, git_commit_list_time_cmp) < 0 ||
git_vector_init(&walk->twos, 4, NULL) < 0 || git_vector_init(&walk->twos, 4, NULL) < 0 ||
git_pool_init(&walk->commit_pool, 1, git_pool_init(&walk->commit_pool, 1,
git_pool__suggest_items_per_page(COMMIT_ALLOC) * COMMIT_ALLOC) < 0) git_pool__suggest_items_per_page(COMMIT_ALLOC) * COMMIT_ALLOC) < 0)
@ -888,7 +459,7 @@ void git_revwalk_sorting(git_revwalk *walk, unsigned int sort_mode)
int git_revwalk_next(git_oid *oid, git_revwalk *walk) int git_revwalk_next(git_oid *oid, git_revwalk *walk)
{ {
int error; int error;
commit_object *next; git_commit_list_node *next;
assert(walk && oid); assert(walk && oid);
@ -913,7 +484,7 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk)
void git_revwalk_reset(git_revwalk *walk) void git_revwalk_reset(git_revwalk *walk)
{ {
commit_object *commit; git_commit_list_node *commit;
assert(walk); assert(walk);
@ -925,9 +496,9 @@ void git_revwalk_reset(git_revwalk *walk)
}); });
git_pqueue_clear(&walk->iterator_time); git_pqueue_clear(&walk->iterator_time);
commit_list_free(&walk->iterator_topo); git_commit_list_free(&walk->iterator_topo);
commit_list_free(&walk->iterator_rand); git_commit_list_free(&walk->iterator_rand);
commit_list_free(&walk->iterator_reverse); git_commit_list_free(&walk->iterator_reverse);
walk->walking = 0; walk->walking = 0;
walk->one = NULL; walk->one = NULL;

44
src/revwalk.h Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_revwalk_h__
#define INCLUDE_revwalk_h__
#include "git2/revwalk.h"
#include "oidmap.h"
#include "commit_list.h"
#include "pqueue.h"
#include "pool.h"
#include "vector.h"
GIT__USE_OIDMAP;
struct git_revwalk {
git_repository *repo;
git_odb *odb;
git_oidmap *commits;
git_pool commit_pool;
git_commit_list *iterator_topo;
git_commit_list *iterator_rand;
git_commit_list *iterator_reverse;
git_pqueue iterator_time;
int (*get_next)(git_commit_list_node **, git_revwalk *);
int (*enqueue)(git_revwalk *, git_commit_list_node *);
unsigned walking:1;
unsigned int sorting;
/* merge base calculation */
git_commit_list_node *one;
git_vector twos;
};
git_commit_list_node *commit_lookup(git_revwalk *walk, const git_oid *oid);
#endif

22
src/stash.c
View File

@ -56,7 +56,7 @@ static int append_abbreviated_oid(git_buf *out, const git_oid *b_commit)
static int append_commit_description(git_buf *out, git_commit* commit) static int append_commit_description(git_buf *out, git_commit* commit)
{ {
const char *message; const char *message;
int pos = 0, len; size_t pos = 0, len;
if (append_abbreviated_oid(out, git_commit_id(commit)) < 0) if (append_abbreviated_oid(out, git_commit_id(commit)) < 0)
return -1; return -1;
@ -98,7 +98,7 @@ static int retrieve_base_commit_and_message(
"%s: ", "%s: ",
git_reference_name(head) + strlen(GIT_REFS_HEADS_DIR)); git_reference_name(head) + strlen(GIT_REFS_HEADS_DIR));
if (git_commit_lookup(b_commit, repo, git_reference_oid(head)) < 0) if (git_commit_lookup(b_commit, repo, git_reference_target(head)) < 0)
goto cleanup; goto cleanup;
if (append_commit_description(stash_message, *b_commit) < 0) if (append_commit_description(stash_message, *b_commit) < 0)
@ -169,12 +169,12 @@ struct cb_data {
}; };
static int update_index_cb( static int update_index_cb(
void *cb_data,
const git_diff_delta *delta, const git_diff_delta *delta,
float progress) float progress,
void *payload)
{ {
int pos; int pos;
struct cb_data *data = (struct cb_data *)cb_data; struct cb_data *data = (struct cb_data *)payload;
GIT_UNUSED(progress); GIT_UNUSED(progress);
@ -253,7 +253,7 @@ static int build_untracked_tree(
if (git_diff_workdir_to_tree(&diff, git_index_owner(index), i_tree, &opts) < 0) if (git_diff_workdir_to_tree(&diff, git_index_owner(index), i_tree, &opts) < 0)
goto cleanup; goto cleanup;
if (git_diff_foreach(diff, &data, update_index_cb, NULL, NULL) < 0) if (git_diff_foreach(diff, update_index_cb, NULL, NULL, &data) < 0)
goto cleanup; goto cleanup;
if (build_tree_from_index(tree_out, index) < 0) if (build_tree_from_index(tree_out, index) < 0)
@ -334,7 +334,7 @@ static int build_workdir_tree(
data.index = index; data.index = index;
data.include_changed = true; data.include_changed = true;
if (git_diff_foreach(diff, &data, update_index_cb, NULL, NULL) < 0) if (git_diff_foreach(diff, update_index_cb, NULL, NULL, &data) < 0)
goto cleanup; goto cleanup;
if (build_tree_from_index(tree_out, index) < 0) if (build_tree_from_index(tree_out, index) < 0)
@ -436,7 +436,7 @@ static int update_reflog(
git_reflog *reflog = NULL; git_reflog *reflog = NULL;
int error; int error;
if ((error = git_reference_create_oid(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1)) < 0) if ((error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1)) < 0)
goto cleanup; goto cleanup;
if ((error = git_reflog_read(&reflog, stash)) < 0) if ((error = git_reflog_read(&reflog, stash)) < 0)
@ -579,7 +579,7 @@ cleanup:
int git_stash_foreach( int git_stash_foreach(
git_repository *repo, git_repository *repo,
stash_cb callback, git_stash_cb callback,
void *payload) void *payload)
{ {
git_reference *stash; git_reference *stash;
@ -603,8 +603,8 @@ int git_stash_foreach(
entry = git_reflog_entry_byindex(reflog, i); entry = git_reflog_entry_byindex(reflog, i);
if (callback(i, if (callback(i,
git_reflog_entry_msg(entry), git_reflog_entry_message(entry),
git_reflog_entry_oidnew(entry), git_reflog_entry_id_new(entry),
payload)) { payload)) {
error = GIT_EUSER; error = GIT_EUSER;
goto cleanup; goto cleanup;

18
src/status.c
View File

@ -78,14 +78,14 @@ static unsigned int workdir_delta2status(git_delta_t workdir_status)
} }
typedef struct { typedef struct {
int (*cb)(const char *, unsigned int, void *); git_status_cb cb;
void *cbdata; void *payload;
} status_user_callback; } status_user_callback;
static int status_invoke_cb( static int status_invoke_cb(
void *cbref, git_diff_delta *i2h, git_diff_delta *w2i) git_diff_delta *i2h, git_diff_delta *w2i, void *payload)
{ {
status_user_callback *usercb = cbref; status_user_callback *usercb = payload;
const char *path = NULL; const char *path = NULL;
unsigned int status = 0; unsigned int status = 0;
@ -98,14 +98,14 @@ static int status_invoke_cb(
status |= index_delta2status(i2h->status); status |= index_delta2status(i2h->status);
} }
return usercb->cb(path, status, usercb->cbdata); return usercb->cb(path, status, usercb->payload);
} }
int git_status_foreach_ext( int git_status_foreach_ext(
git_repository *repo, git_repository *repo,
const git_status_options *opts, const git_status_options *opts,
int (*cb)(const char *, unsigned int, void *), git_status_cb cb,
void *cbdata) void *payload)
{ {
int err = 0; int err = 0;
git_diff_options diffopt; git_diff_options diffopt;
@ -152,7 +152,7 @@ int git_status_foreach_ext(
goto cleanup; goto cleanup;
usercb.cb = cb; usercb.cb = cb;
usercb.cbdata = cbdata; usercb.payload = payload;
if (show == GIT_STATUS_SHOW_INDEX_THEN_WORKDIR) { if (show == GIT_STATUS_SHOW_INDEX_THEN_WORKDIR) {
if ((err = git_diff__paired_foreach( if ((err = git_diff__paired_foreach(
@ -178,7 +178,7 @@ cleanup:
int git_status_foreach( int git_status_foreach(
git_repository *repo, git_repository *repo,
int (*callback)(const char *, unsigned int, void *), git_status_cb callback,
void *payload) void *payload)
{ {
git_status_options opts; git_status_options opts;

40
src/submodule.c
View File

@ -66,7 +66,7 @@ __KHASH_IMPL(
str_hash_no_trailing_slash, str_equal_no_trailing_slash); str_hash_no_trailing_slash, str_equal_no_trailing_slash);
static int load_submodule_config(git_repository *repo, bool force); static int load_submodule_config(git_repository *repo, bool force);
static git_config_file *open_gitmodules(git_repository *, bool, const git_oid *); static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
static int lookup_head_remote(git_buf *url, git_repository *repo); static int lookup_head_remote(git_buf *url, git_repository *repo);
static int submodule_get(git_submodule **, git_repository *, const char *, const char *); static int submodule_get(git_submodule **, git_repository *, const char *, const char *);
static void submodule_release(git_submodule *sm, int decr); static void submodule_release(git_submodule *sm, int decr);
@ -201,7 +201,7 @@ int git_submodule_add_setup(
int use_gitlink) int use_gitlink)
{ {
int error = 0; int error = 0;
git_config_file *mods = NULL; git_config_backend *mods = NULL;
git_submodule *sm; git_submodule *sm;
git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT; git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
git_repository_init_options initopt; git_repository_init_options initopt;
@ -412,7 +412,7 @@ cleanup:
int git_submodule_save(git_submodule *submodule) int git_submodule_save(git_submodule *submodule)
{ {
int error = 0; int error = 0;
git_config_file *mods; git_config_backend *mods;
git_buf key = GIT_BUF_INIT; git_buf key = GIT_BUF_INIT;
assert(submodule); assert(submodule);
@ -513,7 +513,7 @@ int git_submodule_set_url(git_submodule *submodule, const char *url)
return 0; return 0;
} }
const git_oid *git_submodule_index_oid(git_submodule *submodule) const git_oid *git_submodule_index_id(git_submodule *submodule)
{ {
assert(submodule); assert(submodule);
@ -523,7 +523,7 @@ const git_oid *git_submodule_index_oid(git_submodule *submodule)
return NULL; return NULL;
} }
const git_oid *git_submodule_head_oid(git_submodule *submodule) const git_oid *git_submodule_head_id(git_submodule *submodule)
{ {
assert(submodule); assert(submodule);
@ -533,7 +533,7 @@ const git_oid *git_submodule_head_oid(git_submodule *submodule)
return NULL; return NULL;
} }
const git_oid *git_submodule_wd_oid(git_submodule *submodule) const git_oid *git_submodule_wd_id(git_submodule *submodule)
{ {
assert(submodule); assert(submodule);
@ -695,7 +695,7 @@ int git_submodule_open(
/* if we have opened the submodule successfully, let's grab the HEAD OID */ /* if we have opened the submodule successfully, let's grab the HEAD OID */
if (!error && !(submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)) { if (!error && !(submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)) {
if (!git_reference_name_to_oid( if (!git_reference_name_to_id(
&submodule->wd_oid, *subrepo, GIT_HEAD_FILE)) &submodule->wd_oid, *subrepo, GIT_HEAD_FILE))
submodule->flags |= GIT_SUBMODULE_STATUS__WD_OID_VALID; submodule->flags |= GIT_SUBMODULE_STATUS__WD_OID_VALID;
else else
@ -717,7 +717,7 @@ int git_submodule_reload(git_submodule *submodule)
git_index *index; git_index *index;
int pos, error; int pos, error;
git_tree *head; git_tree *head;
git_config_file *mods; git_config_backend *mods;
assert(submodule); assert(submodule);
@ -733,7 +733,7 @@ int git_submodule_reload(git_submodule *submodule)
pos = git_index_find(index, submodule->path); pos = git_index_find(index, submodule->path);
if (pos >= 0) { if (pos >= 0) {
git_index_entry *entry = git_index_get_byindex(index, pos); const git_index_entry *entry = git_index_get_byindex(index, pos);
if (S_ISGITLINK(entry->mode)) { if (S_ISGITLINK(entry->mode)) {
if ((error = submodule_load_from_index(repo, entry)) < 0) if ((error = submodule_load_from_index(repo, entry)) < 0)
@ -1187,14 +1187,14 @@ static int load_submodule_config_from_head(
return error; return error;
} }
static git_config_file *open_gitmodules( static git_config_backend *open_gitmodules(
git_repository *repo, git_repository *repo,
bool okay_to_create, bool okay_to_create,
const git_oid *gitmodules_oid) const git_oid *gitmodules_oid)
{ {
const char *workdir = git_repository_workdir(repo); const char *workdir = git_repository_workdir(repo);
git_buf path = GIT_BUF_INIT; git_buf path = GIT_BUF_INIT;
git_config_file *mods = NULL; git_config_backend *mods = NULL;
if (workdir != NULL) { if (workdir != NULL) {
if (git_buf_joinpath(&path, workdir, GIT_MODULES_FILE) != 0) if (git_buf_joinpath(&path, workdir, GIT_MODULES_FILE) != 0)
@ -1230,7 +1230,7 @@ static int load_submodule_config(git_repository *repo, bool force)
int error; int error;
git_oid gitmodules_oid; git_oid gitmodules_oid;
git_buf path = GIT_BUF_INIT; git_buf path = GIT_BUF_INIT;
git_config_file *mods = NULL; git_config_backend *mods = NULL;
if (repo->submodules && !force) if (repo->submodules && !force)
return 0; return 0;
@ -1316,7 +1316,7 @@ static int lookup_head_remote(git_buf *url, git_repository *repo)
/* remote should refer to something like refs/remotes/ORIGIN/BRANCH */ /* remote should refer to something like refs/remotes/ORIGIN/BRANCH */
if (git_reference_type(remote) != GIT_REF_SYMBOLIC || if (git_reference_type(remote) != GIT_REF_SYMBOLIC ||
git__prefixcmp(git_reference_target(remote), GIT_REFS_REMOTES_DIR) != 0) git__prefixcmp(git_reference_symbolic_target(remote), GIT_REFS_REMOTES_DIR) != 0)
{ {
giterr_set(GITERR_SUBMODULE, giterr_set(GITERR_SUBMODULE,
"Cannot resolve relative URL when HEAD is not symbolic"); "Cannot resolve relative URL when HEAD is not symbolic");
@ -1324,7 +1324,7 @@ static int lookup_head_remote(git_buf *url, git_repository *repo)
goto cleanup; goto cleanup;
} }
scan = tgt = git_reference_target(remote) + strlen(GIT_REFS_REMOTES_DIR); scan = tgt = git_reference_symbolic_target(remote) + strlen(GIT_REFS_REMOTES_DIR);
while (*scan && (*scan != '/' || (scan > tgt && scan[-1] != '\\'))) while (*scan && (*scan != '/' || (scan > tgt && scan[-1] != '\\')))
scan++; /* find non-escaped slash to end ORIGIN name */ scan++; /* find non-escaped slash to end ORIGIN name */
@ -1378,7 +1378,7 @@ static int submodule_update_config(
goto cleanup; goto cleanup;
if (!value) if (!value)
error = git_config_delete(config, key.ptr); error = git_config_delete_entry(config, key.ptr);
else else
error = git_config_set_string(config, key.ptr, value); error = git_config_set_string(config, key.ptr, value);
@ -1389,8 +1389,8 @@ cleanup:
static int submodule_index_status(unsigned int *status, git_submodule *sm) static int submodule_index_status(unsigned int *status, git_submodule *sm)
{ {
const git_oid *head_oid = git_submodule_head_oid(sm); const git_oid *head_oid = git_submodule_head_id(sm);
const git_oid *index_oid = git_submodule_index_oid(sm); const git_oid *index_oid = git_submodule_index_id(sm);
if (!head_oid) { if (!head_oid) {
if (index_oid) if (index_oid)
@ -1410,7 +1410,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
const git_oid *wd_oid, *index_oid; const git_oid *wd_oid, *index_oid;
git_repository *sm_repo = NULL; git_repository *sm_repo = NULL;
/* open repo now if we need it (so wd_oid() call won't reopen) */ /* open repo now if we need it (so wd_id() call won't reopen) */
if ((sm->ignore == GIT_SUBMODULE_IGNORE_NONE || if ((sm->ignore == GIT_SUBMODULE_IGNORE_NONE ||
sm->ignore == GIT_SUBMODULE_IGNORE_UNTRACKED) && sm->ignore == GIT_SUBMODULE_IGNORE_UNTRACKED) &&
(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0) (sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0)
@ -1419,8 +1419,8 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
return error; return error;
} }
index_oid = git_submodule_index_oid(sm); index_oid = git_submodule_index_id(sm);
wd_oid = git_submodule_wd_oid(sm); wd_oid = git_submodule_wd_id(sm);
if (!index_oid) { if (!index_oid) {
if (wd_oid) if (wd_oid)

32
src/tag.c
View File

@ -22,41 +22,41 @@ void git_tag__free(git_tag *tag)
git__free(tag); git__free(tag);
} }
const git_oid *git_tag_id(git_tag *c) const git_oid *git_tag_id(const git_tag *c)
{ {
return git_object_id((git_object *)c); return git_object_id((const git_object *)c);
} }
int git_tag_target(git_object **target, git_tag *t) int git_tag_target(git_object **target, const git_tag *t)
{ {
assert(t); assert(t);
return git_object_lookup(target, t->object.repo, &t->target, t->type); return git_object_lookup(target, t->object.repo, &t->target, t->type);
} }
const git_oid *git_tag_target_oid(git_tag *t) const git_oid *git_tag_target_id(const git_tag *t)
{ {
assert(t); assert(t);
return &t->target; return &t->target;
} }
git_otype git_tag_target_type(git_tag *t) git_otype git_tag_target_type(const git_tag *t)
{ {
assert(t); assert(t);
return t->type; return t->type;
} }
const char *git_tag_name(git_tag *t) const char *git_tag_name(const git_tag *t)
{ {
assert(t); assert(t);
return t->tag_name; return t->tag_name;
} }
const git_signature *git_tag_tagger(git_tag *t) const git_signature *git_tag_tagger(const git_tag *t)
{ {
return t->tagger; return t->tagger;
} }
const char *git_tag_message(git_tag *t) const char *git_tag_message(const git_tag *t)
{ {
assert(t); assert(t);
return t->message; return t->message;
@ -188,7 +188,7 @@ static int retrieve_tag_reference_oid(
if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0)
return -1; return -1;
return git_reference_name_to_oid(oid, repo, ref_name_out->ptr); return git_reference_name_to_id(oid, repo, ref_name_out->ptr);
} }
static int write_tag_annotation( static int write_tag_annotation(
@ -267,7 +267,7 @@ static int git_tag_create__internal(
} else } else
git_oid_cpy(oid, git_object_id(target)); git_oid_cpy(oid, git_object_id(target));
error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite); error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite);
git_reference_free(new_ref); git_reference_free(new_ref);
git_buf_free(&ref_name); git_buf_free(&ref_name);
@ -358,7 +358,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
return -1; return -1;
} }
error = git_reference_create_oid(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite); error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite);
git_reference_free(new_ref); git_reference_free(new_ref);
git_buf_free(&ref_name); git_buf_free(&ref_name);
@ -409,7 +409,7 @@ static int tags_cb(const char *ref, void *data)
if (git__prefixcmp(ref, GIT_REFS_TAGS_DIR) != 0) if (git__prefixcmp(ref, GIT_REFS_TAGS_DIR) != 0)
return 0; /* no tag */ return 0; /* no tag */
if (git_reference_name_to_oid(&oid, d->repo, ref) < 0) if (git_reference_name_to_id(&oid, d->repo, ref) < 0)
return -1; return -1;
return d->cb(ref, &oid, d->cb_data); return d->cb(ref, &oid, d->cb_data);
@ -425,8 +425,8 @@ int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
data.cb_data = cb_data; data.cb_data = cb_data;
data.repo = repo; data.repo = repo;
return git_reference_foreach(repo, GIT_REF_OID | GIT_REF_PACKED, return git_reference_foreach(
&tags_cb, &data); repo, GIT_REF_OID | GIT_REF_PACKED, &tags_cb, &data);
} }
typedef struct { typedef struct {
@ -477,7 +477,7 @@ int git_tag_list(git_strarray *tag_names, git_repository *repo)
return git_tag_list_match(tag_names, "", repo); return git_tag_list_match(tag_names, "", repo);
} }
int git_tag_peel(git_object **tag_target, git_tag *tag) int git_tag_peel(git_object **tag_target, const git_tag *tag)
{ {
return git_object_peel(tag_target, (git_object *)tag, GIT_OBJ_ANY); return git_object_peel(tag_target, (const git_object *)tag, GIT_OBJ_ANY);
} }

4
src/transports/cred.c
View File

@ -11,7 +11,7 @@
static void plaintext_free(struct git_cred *cred) static void plaintext_free(struct git_cred *cred)
{ {
git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred; git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
int pass_len = strlen(c->password); size_t pass_len = strlen(c->password);
git__free(c->username); git__free(c->username);
@ -19,6 +19,8 @@ static void plaintext_free(struct git_cred *cred)
memset(c->password, 0x0, pass_len); memset(c->password, 0x0, pass_len);
git__free(c->password); git__free(c->password);
memset(c, 0, sizeof(*c));
git__free(c); git__free(c);
} }

4
src/transports/local.c
View File

@ -48,7 +48,7 @@ static int add_ref(transport_local *t, const char *name)
head->name = git__strdup(name); head->name = git__strdup(name);
GITERR_CHECK_ALLOC(head->name); GITERR_CHECK_ALLOC(head->name);
if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0) { if (git_reference_name_to_id(&head->oid, t->repo, name) < 0) {
git__free(head->name); git__free(head->name);
git__free(head); git__free(head);
return -1; return -1;
@ -306,7 +306,7 @@ static int local_download_pack(
if (git_odb_exists(odb, &oid)) continue; if (git_odb_exists(odb, &oid)) continue;
if (!git_object_lookup((git_object**)&commit, t->repo, &oid, GIT_OBJ_COMMIT)) { if (!git_object_lookup((git_object**)&commit, t->repo, &oid, GIT_OBJ_COMMIT)) {
const git_oid *tree_oid = git_commit_tree_oid(commit); const git_oid *tree_oid = git_commit_tree_id(commit);
git_commit_free(commit); git_commit_free(commit);
/* Add the commit and its tree */ /* Add the commit and its tree */

6
src/transports/smart.c
View File

@ -24,7 +24,7 @@ static int git_smart__recv_cb(gitno_buffer *buf)
buf->offset += bytes_read; buf->offset += bytes_read;
if (t->packetsize_cb) if (t->packetsize_cb)
t->packetsize_cb(bytes_read, t->packetsize_payload); t->packetsize_cb((int)bytes_read, t->packetsize_payload);
return (int)(buf->offset - old_len); return (int)(buf->offset - old_len);
} }
@ -73,7 +73,7 @@ static int git_smart__connect(
t->flags = flags; t->flags = flags;
t->cred_acquire_cb = cred_acquire_cb; t->cred_acquire_cb = cred_acquire_cb;
if (GIT_DIR_FETCH == direction) if (GIT_DIRECTION_FETCH == direction)
{ {
if ((error = t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK_LS)) < 0) if ((error = t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK_LS)) < 0)
return error; return error;
@ -159,7 +159,7 @@ int git_smart__negotiation_step(git_transport *transport, void *data, size_t len
if (t->rpc) if (t->rpc)
git_smart__reset_stream(t); git_smart__reset_stream(t);
if (GIT_DIR_FETCH == t->direction) { if (GIT_DIRECTION_FETCH == t->direction) {
if ((error = t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) < 0) if ((error = t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) < 0)
return error; return error;

2
src/transports/smart.h
View File

@ -94,7 +94,7 @@ typedef struct transport_smart_caps {
include_tag:1; include_tag:1;
} transport_smart_caps; } transport_smart_caps;
typedef void (*packetsize_cb)(int received, void *payload); typedef void (*packetsize_cb)(size_t received, void *payload);
typedef struct { typedef struct {
git_transport parent; git_transport parent;

6
src/transports/smart_protocol.c
View File

@ -188,7 +188,7 @@ static int fetch_setup_walk(git_revwalk **out, git_repository *repo)
if (git_reference_type(ref) == GIT_REF_SYMBOLIC) if (git_reference_type(ref) == GIT_REF_SYMBOLIC)
continue; continue;
if (git_revwalk_push(walk, git_reference_oid(ref)) < 0) if (git_revwalk_push(walk, git_reference_target(ref)) < 0)
goto on_error; goto on_error;
git_reference_free(ref); git_reference_free(ref);
@ -375,7 +375,7 @@ struct network_packetsize_payload
size_t last_fired_bytes; size_t last_fired_bytes;
}; };
static void network_packetsize(int received, void *payload) static void network_packetsize(size_t received, void *payload)
{ {
struct network_packetsize_payload *npp = (struct network_packetsize_payload*)payload; struct network_packetsize_payload *npp = (struct network_packetsize_payload*)payload;
@ -414,7 +414,7 @@ int git_smart__download_pack(
/* We might have something in the buffer already from negotiate_fetch */ /* We might have something in the buffer already from negotiate_fetch */
if (t->buffer.offset > 0) if (t->buffer.offset > 0)
t->packetsize_cb(t->buffer.offset, t->packetsize_payload); t->packetsize_cb((int)t->buffer.offset, t->packetsize_payload);
} }
if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 || if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||

2
src/transports/winhttp.c
View File

@ -376,7 +376,7 @@ replay:
if (!WinHttpReadData(s->request, if (!WinHttpReadData(s->request,
(LPVOID)buffer, (LPVOID)buffer,
buf_size, (DWORD)buf_size,
&dw_bytes_read)) &dw_bytes_read))
{ {
giterr_set(GITERR_OS, "Failed to read data"); giterr_set(GITERR_OS, "Failed to read data");

73
src/tree.c
View File

@ -98,11 +98,11 @@ static int homing_search_cmp(const void *key, const void *array_member)
* ambiguous because of folder vs file sorting, we look linearly * ambiguous because of folder vs file sorting, we look linearly
* around the area for our target file. * around the area for our target file.
*/ */
static int tree_key_search(git_vector *entries, const char *filename, size_t filename_len) static int tree_key_search(
git_vector *entries, const char *filename, size_t filename_len)
{ {
struct tree_key_search ksearch; struct tree_key_search ksearch;
const git_tree_entry *entry; const git_tree_entry *entry;
int homing, i; int homing, i;
ksearch.filename = filename; ksearch.filename = filename;
@ -166,6 +166,7 @@ git_tree_entry *git_tree_entry_dup(const git_tree_entry *entry)
return NULL; return NULL;
memcpy(copy, entry, total_size); memcpy(copy, entry, total_size);
return copy; return copy;
} }
@ -225,7 +226,8 @@ int git_tree_entry_to_object(
return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY); return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY);
} }
static git_tree_entry *entry_fromname(git_tree *tree, const char *name, size_t name_len) static const git_tree_entry *entry_fromname(
git_tree *tree, const char *name, size_t name_len)
{ {
int idx = tree_key_search(&tree->entries, name, name_len); int idx = tree_key_search(&tree->entries, name, name_len);
if (idx < 0) if (idx < 0)
@ -234,22 +236,25 @@ static git_tree_entry *entry_fromname(git_tree *tree, const char *name, size_t n
return git_vector_get(&tree->entries, idx); return git_vector_get(&tree->entries, idx);
} }
const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename) const git_tree_entry *git_tree_entry_byname(
git_tree *tree, const char *filename)
{ {
assert(tree && filename); assert(tree && filename);
return entry_fromname(tree, filename, strlen(filename)); return entry_fromname(tree, filename, strlen(filename));
} }
const git_tree_entry *git_tree_entry_byindex(git_tree *tree, size_t idx) const git_tree_entry *git_tree_entry_byindex(
git_tree *tree, size_t idx)
{ {
assert(tree); assert(tree);
return git_vector_get(&tree->entries, idx); return git_vector_get(&tree->entries, idx);
} }
const git_tree_entry *git_tree_entry_byoid(git_tree *tree, const git_oid *oid) const git_tree_entry *git_tree_entry_byoid(
const git_tree *tree, const git_oid *oid)
{ {
unsigned int i; size_t i;
git_tree_entry *e; const git_tree_entry *e;
assert(tree); assert(tree);
@ -265,7 +270,7 @@ int git_tree__prefix_position(git_tree *tree, const char *path)
{ {
git_vector *entries = &tree->entries; git_vector *entries = &tree->entries;
struct tree_key_search ksearch; struct tree_key_search ksearch;
unsigned int at_pos; size_t at_pos;
ksearch.filename = path; ksearch.filename = path;
ksearch.filename_len = strlen(path); ksearch.filename_len = strlen(path);
@ -285,13 +290,13 @@ int git_tree__prefix_position(git_tree *tree, const char *path)
break; break;
} }
return at_pos; return (int)at_pos;
} }
unsigned int git_tree_entrycount(const git_tree *tree) size_t git_tree_entrycount(const git_tree *tree)
{ {
assert(tree); assert(tree);
return (unsigned int)tree->entries.length; return tree->entries.length;
} }
static int tree_error(const char *str) static int tree_error(const char *str)
@ -348,14 +353,13 @@ int git_tree__parse(git_tree *tree, git_odb_object *obj)
return tree_parse_buffer(tree, (char *)obj->raw.data, (char *)obj->raw.data + obj->raw.len); return tree_parse_buffer(tree, (char *)obj->raw.data, (char *)obj->raw.data + obj->raw.len);
} }
static unsigned int find_next_dir(const char *dirname, git_index *index, unsigned int start) static size_t find_next_dir(const char *dirname, git_index *index, size_t start)
{ {
unsigned int i, entries = git_index_entrycount(index); size_t dirlen, i, entries = git_index_entrycount(index);
size_t dirlen;
dirlen = strlen(dirname); dirlen = strlen(dirname);
for (i = start; i < entries; ++i) { for (i = start; i < entries; ++i) {
git_index_entry *entry = git_index_get_byindex(index, i); const git_index_entry *entry = git_index_get_byindex(index, i);
if (strlen(entry->path) < dirlen || if (strlen(entry->path) < dirlen ||
memcmp(entry->path, dirname, dirlen) || memcmp(entry->path, dirname, dirlen) ||
(dirlen > 0 && entry->path[dirlen] != '/')) { (dirlen > 0 && entry->path[dirlen] != '/')) {
@ -394,11 +398,10 @@ static int write_tree(
git_repository *repo, git_repository *repo,
git_index *index, git_index *index,
const char *dirname, const char *dirname,
unsigned int start) size_t start)
{ {
git_treebuilder *bld = NULL; git_treebuilder *bld = NULL;
size_t i, entries = git_index_entrycount(index);
unsigned int i, entries = git_index_entrycount(index);
int error; int error;
size_t dirname_len = strlen(dirname); size_t dirname_len = strlen(dirname);
const git_tree_cache *cache; const git_tree_cache *cache;
@ -406,13 +409,11 @@ static int write_tree(
cache = git_tree_cache_get(index->tree, dirname); cache = git_tree_cache_get(index->tree, dirname);
if (cache != NULL && cache->entries >= 0){ if (cache != NULL && cache->entries >= 0){
git_oid_cpy(oid, &cache->oid); git_oid_cpy(oid, &cache->oid);
return find_next_dir(dirname, index, start); return (int)find_next_dir(dirname, index, start);
} }
error = git_treebuilder_create(&bld, NULL); if ((error = git_treebuilder_create(&bld, NULL)) < 0 || bld == NULL)
if (bld == NULL) {
return -1; return -1;
}
/* /*
* This loop is unfortunate, but necessary. The index doesn't have * This loop is unfortunate, but necessary. The index doesn't have
@ -420,8 +421,8 @@ static int write_tree(
* need to keep track of the current position. * need to keep track of the current position.
*/ */
for (i = start; i < entries; ++i) { for (i = start; i < entries; ++i) {
git_index_entry *entry = git_index_get_byindex(index, i); const git_index_entry *entry = git_index_get_byindex(index, i);
char *filename, *next_slash; const char *filename, *next_slash;
/* /*
* If we've left our (sub)tree, exit the loop and return. The * If we've left our (sub)tree, exit the loop and return. The
@ -489,14 +490,15 @@ static int write_tree(
goto on_error; goto on_error;
git_treebuilder_free(bld); git_treebuilder_free(bld);
return i; return (int)i;
on_error: on_error:
git_treebuilder_free(bld); git_treebuilder_free(bld);
return -1; return -1;
} }
int git_tree__write_index(git_oid *oid, git_index *index, git_repository *repo) int git_tree__write_index(
git_oid *oid, git_index *index, git_repository *repo)
{ {
int ret; int ret;
@ -694,7 +696,10 @@ on_error:
return -1; return -1;
} }
void git_treebuilder_filter(git_treebuilder *bld, int (*filter)(const git_tree_entry *, void *), void *payload) void git_treebuilder_filter(
git_treebuilder *bld,
git_treebuilder_filter_cb filter,
void *payload)
{ {
unsigned int i; unsigned int i;
@ -803,17 +808,17 @@ int git_tree_entry_bypath(
} }
static int tree_walk( static int tree_walk(
git_tree *tree, const git_tree *tree,
git_treewalk_cb callback, git_treewalk_cb callback,
git_buf *path, git_buf *path,
void *payload, void *payload,
bool preorder) bool preorder)
{ {
int error = 0; int error = 0;
unsigned int i; size_t i;
for (i = 0; i < tree->entries.length; ++i) { for (i = 0; i < tree->entries.length; ++i) {
git_tree_entry *entry = tree->entries.contents[i]; const git_tree_entry *entry = tree->entries.contents[i];
if (preorder) { if (preorder) {
error = callback(path->ptr, entry, payload); error = callback(path->ptr, entry, payload);
@ -855,7 +860,11 @@ static int tree_walk(
return error; return error;
} }
int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload) int git_tree_walk(
const git_tree *tree,
git_treewalk_mode mode,
git_treewalk_cb callback,
void *payload)
{ {
int error = 0; int error = 0;
git_buf root_path = GIT_BUF_INIT; git_buf root_path = GIT_BUF_INIT;

3
src/tree.h
View File

@ -51,7 +51,8 @@ int git_tree__prefix_position(git_tree *tree, const char *prefix);
/** /**
* Write a tree to the given repository * Write a tree to the given repository
*/ */
int git_tree__write_index(git_oid *oid, git_index *index, git_repository *repo); int git_tree__write_index(
git_oid *oid, git_index *index, git_repository *repo);
/** /**
* Obsolete mode kept for compatibility reasons * Obsolete mode kept for compatibility reasons

37
src/vector.c
View File

@ -9,14 +9,14 @@
#include "repository.h" #include "repository.h"
#include "vector.h" #include "vector.h"
static const double resize_factor = 1.75; static const double git_vector_resize_factor = 1.75;
static const unsigned int minimum_size = 8; static const size_t git_vector_minimum_size = 8;
static int resize_vector(git_vector *v) static int resize_vector(git_vector *v)
{ {
v->_alloc_size = ((unsigned int)(v->_alloc_size * resize_factor)) + 1; v->_alloc_size = (size_t)(v->_alloc_size * git_vector_resize_factor) + 1;
if (v->_alloc_size < minimum_size) if (v->_alloc_size < git_vector_minimum_size)
v->_alloc_size = minimum_size; v->_alloc_size = git_vector_minimum_size;
v->contents = git__realloc(v->contents, v->_alloc_size * sizeof(void *)); v->contents = git__realloc(v->contents, v->_alloc_size * sizeof(void *));
GITERR_CHECK_ALLOC(v->contents); GITERR_CHECK_ALLOC(v->contents);
@ -24,7 +24,7 @@ static int resize_vector(git_vector *v)
return 0; return 0;
} }
int git_vector_dup(git_vector *v, git_vector *src, git_vector_cmp cmp) int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp)
{ {
assert(v && src); assert(v && src);
@ -58,7 +58,7 @@ int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)
memset(v, 0x0, sizeof(git_vector)); memset(v, 0x0, sizeof(git_vector));
if (initial_size == 0) if (initial_size == 0)
initial_size = minimum_size; initial_size = git_vector_minimum_size;
v->_alloc_size = initial_size; v->_alloc_size = initial_size;
v->_cmp = cmp; v->_cmp = cmp;
@ -133,7 +133,7 @@ void git_vector_sort(git_vector *v)
} }
int git_vector_bsearch3( int git_vector_bsearch3(
unsigned int *at_pos, size_t *at_pos,
git_vector *v, git_vector *v,
git_vector_cmp key_lookup, git_vector_cmp key_lookup,
const void *key) const void *key)
@ -151,21 +151,21 @@ int git_vector_bsearch3(
rval = git__bsearch(v->contents, v->length, key, key_lookup, &pos); rval = git__bsearch(v->contents, v->length, key, key_lookup, &pos);
if (at_pos != NULL) if (at_pos != NULL)
*at_pos = (unsigned int)pos; *at_pos = pos;
return (rval >= 0) ? (int)pos : GIT_ENOTFOUND; return (rval >= 0) ? (int)pos : GIT_ENOTFOUND;
} }
int git_vector_search2( int git_vector_search2(
git_vector *v, git_vector_cmp key_lookup, const void *key) const git_vector *v, git_vector_cmp key_lookup, const void *key)
{ {
unsigned int i; size_t i;
assert(v && key && key_lookup); assert(v && key && key_lookup);
for (i = 0; i < v->length; ++i) { for (i = 0; i < v->length; ++i) {
if (key_lookup(key, v->contents[i]) == 0) if (key_lookup(key, v->contents[i]) == 0)
return i; return (int)i;
} }
return GIT_ENOTFOUND; return GIT_ENOTFOUND;
@ -176,14 +176,14 @@ static int strict_comparison(const void *a, const void *b)
return (a == b) ? 0 : -1; return (a == b) ? 0 : -1;
} }
int git_vector_search(git_vector *v, const void *entry) int git_vector_search(const git_vector *v, const void *entry)
{ {
return git_vector_search2(v, v->_cmp ? v->_cmp : strict_comparison, entry); return git_vector_search2(v, v->_cmp ? v->_cmp : strict_comparison, entry);
} }
int git_vector_remove(git_vector *v, unsigned int idx) int git_vector_remove(git_vector *v, size_t idx)
{ {
unsigned int i; size_t i;
assert(v); assert(v);
@ -206,7 +206,7 @@ void git_vector_pop(git_vector *v)
void git_vector_uniq(git_vector *v) void git_vector_uniq(git_vector *v)
{ {
git_vector_cmp cmp; git_vector_cmp cmp;
unsigned int i, j; size_t i, j;
if (v->length <= 1) if (v->length <= 1)
return; return;
@ -223,9 +223,10 @@ void git_vector_uniq(git_vector *v)
v->length -= j - i - 1; v->length -= j - i - 1;
} }
void git_vector_remove_matching(git_vector *v, int (*match)(git_vector *v, size_t idx)) void git_vector_remove_matching(
git_vector *v, int (*match)(const git_vector *v, size_t idx))
{ {
unsigned int i, j; size_t i, j;
for (i = 0, j = 0; j < v->length; ++j) { for (i = 0, j = 0; j < v->length; ++j) {
v->contents[i] = v->contents[j]; v->contents[i] = v->contents[j];

22
src/vector.h
View File

@ -24,23 +24,23 @@ typedef struct git_vector {
int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp); int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp);
void git_vector_free(git_vector *v); void git_vector_free(git_vector *v);
void git_vector_clear(git_vector *v); void git_vector_clear(git_vector *v);
int git_vector_dup(git_vector *v, git_vector *src, git_vector_cmp cmp); int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp);
void git_vector_swap(git_vector *a, git_vector *b); void git_vector_swap(git_vector *a, git_vector *b);
void git_vector_sort(git_vector *v); void git_vector_sort(git_vector *v);
/** Linear search for matching entry using internal comparison function */ /** Linear search for matching entry using internal comparison function */
int git_vector_search(git_vector *v, const void *entry); int git_vector_search(const git_vector *v, const void *entry);
/** Linear search for matching entry using explicit comparison function */ /** Linear search for matching entry using explicit comparison function */
int git_vector_search2(git_vector *v, git_vector_cmp cmp, const void *key); int git_vector_search2(const git_vector *v, git_vector_cmp cmp, const void *key);
/** /**
* Binary search for matching entry using explicit comparison function that * Binary search for matching entry using explicit comparison function that
* returns position where item would go if not found. * returns position where item would go if not found.
*/ */
int git_vector_bsearch3( int git_vector_bsearch3(
unsigned int *at_pos, git_vector *v, git_vector_cmp cmp, const void *key); size_t *at_pos, git_vector *v, git_vector_cmp cmp, const void *key);
/** Binary search for matching entry using internal comparison function */ /** Binary search for matching entry using internal comparison function */
GIT_INLINE(int) git_vector_bsearch(git_vector *v, const void *key) GIT_INLINE(int) git_vector_bsearch(git_vector *v, const void *key)
@ -55,19 +55,14 @@ GIT_INLINE(int) git_vector_bsearch2(
return git_vector_bsearch3(NULL, v, cmp, key); return git_vector_bsearch3(NULL, v, cmp, key);
} }
GIT_INLINE(void *) git_vector_get(git_vector *v, size_t position) GIT_INLINE(void *) git_vector_get(const git_vector *v, size_t position)
{
return (position < v->length) ? v->contents[position] : NULL;
}
GIT_INLINE(const void *) git_vector_get_const(const git_vector *v, size_t position)
{ {
return (position < v->length) ? v->contents[position] : NULL; return (position < v->length) ? v->contents[position] : NULL;
} }
#define GIT_VECTOR_GET(V,I) ((I) < (V)->length ? (V)->contents[(I)] : NULL) #define GIT_VECTOR_GET(V,I) ((I) < (V)->length ? (V)->contents[(I)] : NULL)
GIT_INLINE(void *) git_vector_last(git_vector *v) GIT_INLINE(void *) git_vector_last(const git_vector *v)
{ {
return (v->length > 0) ? git_vector_get(v, v->length - 1) : NULL; return (v->length > 0) ? git_vector_get(v, v->length - 1) : NULL;
} }
@ -81,10 +76,11 @@ GIT_INLINE(void *) git_vector_last(git_vector *v)
int git_vector_insert(git_vector *v, void *element); int git_vector_insert(git_vector *v, void *element);
int git_vector_insert_sorted(git_vector *v, void *element, int git_vector_insert_sorted(git_vector *v, void *element,
int (*on_dup)(void **old, void *new)); int (*on_dup)(void **old, void *new));
int git_vector_remove(git_vector *v, unsigned int idx); int git_vector_remove(git_vector *v, size_t idx);
void git_vector_pop(git_vector *v); void git_vector_pop(git_vector *v);
void git_vector_uniq(git_vector *v); void git_vector_uniq(git_vector *v);
void git_vector_remove_matching(git_vector *v, int (*match)(git_vector *v, size_t idx)); void git_vector_remove_matching(
git_vector *v, int (*match)(const git_vector *v, size_t idx));
int git_vector_resize_to(git_vector *v, size_t new_length); int git_vector_resize_to(git_vector *v, size_t new_length);
int git_vector_set(void **old, git_vector *v, size_t position, void *value); int git_vector_set(void **old, git_vector *v, size_t position, void *value);

8
src/win32/posix_w32.c
View File

@ -520,24 +520,24 @@ int p_inet_pton(int af, const char* src, void* dst)
struct sockaddr_in6 sin6; struct sockaddr_in6 sin6;
struct sockaddr_in sin; struct sockaddr_in sin;
} sa; } sa;
size_t srcsize; int srcsize;
switch(af) switch(af)
{ {
case AF_INET: case AF_INET:
sa.sin.sin_family = AF_INET; sa.sin.sin_family = AF_INET;
srcsize = sizeof (sa.sin); srcsize = (int)sizeof(sa.sin);
break; break;
case AF_INET6: case AF_INET6:
sa.sin6.sin6_family = AF_INET6; sa.sin6.sin6_family = AF_INET6;
srcsize = sizeof (sa.sin6); srcsize = (int)sizeof(sa.sin6);
break; break;
default: default:
errno = WSAEPFNOSUPPORT; errno = WSAEPFNOSUPPORT;
return -1; return -1;
} }
if (WSAStringToAddress(src, af, NULL, (struct sockaddr *) &sa, &srcsize) != 0) if (WSAStringToAddress((LPSTR)src, af, NULL, (struct sockaddr *) &sa, &srcsize) != 0)
{ {
errno = WSAGetLastError(); errno = WSAGetLastError();
return -1; return -1;

2
tests-clar/attr/repo.c
View File

@ -267,7 +267,7 @@ static void add_to_workdir(const char *filename, const char *content)
static void assert_proper_normalization(git_index *index, const char *filename, const char *expected_sha) static void assert_proper_normalization(git_index *index, const char *filename, const char *expected_sha)
{ {
int index_pos; int index_pos;
git_index_entry *entry; const git_index_entry *entry;
add_to_workdir(filename, CONTENT); add_to_workdir(filename, CONTENT);
cl_git_pass(git_index_add_from_workdir(index, filename)); cl_git_pass(git_index_add_from_workdir(index, filename));

2
tests-clar/checkout/index.c
View File

@ -247,7 +247,7 @@ void test_checkout_index__options_dir_modes(void)
git_oid oid; git_oid oid;
git_commit *commit; git_commit *commit;
cl_git_pass(git_reference_name_to_oid(&oid, g_repo, "refs/heads/dir")); cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/dir"));
cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
reset_index_to_treeish((git_object *)commit); reset_index_to_treeish((git_object *)commit);

10
tests-clar/clone/network.c
View File

@ -74,7 +74,7 @@ void test_clone_network__empty_repository(void)
cl_git_pass(git_reference_lookup(&head, g_repo, GIT_HEAD_FILE)); cl_git_pass(git_reference_lookup(&head, g_repo, GIT_HEAD_FILE));
cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head)); cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
cl_assert_equal_s("refs/heads/master", git_reference_target(head)); cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
git_reference_free(head); git_reference_free(head);
} }
@ -109,7 +109,7 @@ static void fetch_progress(const git_transfer_progress *stats, void *payload)
void test_clone_network__can_checkout_a_cloned_repo(void) void test_clone_network__can_checkout_a_cloned_repo(void)
{ {
git_checkout_opts opts = {0}; git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
git_buf path = GIT_BUF_INIT; git_buf path = GIT_BUF_INIT;
git_reference *head; git_reference *head;
bool checkout_progress_cb_was_called = false, bool checkout_progress_cb_was_called = false,
@ -121,15 +121,15 @@ void test_clone_network__can_checkout_a_cloned_repo(void)
cl_set_cleanup(&cleanup_repository, "./default-checkout"); cl_set_cleanup(&cleanup_repository, "./default-checkout");
cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./default-checkout", cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./default-checkout", &opts,
&fetch_progress, &fetch_progress_cb_was_called, &opts)); &fetch_progress, &fetch_progress_cb_was_called));
cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "master.txt")); cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "master.txt"));
cl_assert_equal_i(true, git_path_isfile(git_buf_cstr(&path))); cl_assert_equal_i(true, git_path_isfile(git_buf_cstr(&path)));
cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD")); cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head)); cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
cl_assert_equal_s("refs/heads/master", git_reference_target(head)); cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
cl_assert_equal_i(true, checkout_progress_cb_was_called); cl_assert_equal_i(true, checkout_progress_cb_was_called);
cl_assert_equal_i(true, fetch_progress_cb_was_called); cl_assert_equal_i(true, fetch_progress_cb_was_called);

Some files were not shown because too many files have changed in this diff Show More