diff options
| author | Edward Thomson <ethomson@edwardthomson.com> | 2021-09-07 17:53:49 -0400 |
|---|---|---|
| committer | Edward Thomson <ethomson@edwardthomson.com> | 2021-10-17 09:49:01 -0400 |
| commit | f0e693b18afbe1de37d7da5b5a8967b6c87d8e53 (patch) | |
| tree | be5e1cdbfa218ba81ec06bf45e45cfeb7f79a2a5 /src | |
| parent | 5346be3ddd3bcf19779c5d62e71f8442a0171133 (diff) | |
| download | libgit2-f0e693b18afbe1de37d7da5b5a8967b6c87d8e53.tar.gz | |
str: introduce `git_str` for internal, `git_buf` is externalethomson/gitstr
libgit2 has two distinct requirements that were previously solved by
`git_buf`. We require:
1. A general purpose string class that provides a number of utility APIs
for manipulating data (eg, concatenating, truncating, etc).
2. A structure that we can use to return strings to callers that they
can take ownership of.
By using a single class (`git_buf`) for both of these purposes, we have
confused the API to the point that refactorings are difficult and
reasoning about correctness is also difficult.
Move the utility class `git_buf` to be called `git_str`: this represents
its general purpose, as an internal string buffer class. The name also
is an homage to Junio Hamano ("gitstr").
The public API remains `git_buf`, and has a much smaller footprint. It
is generally only used as an "out" param with strict requirements that
follow the documentation. (Exceptions exist for some legacy APIs to
avoid breaking callers unnecessarily.)
Utility functions exist to convert a user-specified `git_buf` to a
`git_str` so that we can call internal functions, then converting it
back again.
Diffstat (limited to 'src')
148 files changed, 4231 insertions, 3723 deletions
diff --git a/src/apply.c b/src/apply.c index 7c65cd79d..18304da4d 100644 --- a/src/apply.c +++ b/src/apply.c @@ -265,7 +265,7 @@ done: } static int apply_hunks( - git_buf *out, + git_str *out, const char *source, size_t source_len, git_patch *patch, @@ -286,7 +286,7 @@ static int apply_hunks( } git_vector_foreach(&image.lines, i, line) - git_buf_put(out, line->content, line->content_len); + git_str_put(out, line->content, line->content_len); done: patch_image_free(&image); @@ -295,24 +295,24 @@ done: } static int apply_binary_delta( - git_buf *out, + git_str *out, const char *source, size_t source_len, git_diff_binary_file *binary_file) { - git_buf inflated = GIT_BUF_INIT; + git_str inflated = GIT_STR_INIT; int error = 0; /* no diff means identical contents */ if (binary_file->datalen == 0) - return git_buf_put(out, source, source_len); + return git_str_put(out, source, source_len); error = git_zstream_inflatebuf(&inflated, binary_file->data, binary_file->datalen); if (!error && inflated.size != binary_file->inflatedlen) { error = apply_err("inflated delta does not match expected length"); - git_buf_dispose(out); + git_str_dispose(out); } if (error < 0) @@ -330,7 +330,7 @@ static int apply_binary_delta( out->asize = data_len; } else if (binary_file->type == GIT_DIFF_BINARY_LITERAL) { - git_buf_swap(out, &inflated); + git_str_swap(out, &inflated); } else { error = apply_err("unknown binary delta type"); @@ -338,17 +338,17 @@ static int apply_binary_delta( } done: - git_buf_dispose(&inflated); + git_str_dispose(&inflated); return error; } static int apply_binary( - git_buf *out, + git_str *out, const char *source, size_t source_len, git_patch *patch) { - git_buf reverse = GIT_BUF_INIT; + git_str reverse = GIT_STR_INIT; int error = 0; if (!patch->binary.contains_data) { @@ -378,14 +378,14 @@ static int apply_binary( done: if (error < 0) - git_buf_dispose(out); + git_str_dispose(out); - git_buf_dispose(&reverse); + git_str_dispose(&reverse); return error; } int git_apply__patch( - git_buf *contents_out, + git_str *contents_out, char **filename_out, unsigned int *mode_out, const char *source, @@ -423,13 +423,13 @@ int git_apply__patch( else if (patch->hunks.size) error = apply_hunks(contents_out, source, source_len, patch, &ctx); else - error = git_buf_put(contents_out, source, source_len); + error = git_str_put(contents_out, source, source_len); if (error) goto done; if (patch->delta->status == GIT_DELTA_DELETED && - git_buf_len(contents_out) > 0) { + git_str_len(contents_out) > 0) { error = apply_err("removal patch leaves file contents"); goto done; } @@ -456,7 +456,7 @@ static int apply_one( const git_apply_options *opts) { git_patch *patch = NULL; - git_buf pre_contents = GIT_BUF_INIT, post_contents = GIT_BUF_INIT; + git_str pre_contents = GIT_STR_INIT, post_contents = GIT_STR_INIT; const git_diff_delta *delta; char *filename = NULL; unsigned int mode; @@ -579,8 +579,8 @@ static int apply_one( git_strmap_delete(removed_paths, delta->new_file.path); done: - git_buf_dispose(&pre_contents); - git_buf_dispose(&post_contents); + git_str_dispose(&pre_contents); + git_str_dispose(&post_contents); git__free(filename); git_patch_free(patch); diff --git a/src/apply.h b/src/apply.h index 11ec75637..e990a7107 100644 --- a/src/apply.h +++ b/src/apply.h @@ -11,10 +11,10 @@ #include "git2/patch.h" #include "git2/apply.h" -#include "buffer.h" +#include "str.h" extern int git_apply__patch( - git_buf *out, + git_str *out, char **filename, unsigned int *mode, const char *source, diff --git a/src/attr.c b/src/attr.c index 95b49e3de..5849e701f 100644 --- a/src/attr.c +++ b/src/attr.c @@ -338,7 +338,7 @@ GIT_INLINE(int) preload_attr_file( } static int system_attr_file( - git_buf *out, + git_str *out, git_attr_session *attr_session) { int error; @@ -366,11 +366,11 @@ static int system_attr_file( if (attr_session->sysdir.size == 0) return GIT_ENOTFOUND; - /* We can safely provide a git_buf with no allocation (asize == 0) to - * a consumer. This allows them to treat this as a regular `git_buf`, - * but their call to `git_buf_dispose` will not attempt to free it. + /* We can safely provide a git_str with no allocation (asize == 0) to + * a consumer. This allows them to treat this as a regular `git_str`, + * but their call to `git_str_dispose` will not attempt to free it. */ - git_buf_attach_notowned( + git_str_attach_notowned( out, attr_session->sysdir.ptr, attr_session->sysdir.size); return 0; } @@ -380,7 +380,7 @@ static int attr_setup( git_attr_session *attr_session, git_attr_options *opts) { - git_buf system = GIT_BUF_INIT, info = GIT_BUF_INIT; + git_str system = GIT_STR_INIT, info = GIT_STR_INIT; git_attr_file_source index_source = { GIT_ATTR_FILE_SOURCE_INDEX, NULL, GIT_ATTR_FILE, NULL }; git_attr_file_source head_source = { GIT_ATTR_FILE_SOURCE_HEAD, NULL, GIT_ATTR_FILE, NULL }; git_attr_file_source commit_source = { GIT_ATTR_FILE_SOURCE_COMMIT, NULL, GIT_ATTR_FILE, NULL }; @@ -411,7 +411,7 @@ static int attr_setup( git_repository_attr_cache(repo)->cfg_attr_file)) < 0) goto out; - if ((error = git_repository_item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + if ((error = git_repository__item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = preload_attr_file(repo, attr_session, info.ptr, GIT_ATTR_FILE_INREPO)) < 0) { if (error != GIT_ENOTFOUND) goto out; @@ -447,8 +447,8 @@ static int attr_setup( attr_session->init_setup = 1; out: - git_buf_dispose(&system); - git_buf_dispose(&info); + git_str_dispose(&system); + git_str_dispose(&info); return error; } @@ -625,7 +625,7 @@ static int collect_attr_files( git_vector *files) { int error = 0; - git_buf dir = GIT_BUF_INIT, attrfile = GIT_BUF_INIT; + git_str dir = GIT_STR_INIT, attrfile = GIT_STR_INIT; const char *workdir = git_repository_workdir(repo); attr_walk_up_info info = { NULL }; @@ -653,7 +653,7 @@ static int collect_attr_files( * - $GIT_PREFIX/etc/gitattributes */ - if ((error = git_repository_item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + if ((error = git_repository__item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = push_attr_file(repo, attr_session, files, attrfile.ptr, GIT_ATTR_FILE_INREPO)) < 0) { if (error != GIT_ENOTFOUND) goto cleanup; @@ -693,8 +693,8 @@ static int collect_attr_files( cleanup: if (error < 0) release_attr_files(files); - git_buf_dispose(&attrfile); - git_buf_dispose(&dir); + git_str_dispose(&attrfile); + git_str_dispose(&dir); return error; } diff --git a/src/attr_file.c b/src/attr_file.c index 71bd20a0f..09f0ce1b8 100644 --- a/src/attr_file.c +++ b/src/attr_file.c @@ -117,13 +117,13 @@ int git_attr_file__load( git_tree *tree = NULL; git_tree_entry *tree_entry = NULL; git_blob *blob = NULL; - git_buf content = GIT_BUF_INIT; + git_str content = GIT_STR_INIT; const char *content_str; git_attr_file *file; struct stat st; bool nonexistent = false; int bom_offset; - git_buf_bom_t bom; + git_str_bom_t bom; git_oid id; git_object_size_t blobsize; @@ -143,7 +143,7 @@ int git_attr_file__load( blobsize = git_blob_rawsize(blob); GIT_ERROR_CHECK_BLOBSIZE(blobsize); - git_buf_put(&content, git_blob_rawcontent(blob), (size_t)blobsize); + git_str_put(&content, git_blob_rawcontent(blob), (size_t)blobsize); break; } case GIT_ATTR_FILE_SOURCE_FILE: { @@ -198,7 +198,7 @@ int git_attr_file__load( blobsize = git_blob_rawsize(blob); GIT_ERROR_CHECK_BLOBSIZE(blobsize); - if ((error = git_buf_put(&content, + if ((error = git_str_put(&content, git_blob_rawcontent(blob), (size_t)blobsize)) < 0) goto cleanup; @@ -213,10 +213,10 @@ int git_attr_file__load( goto cleanup; /* advance over a UTF8 BOM */ - content_str = git_buf_cstr(&content); - bom_offset = git_buf_detect_bom(&bom, &content); + content_str = git_str_cstr(&content); + bom_offset = git_str_detect_bom(&bom, &content); - if (bom == GIT_BUF_BOM_UTF8) + if (bom == GIT_STR_BOM_UTF8) content_str += bom_offset; /* store the key of the attr_reader; don't bother with cache @@ -250,7 +250,7 @@ cleanup: git_tree_entry_free(tree_entry); git_tree_free(tree); git_commit_free(commit); - git_buf_dispose(&content); + git_str_dispose(&content); return error; } @@ -435,7 +435,7 @@ int git_attr_file__lookup_one( int git_attr_file__load_standalone(git_attr_file **out, const char *path) { - git_buf content = GIT_BUF_INIT; + git_str content = GIT_STR_INIT; git_attr_file_source source = { GIT_ATTR_FILE_SOURCE_FILE }; git_attr_file *file = NULL; int error; @@ -457,7 +457,7 @@ int git_attr_file__load_standalone(git_attr_file **out, const char *path) out: if (error < 0) git_attr_file__free(file); - git_buf_dispose(&content); + git_str_dispose(&content); return error; } @@ -558,7 +558,7 @@ int git_attr_path__init( ssize_t root; /* build full path as best we can */ - git_buf_init(&info->full, 0); + git_str_init(&info->full, 0); if (git_path_join_unrooted(&info->full, path, base, &root) < 0) return -1; @@ -605,7 +605,7 @@ int git_attr_path__init( void git_attr_path__free(git_attr_path *info) { - git_buf_dispose(&info->full); + git_str_dispose(&info->full); info->path = NULL; info->basename = NULL; } @@ -1020,8 +1020,8 @@ void git_attr_session__free(git_attr_session *session) if (!session) return; - git_buf_dispose(&session->sysdir); - git_buf_dispose(&session->tmp); + git_str_dispose(&session->sysdir); + git_str_dispose(&session->tmp); memset(session, 0, sizeof(git_attr_session)); } diff --git a/src/attr_file.h b/src/attr_file.h index d634e6da9..08630d1a6 100644 --- a/src/attr_file.h +++ b/src/attr_file.h @@ -13,7 +13,7 @@ #include "git2/attr.h" #include "vector.h" #include "pool.h" -#include "buffer.h" +#include "str.h" #include "futils.h" #define GIT_ATTR_FILE ".gitattributes" @@ -118,7 +118,7 @@ struct git_attr_file_entry { }; typedef struct { - git_buf full; + git_str full; char *path; char *basename; int is_dir; @@ -132,8 +132,8 @@ typedef struct { int key; unsigned int init_setup:1, init_sysdir:1; - git_buf sysdir; - git_buf tmp; + git_str sysdir; + git_str tmp; } git_attr_session; extern int git_attr_session__init(git_attr_session *attr_session, git_repository *repo); diff --git a/src/attrcache.c b/src/attrcache.c index 2b36b7a9c..98d73cbc3 100644 --- a/src/attrcache.c +++ b/src/attrcache.c @@ -161,7 +161,7 @@ static int attr_cache_lookup( git_attr_file_source *source) { int error = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; const char *wd = git_repository_workdir(repo); const char *filename; git_attr_cache *cache = git_repository_attr_cache(repo); @@ -170,9 +170,9 @@ static int attr_cache_lookup( /* join base and path as needed */ if (source->base != NULL && git_path_root(source->filename) < 0) { - git_buf *p = attr_session ? &attr_session->tmp : &path; + git_str *p = attr_session ? &attr_session->tmp : &path; - if (git_buf_joinpath(p, source->base, source->filename) < 0 || + if (git_str_joinpath(p, source->base, source->filename) < 0 || git_path_validate_workdir_buf(repo, p) < 0) return -1; @@ -203,7 +203,7 @@ cleanup: *out_file = file; *out_entry = entry; - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -281,7 +281,7 @@ bool git_attr_cache__is_cached( static int attr_cache__lookup_path( char **out, git_config *cfg, const char *key, const char *fallback) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; git_config_entry *entry = NULL; @@ -296,17 +296,17 @@ static int attr_cache__lookup_path( /* expand leading ~/ as needed */ if (cfgval && cfgval[0] == '~' && cfgval[1] == '/') { if (! (error = git_sysdir_expand_global_file(&buf, &cfgval[2]))) - *out = git_buf_detach(&buf); + *out = git_str_detach(&buf); } else if (cfgval) { *out = git__strdup(cfgval); } } else if (!git_sysdir_find_xdg_file(&buf, fallback)) { - *out = git_buf_detach(&buf); + *out = git_str_detach(&buf); } git_config_entry_free(entry); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } diff --git a/src/blob.c b/src/blob.c index 09b5b5d91..6f57d09e4 100644 --- a/src/blob.c +++ b/src/blob.c @@ -12,6 +12,7 @@ #include "git2/repository.h" #include "git2/odb_backend.h" +#include "buf.h" #include "filebuf.h" #include "filter.h" @@ -35,12 +36,12 @@ git_object_size_t git_blob_rawsize(const git_blob *blob) return (git_object_size_t)git_odb_object_size(blob->data.odb); } -int git_blob__getbuf(git_buf *buffer, git_blob *blob) +int git_blob__getbuf(git_str *buffer, git_blob *blob) { git_object_size_t size = git_blob_rawsize(blob); GIT_ERROR_CHECK_BLOBSIZE(size); - return git_buf_set(buffer, git_blob_rawcontent(blob), (size_t)size); + return git_str_set(buffer, git_blob_rawcontent(blob), (size_t)size); } void git_blob__free(void *_blob) @@ -142,9 +143,9 @@ static int write_file_filtered( git_repository* repo) { int error; - git_buf tgt = GIT_BUF_INIT; + git_str tgt = GIT_STR_INIT; - error = git_filter_list_apply_to_file(&tgt, fl, repo, full_path); + error = git_filter_list__apply_to_file(&tgt, fl, repo, full_path); /* Write the file to disk if it was properly filtered */ if (!error) { @@ -153,7 +154,7 @@ static int write_file_filtered( error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJECT_BLOB); } - git_buf_dispose(&tgt); + git_str_dispose(&tgt); return error; } @@ -193,7 +194,7 @@ int git_blob__create_from_paths( git_odb *odb = NULL; git_object_size_t size; mode_t mode; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; GIT_ASSERT_ARG(hint_path || !try_load_filters); @@ -261,7 +262,7 @@ int git_blob__create_from_paths( done: git_odb_free(odb); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -276,11 +277,11 @@ int git_blob_create_from_disk( git_oid *id, git_repository *repo, const char *path) { int error; - git_buf full_path = GIT_BUF_INIT; + git_str full_path = GIT_STR_INIT; const char *workdir, *hintpath = NULL; if ((error = git_path_prettify(&full_path, path, NULL)) < 0) { - git_buf_dispose(&full_path); + git_str_dispose(&full_path); return error; } @@ -290,9 +291,9 @@ int git_blob_create_from_disk( hintpath = full_path.ptr + strlen(workdir); error = git_blob__create_from_paths( - id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, !!hintpath); + id, NULL, repo, git_str_cstr(&full_path), hintpath, 0, !!hintpath); - git_buf_dispose(&full_path); + git_str_dispose(&full_path); return error; } @@ -330,7 +331,7 @@ static int blob_writestream_write(git_writestream *_stream, const char *buffer, int git_blob_create_from_stream(git_writestream **out, git_repository *repo, const char *hintpath) { int error; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; blob_writestream *stream; GIT_ASSERT_ARG(out); @@ -349,11 +350,11 @@ int git_blob_create_from_stream(git_writestream **out, git_repository *repo, con stream->parent.close = blob_writestream_close; stream->parent.free = blob_writestream_free; - if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 - || (error = git_buf_joinpath(&path, path.ptr, "streamed")) < 0) + if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 + || (error = git_str_joinpath(&path, path.ptr, "streamed")) < 0) goto cleanup; - if ((error = git_filebuf_open_withsize(&stream->fbuf, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY, + if ((error = git_filebuf_open_withsize(&stream->fbuf, git_str_cstr(&path), GIT_FILEBUF_TEMPORARY, 0666, 2 * 1024 * 1024)) < 0) goto cleanup; @@ -363,7 +364,7 @@ cleanup: if (error < 0) blob_writestream_free((git_writestream *) stream); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -391,16 +392,16 @@ cleanup: int git_blob_is_binary(const git_blob *blob) { - git_buf content = GIT_BUF_INIT; + git_str content = GIT_STR_INIT; git_object_size_t size; GIT_ASSERT_ARG(blob); size = git_blob_rawsize(blob); - git_buf_attach_notowned(&content, git_blob_rawcontent(blob), + git_str_attach_notowned(&content, git_blob_rawcontent(blob), (size_t)min(size, GIT_FILTER_BYTES_TO_CHECK_NUL)); - return git_buf_is_binary(&content); + return git_str_is_binary(&content); } int git_blob_filter_options_init( @@ -418,10 +419,10 @@ int git_blob_filter( const char *path, git_blob_filter_options *given_opts) { - int error = 0; - git_filter_list *fl = NULL; git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT; git_filter_options filter_opts = GIT_FILTER_OPTIONS_INIT; + git_filter_list *fl = NULL; + int error = 0; GIT_ASSERT_ARG(blob); GIT_ASSERT_ARG(path); @@ -430,9 +431,6 @@ int git_blob_filter( GIT_ERROR_CHECK_VERSION( given_opts, GIT_BLOB_FILTER_OPTIONS_VERSION, "git_blob_filter_options"); - if (git_buf_sanitize(out) < 0) - return -1; - if (given_opts != NULL) memcpy(&opts, given_opts, sizeof(git_blob_filter_options)); diff --git a/src/blob.h b/src/blob.h index e5770991e..9a5dda225 100644 --- a/src/blob.h +++ b/src/blob.h @@ -38,7 +38,7 @@ struct git_blob { void git_blob__free(void *blob); int git_blob__parse(void *blob, git_odb_object *obj); int git_blob__parse_raw(void *blob, const char *data, size_t size); -int git_blob__getbuf(git_buf *buffer, git_blob *blob); +int git_blob__getbuf(git_str *buffer, git_blob *blob); extern int git_blob__create_from_paths( git_oid *out_oid, diff --git a/src/branch.c b/src/branch.c index e6818a86d..cf985f153 100644 --- a/src/branch.c +++ b/src/branch.c @@ -7,6 +7,7 @@ #include "branch.h" +#include "buf.h" #include "commit.h" #include "tag.h" #include "config.h" @@ -27,11 +28,11 @@ static int retrieve_branch_reference( git_reference *branch = NULL; int error = 0; char *prefix; - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; prefix = is_remote ? GIT_REFS_REMOTES_DIR : GIT_REFS_HEADS_DIR; - if ((error = git_buf_joinpath(&ref_name, prefix, branch_name)) < 0) + if ((error = git_str_joinpath(&ref_name, prefix, branch_name)) < 0) /* OOM */; else if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0) git_error_set( @@ -40,7 +41,7 @@ static int retrieve_branch_reference( *branch_reference_out = branch; /* will be NULL on error */ - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; } @@ -62,8 +63,8 @@ static int create_branch( { int is_unmovable_head = 0; git_reference *branch = NULL; - git_buf canonical_branch_name = GIT_BUF_INIT, - log_message = GIT_BUF_INIT; + git_str canonical_branch_name = GIT_STR_INIT, + log_message = GIT_STR_INIT; int error = -1; int bare = git_repository_is_bare(repository); @@ -96,22 +97,22 @@ static int create_branch( goto cleanup; } - if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0) + if (git_str_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0) goto cleanup; - if (git_buf_printf(&log_message, "branch: Created from %s", from) < 0) + if (git_str_printf(&log_message, "branch: Created from %s", from) < 0) goto cleanup; error = git_reference_create(&branch, repository, - git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, - git_buf_cstr(&log_message)); + git_str_cstr(&canonical_branch_name), git_commit_id(commit), force, + git_str_cstr(&log_message)); if (!error) *ref_out = branch; cleanup: - git_buf_dispose(&canonical_branch_name); - git_buf_dispose(&log_message); + git_str_dispose(&canonical_branch_name); + git_str_dispose(&log_message); return error; } @@ -174,7 +175,7 @@ int git_branch_is_checked_out(const git_reference *branch) int git_branch_delete(git_reference *branch) { int is_head; - git_buf config_section = GIT_BUF_INIT; + git_str config_section = GIT_STR_INIT; int error = -1; GIT_ASSERT_ARG(branch); @@ -200,18 +201,18 @@ int git_branch_delete(git_reference *branch) return -1; } - if (git_buf_join(&config_section, '.', "branch", + if (git_str_join(&config_section, '.', "branch", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0) goto on_error; if (git_config_rename_section( - git_reference_owner(branch), git_buf_cstr(&config_section), NULL) < 0) + git_reference_owner(branch), git_str_cstr(&config_section), NULL) < 0) goto on_error; error = git_reference_delete(branch); on_error: - git_buf_dispose(&config_section); + git_str_dispose(&config_section); return error; } @@ -286,10 +287,10 @@ int git_branch_move( const char *new_branch_name, int force) { - git_buf new_reference_name = GIT_BUF_INIT, - old_config_section = GIT_BUF_INIT, - new_config_section = GIT_BUF_INIT, - log_message = GIT_BUF_INIT; + git_str new_reference_name = GIT_STR_INIT, + old_config_section = GIT_STR_INIT, + new_config_section = GIT_STR_INIT, + log_message = GIT_STR_INIT; int error; GIT_ASSERT_ARG(branch); @@ -298,35 +299,35 @@ int git_branch_move( if (!git_reference_is_branch(branch)) return not_a_local_branch(git_reference_name(branch)); - if ((error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name)) < 0) + if ((error = git_str_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name)) < 0) goto done; - if ((error = git_buf_printf(&log_message, "branch: renamed %s to %s", - git_reference_name(branch), git_buf_cstr(&new_reference_name))) < 0) + if ((error = git_str_printf(&log_message, "branch: renamed %s to %s", + git_reference_name(branch), git_str_cstr(&new_reference_name))) < 0) goto done; /* first update ref then config so failure won't trash config */ error = git_reference_rename( - out, branch, git_buf_cstr(&new_reference_name), force, - git_buf_cstr(&log_message)); + out, branch, git_str_cstr(&new_reference_name), force, + git_str_cstr(&log_message)); if (error < 0) goto done; - git_buf_join(&old_config_section, '.', "branch", + git_str_join(&old_config_section, '.', "branch", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)); - git_buf_join(&new_config_section, '.', "branch", new_branch_name); + git_str_join(&new_config_section, '.', "branch", new_branch_name); error = git_config_rename_section( git_reference_owner(branch), - git_buf_cstr(&old_config_section), - git_buf_cstr(&new_config_section)); + git_str_cstr(&old_config_section), + git_str_cstr(&new_config_section)); done: - git_buf_dispose(&new_reference_name); - git_buf_dispose(&old_config_section); - git_buf_dispose(&new_config_section); - git_buf_dispose(&log_message); + git_str_dispose(&new_reference_name); + git_str_dispose(&old_config_section); + git_str_dispose(&new_config_section); + git_str_dispose(&log_message); return error; } @@ -384,20 +385,20 @@ int git_branch_name( } static int retrieve_upstream_configuration( - git_buf *out, + git_str *out, const git_config *config, const char *canonical_branch_name, const char *format) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; - if (git_buf_printf(&buf, format, + if (git_str_printf(&buf, format, canonical_branch_name + strlen(GIT_REFS_HEADS_DIR)) < 0) return -1; - error = git_config_get_string_buf(out, config, git_buf_cstr(&buf)); - git_buf_dispose(&buf); + error = git_config__get_string_buf(out, config, git_str_cstr(&buf)); + git_str_dispose(&buf); return error; } @@ -406,20 +407,26 @@ int git_branch_upstream_name( git_repository *repo, const char *refname) { - git_buf remote_name = GIT_BUF_INIT; - git_buf merge_name = GIT_BUF_INIT; - git_buf buf = GIT_BUF_INIT; + GIT_BUF_WRAP_PRIVATE(out, git_branch__upstream_name, repo, refname); +} + +int git_branch__upstream_name( + git_str *out, + git_repository *repo, + const char *refname) +{ + git_str remote_name = GIT_STR_INIT; + git_str merge_name = GIT_STR_INIT; + git_str buf = GIT_STR_INIT; int error = -1; git_remote *remote = NULL; const git_refspec *refspec; git_config *config; GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(refname); - if ((error = git_buf_sanitize(out)) < 0) - return error; - if (!git_reference__is_branch(refname)) return not_a_local_branch(refname); @@ -434,75 +441,109 @@ int git_branch_upstream_name( &merge_name, config, refname, "branch.%s.merge")) < 0) goto cleanup; - if (git_buf_len(&remote_name) == 0 || git_buf_len(&merge_name) == 0) { + if (git_str_len(&remote_name) == 0 || git_str_len(&merge_name) == 0) { git_error_set(GIT_ERROR_REFERENCE, "branch '%s' does not have an upstream", refname); error = GIT_ENOTFOUND; goto cleanup; } - if (strcmp(".", git_buf_cstr(&remote_name)) != 0) { - if ((error = git_remote_lookup(&remote, repo, git_buf_cstr(&remote_name))) < 0) + if (strcmp(".", git_str_cstr(&remote_name)) != 0) { + if ((error = git_remote_lookup(&remote, repo, git_str_cstr(&remote_name))) < 0) goto cleanup; - refspec = git_remote__matching_refspec(remote, git_buf_cstr(&merge_name)); + refspec = git_remote__matching_refspec(remote, git_str_cstr(&merge_name)); if (!refspec) { error = GIT_ENOTFOUND; goto cleanup; } - if (git_refspec_transform(&buf, refspec, git_buf_cstr(&merge_name)) < 0) + if (git_refspec__transform(&buf, refspec, git_str_cstr(&merge_name)) < 0) goto cleanup; } else - if (git_buf_set(&buf, git_buf_cstr(&merge_name), git_buf_len(&merge_name)) < 0) + if (git_str_set(&buf, git_str_cstr(&merge_name), git_str_len(&merge_name)) < 0) goto cleanup; - error = git_buf_set(out, git_buf_cstr(&buf), git_buf_len(&buf)); + git_str_swap(out, &buf); cleanup: git_config_free(config); git_remote_free(remote); - git_buf_dispose(&remote_name); - git_buf_dispose(&merge_name); - git_buf_dispose(&buf); + git_str_dispose(&remote_name); + git_str_dispose(&merge_name); + git_str_dispose(&buf); return error; } -static int git_branch_upstream_with_format(git_buf *buf, git_repository *repo, const char *refname, const char *format, const char *format_name) +static int git_branch_upstream_with_format( + git_str *out, + git_repository *repo, + const char *refname, + const char *format, + const char *format_name) { - int error; git_config *cfg; + int error; if (!git_reference__is_branch(refname)) return not_a_local_branch(refname); - if ((error = git_repository_config__weakptr(&cfg, repo)) < 0) - return error; - - if ((error = git_buf_sanitize(buf)) < 0 || - (error = retrieve_upstream_configuration(buf, cfg, refname, format)) < 0) + if ((error = git_repository_config__weakptr(&cfg, repo)) < 0 || + (error = retrieve_upstream_configuration(out, cfg, refname, format)) < 0) return error; - if (git_buf_len(buf) == 0) { + if (git_str_len(out) == 0) { git_error_set(GIT_ERROR_REFERENCE, "branch '%s' does not have an upstream %s", refname, format_name); error = GIT_ENOTFOUND; - git_buf_clear(buf); } return error; } -int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *refname) +int git_branch_upstream_remote( + git_buf *out, + git_repository *repo, + const char *refname) { - return git_branch_upstream_with_format(buf, repo, refname, "branch.%s.remote", "remote"); + GIT_BUF_WRAP_PRIVATE(out, git_branch__upstream_remote, repo, refname); } -int git_branch_upstream_merge(git_buf *buf, git_repository *repo, const char *refname) +int git_branch__upstream_remote( + git_str *out, + git_repository *repo, + const char *refname) { - return git_branch_upstream_with_format(buf, repo, refname, "branch.%s.merge", "merge"); + return git_branch_upstream_with_format(out, repo, refname, "branch.%s.remote", "remote"); } -int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refname) +int git_branch_upstream_merge( + git_buf *out, + git_repository *repo, + const char *refname) +{ + GIT_BUF_WRAP_PRIVATE(out, git_branch__upstream_merge, repo, refname); +} + +int git_branch__upstream_merge( + git_str *out, + git_repository *repo, + const char *refname) +{ + return git_branch_upstream_with_format(out, repo, refname, "branch.%s.merge", "merge"); +} + +int git_branch_remote_name( + git_buf *out, + git_repository *repo, + const char *refname) +{ + GIT_BUF_WRAP_PRIVATE(out, git_branch__remote_name, repo, refname); +} + +int git_branch__remote_name( + git_str *out, + git_repository *repo, + const char *refname) { git_strarray remote_list = {0}; size_t i; @@ -511,13 +552,10 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna int error = 0; char *remote_name = NULL; - GIT_ASSERT_ARG(buf); + GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(refname); - if ((error = git_buf_sanitize(buf)) < 0) - return error; - /* Verify that this is a remote branch */ if (!git_reference__is_remote(refname)) { git_error_set(GIT_ERROR_INVALID, "reference '%s' is not a remote branch.", @@ -557,8 +595,8 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna } if (remote_name) { - git_buf_clear(buf); - error = git_buf_puts(buf, remote_name); + git_str_clear(out); + error = git_str_puts(out, remote_name); } else { git_error_set(GIT_ERROR_REFERENCE, "could not determine remote for '%s'", refname); @@ -567,7 +605,7 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna cleanup: if (error < 0) - git_buf_dispose(buf); + git_str_dispose(out); git_strarray_dispose(&remote_list); return error; @@ -578,49 +616,49 @@ int git_branch_upstream( const git_reference *branch) { int error; - git_buf tracking_name = GIT_BUF_INIT; + git_str tracking_name = GIT_STR_INIT; - if ((error = git_branch_upstream_name(&tracking_name, + if ((error = git_branch__upstream_name(&tracking_name, git_reference_owner(branch), git_reference_name(branch))) < 0) return error; error = git_reference_lookup( tracking_out, git_reference_owner(branch), - git_buf_cstr(&tracking_name)); + git_str_cstr(&tracking_name)); - git_buf_dispose(&tracking_name); + git_str_dispose(&tracking_name); return error; } static int unset_upstream(git_config *config, const char *shortname) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; - if (git_buf_printf(&buf, "branch.%s.remote", shortname) < 0) + if (git_str_printf(&buf, "branch.%s.remote", shortname) < 0) return -1; - if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0) + if (git_config_delete_entry(config, git_str_cstr(&buf)) < 0) goto on_error; - git_buf_clear(&buf); - if (git_buf_printf(&buf, "branch.%s.merge", shortname) < 0) + git_str_clear(&buf); + if (git_str_printf(&buf, "branch.%s.merge", shortname) < 0) goto on_error; - if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0) + if (git_config_delete_entry(config, git_str_cstr(&buf)) < 0) goto on_error; - git_buf_dispose(&buf); + git_str_dispose(&buf); return 0; on_error: - git_buf_dispose(&buf); + git_str_dispose(&buf); return -1; } int git_branch_set_upstream(git_reference *branch, const char *branch_name) { - git_buf key = GIT_BUF_INIT, remote_name = GIT_BUF_INIT, merge_refspec = GIT_BUF_INIT; + git_str key = GIT_STR_INIT, remote_name = GIT_STR_INIT, merge_refspec = GIT_STR_INIT; git_reference *upstream; git_repository *repo; git_remote *remote = NULL; @@ -662,31 +700,31 @@ int git_branch_set_upstream(git_reference *branch, const char *branch_name) * name on the remote is and use that. */ if (local) - error = git_buf_puts(&remote_name, "."); + error = git_str_puts(&remote_name, "."); else - error = git_branch_remote_name(&remote_name, repo, git_reference_name(upstream)); + error = git_branch__remote_name(&remote_name, repo, git_reference_name(upstream)); if (error < 0) goto on_error; /* Update the upsteam branch config with the new name */ - if (git_buf_printf(&key, "branch.%s.remote", shortname) < 0) + if (git_str_printf(&key, "branch.%s.remote", shortname) < 0) goto on_error; - if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&remote_name)) < 0) + if (git_config_set_string(config, git_str_cstr(&key), git_str_cstr(&remote_name)) < 0) goto on_error; if (local) { /* A local branch uses the upstream refname directly */ - if (git_buf_puts(&merge_refspec, git_reference_name(upstream)) < 0) + if (git_str_puts(&merge_refspec, git_reference_name(upstream)) < 0) goto on_error; } else { /* We transform the upstream branch name according to the remote's refspecs */ - if (git_remote_lookup(&remote, repo, git_buf_cstr(&remote_name)) < 0) + if (git_remote_lookup(&remote, repo, git_str_cstr(&remote_name)) < 0) goto on_error; fetchspec = git_remote__matching_dst_refspec(remote, git_reference_name(upstream)); - if (!fetchspec || git_refspec_rtransform(&merge_refspec, fetchspec, git_reference_name(upstream)) < 0) + if (!fetchspec || git_refspec__rtransform(&merge_refspec, fetchspec, git_reference_name(upstream)) < 0) goto on_error; git_remote_free(remote); @@ -694,25 +732,25 @@ int git_branch_set_upstream(git_reference *branch, const char *branch_name) } /* Update the merge branch config with the refspec */ - git_buf_clear(&key); - if (git_buf_printf(&key, "branch.%s.merge", shortname) < 0) + git_str_clear(&key); + if (git_str_printf(&key, "branch.%s.merge", shortname) < 0) goto on_error; - if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&merge_refspec)) < 0) + if (git_config_set_string(config, git_str_cstr(&key), git_str_cstr(&merge_refspec)) < 0) goto on_error; git_reference_free(upstream); - git_buf_dispose(&key); - git_buf_dispose(&remote_name); - git_buf_dispose(&merge_refspec); + git_str_dispose(&key); + git_str_dispose(&remote_name); + git_str_dispose(&merge_refspec); return 0; on_error: git_reference_free(upstream); - git_buf_dispose(&key); - git_buf_dispose(&remote_name); - git_buf_dispose(&merge_refspec); + git_str_dispose(&key); + git_str_dispose(&remote_name); + git_str_dispose(&merge_refspec); git_remote_free(remote); return -1; @@ -749,7 +787,7 @@ int git_branch_is_head( int git_branch_name_is_valid(int *valid, const char *name) { - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; int error = 0; GIT_ASSERT(valid); @@ -765,13 +803,13 @@ int git_branch_name_is_valid(int *valid, const char *name) if (!name || name[0] == '-' || !git__strcmp(name, "HEAD")) goto done; - if ((error = git_buf_puts(&ref_name, GIT_REFS_HEADS_DIR)) < 0 || - (error = git_buf_puts(&ref_name, name)) < 0) + if ((error = git_str_puts(&ref_name, GIT_REFS_HEADS_DIR)) < 0 || + (error = git_str_puts(&ref_name, name)) < 0) goto done; error = git_reference_name_is_valid(valid, ref_name.ptr); done: - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; } diff --git a/src/branch.h b/src/branch.h index 5ae227c05..b4db42a01 100644 --- a/src/branch.h +++ b/src/branch.h @@ -9,10 +9,22 @@ #include "common.h" -#include "buffer.h" +#include "str.h" -int git_branch_upstream__name( - git_buf *tracking_name, +int git_branch__remote_name( + git_str *out, + git_repository *repo, + const char *refname); +int git_branch__upstream_remote( + git_str *out, + git_repository *repo, + const char *refname); +int git_branch__upstream_merge( + git_str *out, + git_repository *repo, + const char *refname); +int git_branch__upstream_name( + git_str *tracking_name, git_repository *repo, const char *canonical_branch_name); diff --git a/src/buf.c b/src/buf.c new file mode 100644 index 000000000..652f5dd52 --- /dev/null +++ b/src/buf.c @@ -0,0 +1,126 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * 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 "buf.h" +#include "common.h" + +int git_buf_sanitize(git_buf *buf) +{ + GIT_ASSERT_ARG(buf); + + if (buf->reserved > 0) + buf->ptr[0] = '\0'; + else + buf->ptr = git_str__initstr; + + buf->size = 0; + return 0; +} + +int git_buf_tostr(git_str *out, git_buf *buf) +{ + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(buf); + + if (git_buf_sanitize(buf) < 0) + return -1; + + out->ptr = buf->ptr; + out->asize = buf->reserved; + out->size = buf->size; + + buf->ptr = git_str__initstr; + buf->reserved = 0; + buf->size = 0; + + return 0; +} + +int git_buf_fromstr(git_buf *out, git_str *str) +{ + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(str); + + out->ptr = str->ptr; + out->reserved = str->asize; + out->size = str->size; + + str->ptr = git_str__initstr; + str->asize = 0; + str->size = 0; + + return 0; +} + +void git_buf_dispose(git_buf *buf) +{ + if (!buf) + return; + + if (buf->ptr != git_str__initstr) + git__free(buf->ptr); + + buf->ptr = git_str__initstr; + buf->reserved = 0; + buf->size = 0; +} + +#ifndef GIT_DEPRECATE_HARD +int git_buf_grow(git_buf *buffer, size_t target_size) +{ + char *newptr; + + if (buffer->reserved >= target_size) + return 0; + + if (buffer->ptr == git_str__initstr) + newptr = git__malloc(target_size); + else + newptr = git__realloc(buffer->ptr, target_size); + + if (!newptr) + return -1; + + buffer->ptr = newptr; + buffer->reserved = target_size; + return 0; +} + +int git_buf_set(git_buf *buffer, const void *data, size_t datalen) +{ + size_t alloclen; + + GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, datalen, 1); + + if (git_buf_grow(buffer, alloclen) < 0) + return -1; + + memmove(buffer->ptr, data, datalen); + buffer->size = datalen; + buffer->ptr[buffer->size] = '\0'; + + return 0; +} + +int git_buf_is_binary(const git_buf *buf) +{ + git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size); + return git_str_is_binary(&str); +} + +int git_buf_contains_nul(const git_buf *buf) +{ + git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size); + return git_str_contains_nul(&str); +} + +void git_buf_free(git_buf *buffer) +{ + git_buf_dispose(buffer); +} + +#endif diff --git a/src/buf.h b/src/buf.h new file mode 100644 index 000000000..4bc7f2709 --- /dev/null +++ b/src/buf.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * 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_buf_h__ +#define INCLUDE_buf_h__ + +#include "git2/buffer.h" +#include "common.h" + +/* + * Adapts a private API that takes a `git_str` into a public API that + * takes a `git_buf`. + */ + +#define GIT_BUF_WRAP_PRIVATE(buf, fn, ...) \ + { \ + git_str str = GIT_STR_INIT; \ + int error; \ + if ((error = git_buf_tostr(&str, buf)) == 0 && \ + (error = fn(&str, __VA_ARGS__)) == 0) \ + error = git_buf_fromstr(buf, &str); \ + git_str_dispose(&str); \ + return error; \ +} + +/** + * "Sanitizes" a buffer from user input. This simply ensures that the + * `git_buf` has nice defaults if the user didn't set the members to + * anything, so that if we return early we don't leave it populated + * with nonsense. + */ +extern int git_buf_sanitize(git_buf *from_user); + +/** + * Populate a `git_str` from a `git_buf` for passing to libgit2 internal + * functions. Sanitizes the given `git_buf` before proceeding. The + * `git_buf` will no longer point to this memory. + */ +extern int git_buf_tostr(git_str *out, git_buf *buf); + +/** + * Populate a `git_buf` from a `git_str` for returning to a user. + * The `git_str` will no longer point to this memory. + */ +extern int git_buf_fromstr(git_buf *out, git_str *str); + +#endif diff --git a/src/buffer.h b/src/buffer.h deleted file mode 100644 index 75930e209..000000000 --- a/src/buffer.h +++ /dev/null @@ -1,374 +0,0 @@ -/* - * Copyright (C) the libgit2 contributors. All rights reserved. - * - * 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_buffer_h__ -#define INCLUDE_buffer_h__ - -#include "common.h" -#include "git2/strarray.h" -#include "git2/buffer.h" - -/* typedef struct { - * char *ptr; - * size_t asize, size; - * } git_buf; - */ - -typedef enum { - GIT_BUF_BOM_NONE = 0, - GIT_BUF_BOM_UTF8 = 1, - GIT_BUF_BOM_UTF16_LE = 2, - GIT_BUF_BOM_UTF16_BE = 3, - GIT_BUF_BOM_UTF32_LE = 4, - GIT_BUF_BOM_UTF32_BE = 5 -} git_buf_bom_t; - -typedef struct { - git_buf_bom_t bom; /* BOM found at head of text */ - unsigned int nul, cr, lf, crlf; /* NUL, CR, LF and CRLF counts */ - unsigned int printable, nonprintable; /* These are just approximations! */ -} git_buf_text_stats; - -extern char git_buf__initbuf[]; -extern char git_buf__oom[]; - -/* Use to initialize buffer structure when git_buf is on stack */ -#define GIT_BUF_INIT { git_buf__initbuf, 0, 0 } - -/** - * Static initializer for git_buf from static buffer - */ -#ifdef GIT_DEPRECATE_HARD -# define GIT_BUF_INIT_CONST(STR,LEN) { (char *)(STR), 0, (size_t)(LEN) } -#endif - -GIT_INLINE(bool) git_buf_is_allocated(const git_buf *buf) -{ - return (buf->ptr != NULL && buf->asize > 0); -} - -/** - * Initialize a git_buf structure. - * - * For the cases where GIT_BUF_INIT cannot be used to do static - * initialization. - */ -extern int git_buf_init(git_buf *buf, size_t initial_size); - -#ifdef GIT_DEPRECATE_HARD - -/** - * Resize the buffer allocation to make more space. - * - * This will attempt to grow the buffer to accommodate the target size. - * - * If the buffer refers to memory that was not allocated by libgit2 (i.e. - * the `asize` field is zero), then `ptr` will be replaced with a newly - * allocated block of data. Be careful so that memory allocated by the - * caller is not lost. As a special variant, if you pass `target_size` as - * 0 and the memory is not allocated by libgit2, this will allocate a new - * buffer of size `size` and copy the external data into it. - * - * Currently, this will never shrink a buffer, only expand it. - * - * If the allocation fails, this will return an error and the buffer will be - * marked as invalid for future operations, invaliding the contents. - * - * @param buffer The buffer to be resized; may or may not be allocated yet - * @param target_size The desired available size - * @return 0 on success, -1 on allocation failure - */ -int git_buf_grow(git_buf *buffer, size_t target_size); - -#endif - -/** - * Resize the buffer allocation to make more space. - * - * This will attempt to grow the buffer to accommodate the additional size. - * It is similar to `git_buf_grow`, but performs the new size calculation, - * checking for overflow. - * - * Like `git_buf_grow`, if this is a user-supplied buffer, this will allocate - * a new buffer. - */ -extern int git_buf_grow_by(git_buf *buffer, size_t additional_size); - -/** - * Attempt to grow the buffer to hold at least `target_size` bytes. - * - * If the allocation fails, this will return an error. If `mark_oom` is true, - * this will mark the buffer as invalid for future operations; if false, - * existing buffer content will be preserved, but calling code must handle - * that buffer was not expanded. If `preserve_external` is true, then any - * existing data pointed to be `ptr` even if `asize` is zero will be copied - * into the newly allocated buffer. - */ -extern int git_buf_try_grow( - git_buf *buf, size_t target_size, bool mark_oom); - -/** - * Sanitizes git_buf structures provided from user input. Users of the - * library, when providing git_buf's, may wish to provide a NULL ptr for - * ease of handling. The buffer routines, however, expect a non-NULL ptr - * always. This helper method simply handles NULL input, converting to a - * git_buf__initbuf. If a buffer with a non-NULL ptr is passed in, this method - * assures that the buffer is '\0'-terminated. - */ -extern int git_buf_sanitize(git_buf *buf); - -extern void git_buf_swap(git_buf *buf_a, git_buf *buf_b); -extern char *git_buf_detach(git_buf *buf); -extern int git_buf_attach(git_buf *buf, char *ptr, size_t asize); - -/* Populates a `git_buf` where the contents are not "owned" by the - * buffer, and calls to `git_buf_dispose` will not free the given buf. - */ -extern void git_buf_attach_notowned( - git_buf *buf, const char *ptr, size_t size); - -/** - * Test if there have been any reallocation failures with this git_buf. - * - * Any function that writes to a git_buf can fail due to memory allocation - * issues. If one fails, the git_buf will be marked with an OOM error and - * further calls to modify the buffer will fail. Check git_buf_oom() at the - * end of your sequence and it will be true if you ran out of memory at any - * point with that buffer. - * - * @return false if no error, true if allocation error - */ -GIT_INLINE(bool) git_buf_oom(const git_buf *buf) -{ - return (buf->ptr == git_buf__oom); -} - -/* - * Functions below that return int value error codes will return 0 on - * success or -1 on failure (which generally means an allocation failed). - * Using a git_buf where the allocation has failed with result in -1 from - * all further calls using that buffer. As a result, you can ignore the - * return code of these functions and call them in a series then just call - * git_buf_oom at the end. - */ - -#ifdef GIT_DEPRECATE_HARD -int git_buf_set(git_buf *buffer, const void *data, size_t datalen); -#endif - -int git_buf_sets(git_buf *buf, const char *string); -int git_buf_putc(git_buf *buf, char c); -int git_buf_putcn(git_buf *buf, char c, size_t len); -int git_buf_put(git_buf *buf, const char *data, size_t len); -int git_buf_puts(git_buf *buf, const char *string); -int git_buf_printf(git_buf *buf, const char *format, ...) GIT_FORMAT_PRINTF(2, 3); -int git_buf_vprintf(git_buf *buf, const char *format, va_list ap); -void git_buf_clear(git_buf *buf); -void git_buf_consume_bytes(git_buf *buf, size_t len); -void git_buf_consume(git_buf *buf, const char *end); -void git_buf_truncate(git_buf *buf, size_t len); -void git_buf_shorten(git_buf *buf, size_t amount); -void git_buf_truncate_at_char(git_buf *buf, char separator); -void git_buf_rtruncate_at_char(git_buf *path, char separator); - -/** General join with separator */ -int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...); -/** Fast join of two strings - first may legally point into `buf` data */ -int git_buf_join(git_buf *buf, char separator, const char *str_a, const char *str_b); -/** Fast join of three strings - cannot reference `buf` data */ -int git_buf_join3(git_buf *buf, char separator, const char *str_a, const char *str_b, const char *str_c); - -/** - * Join two strings as paths, inserting a slash between as needed. - * @return 0 on success, -1 on failure - */ -GIT_INLINE(int) git_buf_joinpath(git_buf *buf, const char *a, const char *b) -{ - return git_buf_join(buf, '/', a, b); -} - -GIT_INLINE(const char *) git_buf_cstr(const git_buf *buf) -{ - return buf->ptr; -} - -GIT_INLINE(size_t) git_buf_len(const git_buf *buf) -{ - return buf->size; -} - -int git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf); - -#define git_buf_PUTS(buf, str) git_buf_put(buf, str, sizeof(str) - 1) - -GIT_INLINE(ssize_t) git_buf_rfind_next(const git_buf *buf, char ch) -{ - ssize_t idx = (ssize_t)buf->size - 1; - while (idx >= 0 && buf->ptr[idx] == ch) idx--; - while (idx >= 0 && buf->ptr[idx] != ch) idx--; - return idx; -} - -GIT_INLINE(ssize_t) git_buf_rfind(const git_buf *buf, char ch) -{ - ssize_t idx = (ssize_t)buf->size - 1; - while (idx >= 0 && buf->ptr[idx] != ch) idx--; - return idx; -} - -GIT_INLINE(ssize_t) git_buf_find(const git_buf *buf, char ch) -{ - void *found = memchr(buf->ptr, ch, buf->size); - return found ? (ssize_t)((const char *)found - buf->ptr) : -1; -} - -/* Remove whitespace from the end of the buffer */ -void git_buf_rtrim(git_buf *buf); - -int git_buf_cmp(const git_buf *a, const git_buf *b); - -/* Quote and unquote a buffer as specified in - * http://marc.info/?l=git&m=112927316408690&w=2 - */ -int git_buf_quote(git_buf *buf); -int git_buf_unquote(git_buf *buf); - -/* Write data as base64 encoded in buffer */ -int git_buf_encode_base64(git_buf *buf, const char *data, size_t len); -/* Decode the given bas64 and write the result to the buffer */ -int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len); - -/* Write data as "base85" encoded in buffer */ -int git_buf_encode_base85(git_buf *buf, const char *data, size_t len); -/* Decode the given "base85" and write the result to the buffer */ -int git_buf_decode_base85(git_buf *buf, const char *base64, size_t len, size_t output_len); - -/* Decode the given percent-encoded string and write the result to the buffer */ -int git_buf_decode_percent(git_buf *buf, const char *str, size_t len); - -/* - * Insert, remove or replace a portion of the buffer. - * - * @param buf The buffer to work with - * - * @param where The location in the buffer where the transformation - * should be applied. - * - * @param nb_to_remove The number of chars to be removed. 0 to not - * remove any character in the buffer. - * - * @param data A pointer to the data which should be inserted. - * - * @param nb_to_insert The number of chars to be inserted. 0 to not - * insert any character from the buffer. - * - * @return 0 or an error code. - */ -int git_buf_splice( - git_buf *buf, - size_t where, - size_t nb_to_remove, - const char *data, - size_t nb_to_insert); - -/** - * Append string to buffer, prefixing each character from `esc_chars` with - * `esc_with` string. - * - * @param buf Buffer to append data to - * @param string String to escape and append - * @param esc_chars Characters to be escaped - * @param esc_with String to insert in from of each found character - * @return 0 on success, <0 on failure (probably allocation problem) - */ -extern int git_buf_puts_escaped( - git_buf *buf, - const char *string, - const char *esc_chars, - const char *esc_with); - -/** - * Append string escaping characters that are regex special - */ -GIT_INLINE(int) git_buf_puts_escape_regex(git_buf *buf, const char *string) -{ - return git_buf_puts_escaped(buf, string, "^.[]$()|*+?{}\\", "\\"); -} - -/** - * Unescape all characters in a buffer in place - * - * I.e. remove backslashes - */ -extern void git_buf_unescape(git_buf *buf); - -/** - * Replace all \r\n with \n. - * - * @return 0 on success, -1 on memory error - */ -extern int git_buf_crlf_to_lf(git_buf *tgt, const git_buf *src); - -/** - * Replace all \n with \r\n. Does not modify existing \r\n. - * - * @return 0 on success, -1 on memory error - */ -extern int git_buf_lf_to_crlf(git_buf *tgt, const git_buf *src); - -/** - * Fill buffer with the common prefix of a array of strings - * - * Buffer will be set to empty if there is no common prefix - */ -extern int git_buf_common_prefix(git_buf *buf, char *const *const strings, size_t count); - -/** - * Check if a buffer begins with a UTF BOM - * - * @param bom Set to the type of BOM detected or GIT_BOM_NONE - * @param buf Buffer in which to check the first bytes for a BOM - * @return Number of bytes of BOM data (or 0 if no BOM found) - */ -extern int git_buf_detect_bom(git_buf_bom_t *bom, const git_buf *buf); - -/** - * Gather stats for a piece of text - * - * Fill the `stats` structure with counts of unreadable characters, carriage - * returns, etc, so it can be used in heuristics. This automatically skips - * a trailing EOF (\032 character). Also it will look for a BOM at the - * start of the text and can be told to skip that as well. - * - * @param stats Structure to be filled in - * @param buf Text to process - * @param skip_bom Exclude leading BOM from stats if true - * @return Does the buffer heuristically look like binary data - */ -extern bool git_buf_gather_text_stats( - git_buf_text_stats *stats, const git_buf *buf, bool skip_bom); - -#ifdef GIT_DEPRECATE_HARD - -/** -* Check quickly if buffer looks like it contains binary data -* -* @param buf Buffer to check -* @return 1 if buffer looks like non-text data -*/ -int git_buf_is_binary(const git_buf *buf); - -/** -* Check quickly if buffer contains a NUL byte -* -* @param buf Buffer to check -* @return 1 if buffer contains a NUL byte -*/ -int git_buf_contains_nul(const git_buf *buf); - -#endif - -#endif diff --git a/src/checkout.c b/src/checkout.c index 3a171066b..b31918fc8 100644 --- a/src/checkout.c +++ b/src/checkout.c @@ -61,9 +61,9 @@ typedef struct { git_vector update_conflicts; git_vector *update_reuc; git_vector *update_names; - git_buf target_path; + git_str target_path; size_t target_len; - git_buf tmp; + git_str tmp; unsigned int strategy; int can_symlink; int respect_filemode; @@ -321,11 +321,11 @@ static int checkout_action_no_wd( } static int checkout_target_fullpath( - git_buf **out, checkout_data *data, const char *path) + git_str **out, checkout_data *data, const char *path) { - git_buf_truncate(&data->target_path, data->target_len); + git_str_truncate(&data->target_path, data->target_len); - if (path && git_buf_puts(&data->target_path, path) < 0) + if (path && git_str_puts(&data->target_path, path) < 0) return -1; if (git_path_validate_workdir_buf(data->repo, &data->target_path) < 0) @@ -339,7 +339,7 @@ static int checkout_target_fullpath( static bool wd_item_is_removable( checkout_data *data, const git_index_entry *wd) { - git_buf *full; + git_str *full; if (wd->mode != GIT_FILEMODE_TREE) return true; @@ -423,7 +423,7 @@ static int checkout_action_wd_only( /* copy the entry for issuing notification callback later */ git_index_entry saved_wd = *wd; - git_buf_sets(&data->tmp, wd->path); + git_str_sets(&data->tmp, wd->path); saved_wd.path = data->tmp.ptr; error = git_iterator_advance_over( @@ -476,7 +476,7 @@ static bool submodule_is_config_only( static bool checkout_is_empty_dir(checkout_data *data, const char *path) { - git_buf *fullpath; + git_str *fullpath; if (checkout_target_fullpath(&fullpath, data, path) < 0) return false; @@ -1584,7 +1584,7 @@ static int blob_content_to_link( git_blob *blob, const char *path) { - git_buf linktarget = GIT_BUF_INIT; + git_str linktarget = GIT_STR_INIT; int error; if ((error = mkpath2file(data, path, data->opts.dir_mode)) < 0) @@ -1594,10 +1594,10 @@ static int blob_content_to_link( return error; if (data->can_symlink) { - if ((error = p_symlink(git_buf_cstr(&linktarget), path)) < 0) + if ((error = p_symlink(git_str_cstr(&linktarget), path)) < 0) git_error_set(GIT_ERROR_OS, "could not create symlink %s", path); } else { - error = git_futils_fake_symlink(git_buf_cstr(&linktarget), path); + error = git_futils_fake_symlink(git_str_cstr(&linktarget), path); } if (!error) { @@ -1609,7 +1609,7 @@ static int blob_content_to_link( st->st_mode = GIT_FILEMODE_LINK; } - git_buf_dispose(&linktarget); + git_str_dispose(&linktarget); return error; } @@ -1636,7 +1636,7 @@ static int checkout_submodule_update_index( checkout_data *data, const git_diff_file *file) { - git_buf *fullpath; + git_str *fullpath; struct stat st; /* update the index unless prevented */ @@ -1772,7 +1772,7 @@ static int checkout_blob( checkout_data *data, const git_diff_file *file) { - git_buf *fullpath; + git_str *fullpath; struct stat st; int error = 0; @@ -1809,7 +1809,7 @@ static int checkout_remove_the_old( git_diff_delta *delta; const char *str; size_t i; - git_buf *fullpath; + git_str *fullpath; uint32_t flg = GIT_RMDIR_EMPTY_PARENTS | GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS; @@ -1927,40 +1927,40 @@ static int checkout_lookup_head_tree(git_tree **out, git_repository *repo) static int conflict_entry_name( - git_buf *out, + git_str *out, const char *side_name, const char *filename) { - if (git_buf_puts(out, side_name) < 0 || - git_buf_putc(out, ':') < 0 || - git_buf_puts(out, filename) < 0) + if (git_str_puts(out, side_name) < 0 || + git_str_putc(out, ':') < 0 || + git_str_puts(out, filename) < 0) return -1; return 0; } -static int checkout_path_suffixed(git_buf *path, const char *suffix) +static int checkout_path_suffixed(git_str *path, const char *suffix) { size_t path_len; int i = 0, error = 0; - if ((error = git_buf_putc(path, '~')) < 0 || (error = git_buf_puts(path, suffix)) < 0) + if ((error = git_str_putc(path, '~')) < 0 || (error = git_str_puts(path, suffix)) < 0) return -1; - path_len = git_buf_len(path); + path_len = git_str_len(path); - while (git_path_exists(git_buf_cstr(path)) && i < INT_MAX) { - git_buf_truncate(path, path_len); + while (git_path_exists(git_str_cstr(path)) && i < INT_MAX) { + git_str_truncate(path, path_len); - if ((error = git_buf_putc(path, '_')) < 0 || - (error = git_buf_printf(path, "%d", i)) < 0) + if ((error = git_str_putc(path, '_')) < 0 || + (error = git_str_printf(path, "%d", i)) < 0) return error; i++; } if (i == INT_MAX) { - git_buf_truncate(path, path_len); + git_str_truncate(path, path_len); git_error_set(GIT_ERROR_CHECKOUT, "could not write '%s': working directory file exists", path->ptr); return GIT_EEXISTS; @@ -1974,8 +1974,8 @@ static int checkout_write_entry( checkout_conflictdata *conflict, const git_index_entry *side) { - const char *hint_path, *suffix; - git_buf *fullpath; + const char *hint_path = NULL, *suffix; + git_str *fullpath; struct stat st; int error; @@ -2025,7 +2025,7 @@ static int checkout_write_entries( } static int checkout_merge_path( - git_buf *out, + git_str *out, checkout_data *data, checkout_conflictdata *conflict, git_merge_file_result *result) @@ -2033,7 +2033,7 @@ static int checkout_merge_path( const char *our_label_raw, *their_label_raw, *suffix; int error = 0; - if ((error = git_buf_joinpath(out, data->opts.target_directory, result->path)) < 0 || + if ((error = git_str_joinpath(out, data->opts.target_directory, result->path)) < 0 || (error = git_path_validate_workdir_buf(data->repo, out)) < 0) return error; @@ -2056,9 +2056,9 @@ static int checkout_write_merge( checkout_data *data, checkout_conflictdata *conflict) { - git_buf our_label = GIT_BUF_INIT, their_label = GIT_BUF_INIT, - path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT, - in_data = GIT_BUF_INIT, out_data = GIT_BUF_INIT; + git_str our_label = GIT_STR_INIT, their_label = GIT_STR_INIT, + path_suffixed = GIT_STR_INIT, path_workdir = GIT_STR_INIT, + in_data = GIT_STR_INIT, out_data = GIT_STR_INIT; git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT; git_merge_file_result result = {0}; git_filebuf output = GIT_FILEBUF_INIT; @@ -2088,8 +2088,8 @@ static int checkout_write_merge( &their_label, opts.their_label, conflict->theirs->path)) < 0) goto done; - opts.our_label = git_buf_cstr(&our_label); - opts.their_label = git_buf_cstr(&their_label); + opts.our_label = git_str_cstr(&our_label); + opts.their_label = git_str_cstr(&their_label); } if ((error = git_merge_file_from_index(&result, data->repo, @@ -2106,7 +2106,7 @@ static int checkout_write_merge( goto done; if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0 && - (error = checkout_safe_for_update_only(data, git_buf_cstr(&path_workdir), result.mode)) <= 0) + (error = checkout_safe_for_update_only(data, git_str_cstr(&path_workdir), result.mode)) <= 0) goto done; if (!data->opts.disable_filters) { @@ -2127,7 +2127,7 @@ static int checkout_write_merge( } if ((error = mkpath2file(data, path_workdir.ptr, data->opts.dir_mode)) < 0 || - (error = git_filebuf_open(&output, git_buf_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 || + (error = git_filebuf_open(&output, git_str_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 || (error = git_filebuf_write(&output, out_data.ptr, out_data.size)) < 0 || (error = git_filebuf_commit(&output)) < 0) goto done; @@ -2135,13 +2135,13 @@ static int checkout_write_merge( done: git_filter_list_free(fl); - git_buf_dispose(&out_data); - git_buf_dispose(&our_label); - git_buf_dispose(&their_label); + git_str_dispose(&out_data); + git_str_dispose(&our_label); + git_str_dispose(&their_label); git_merge_file_result_free(&result); - git_buf_dispose(&path_workdir); - git_buf_dispose(&path_suffixed); + git_str_dispose(&path_workdir); + git_str_dispose(&path_suffixed); return error; } @@ -2321,8 +2321,8 @@ static void checkout_data_clear(checkout_data *data) git__free(data->pfx); data->pfx = NULL; - git_buf_dispose(&data->target_path); - git_buf_dispose(&data->tmp); + git_str_dispose(&data->target_path); + git_str_dispose(&data->tmp); git_index_free(data->index); data->index = NULL; @@ -2506,12 +2506,12 @@ static int checkout_data_init( (error = git_vector_init(&data->removes, 0, git__strcmp_cb)) < 0 || (error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 || (error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 || - (error = git_buf_puts(&data->target_path, data->opts.target_directory)) < 0 || + (error = git_str_puts(&data->target_path, data->opts.target_directory)) < 0 || (error = git_path_to_dir(&data->target_path)) < 0 || (error = git_strmap_new(&data->mkdir_map)) < 0) goto cleanup; - data->target_len = git_buf_len(&data->target_path); + data->target_len = git_str_len(&data->target_path); git_attr_session__init(&data->attr_session, data->repo); @@ -2623,7 +2623,7 @@ int git_checkout_iterator( if (data.strategy & GIT_CHECKOUT_DRY_RUN) goto cleanup; - + data.total_steps = counts[CHECKOUT_ACTION__REMOVE] + counts[CHECKOUT_ACTION__REMOVE_CONFLICT] + counts[CHECKOUT_ACTION__UPDATE_BLOB] + diff --git a/src/cherrypick.c b/src/cherrypick.c index 4287956c9..9ec4962b9 100644 --- a/src/cherrypick.c +++ b/src/cherrypick.c @@ -26,10 +26,10 @@ static int write_cherrypick_head( const char *commit_oidstr) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; int error = 0; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_CHERRYPICK_HEAD_FILE)) >= 0 && + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_CHERRYPICK_HEAD_FILE)) >= 0 && (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_CHERRYPICK_FILE_MODE)) >= 0 && (error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0) error = git_filebuf_commit(&file); @@ -37,7 +37,7 @@ static int write_cherrypick_head( if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -47,10 +47,10 @@ static int write_merge_msg( const char *commit_msg) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; int error = 0; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_CHERRYPICK_FILE_MODE)) < 0 || (error = git_filebuf_printf(&file, "%s", commit_msg)) < 0) goto cleanup; @@ -61,7 +61,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -175,7 +175,7 @@ int git_cherrypick( git_commit *our_commit = NULL; char commit_oidstr[GIT_OID_HEXSZ + 1]; const char *commit_msg, *commit_summary; - git_buf their_label = GIT_BUF_INIT; + git_str their_label = GIT_STR_INIT; git_index *index = NULL; git_indexwriter indexwriter = GIT_INDEXWRITER_INIT; int error = 0; @@ -197,8 +197,8 @@ int git_cherrypick( git_oid_nfmt(commit_oidstr, sizeof(commit_oidstr), git_commit_id(commit)); if ((error = write_merge_msg(repo, commit_msg)) < 0 || - (error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 || - (error = cherrypick_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 || + (error = git_str_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 || + (error = cherrypick_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 || (error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 || (error = write_cherrypick_head(repo, commit_oidstr)) < 0 || (error = git_repository_head(&our_ref, repo)) < 0 || @@ -220,7 +220,7 @@ done: git_index_free(index); git_commit_free(our_commit); git_reference_free(our_ref); - git_buf_dispose(&their_label); + git_str_dispose(&their_label); return error; } diff --git a/src/clone.c b/src/clone.c index 752df3b92..cf4cc3c7f 100644 --- a/src/clone.c +++ b/src/clone.c @@ -34,7 +34,7 @@ static int create_branch( { git_commit *head_obj = NULL; git_reference *branch_ref = NULL; - git_buf refname = GIT_BUF_INIT; + git_str refname = GIT_STR_INIT; int error; /* Find the target commit */ @@ -42,11 +42,11 @@ static int create_branch( return error; /* Create the new branch */ - if ((error = git_buf_printf(&refname, GIT_REFS_HEADS_DIR "%s", name)) < 0) + if ((error = git_str_printf(&refname, GIT_REFS_HEADS_DIR "%s", name)) < 0) return error; - error = git_reference_create(&branch_ref, repo, git_buf_cstr(&refname), target, 0, log_message); - git_buf_dispose(&refname); + error = git_reference_create(&branch_ref, repo, git_str_cstr(&refname), target, 0, log_message); + git_str_dispose(&refname); git_commit_free(head_obj); if (!error) @@ -64,29 +64,29 @@ static int setup_tracking_config( const char *merge_target) { git_config *cfg; - git_buf remote_key = GIT_BUF_INIT, merge_key = GIT_BUF_INIT; + git_str remote_key = GIT_STR_INIT, merge_key = GIT_STR_INIT; int error = -1; if (git_repository_config__weakptr(&cfg, repo) < 0) return -1; - if (git_buf_printf(&remote_key, "branch.%s.remote", branch_name) < 0) + if (git_str_printf(&remote_key, "branch.%s.remote", branch_name) < 0) goto cleanup; - if (git_buf_printf(&merge_key, "branch.%s.merge", branch_name) < 0) + if (git_str_printf(&merge_key, "branch.%s.merge", branch_name) < 0) goto cleanup; - if (git_config_set_string(cfg, git_buf_cstr(&remote_key), remote_name) < 0) + if (git_config_set_string(cfg, git_str_cstr(&remote_key), remote_name) < 0) goto cleanup; - if (git_config_set_string(cfg, git_buf_cstr(&merge_key), merge_target) < 0) + if (git_config_set_string(cfg, git_str_cstr(&merge_key), merge_target) < 0) goto cleanup; error = 0; cleanup: - git_buf_dispose(&remote_key); - git_buf_dispose(&merge_key); + git_str_dispose(&remote_key); + git_str_dispose(&merge_key); return error; } @@ -139,7 +139,7 @@ static int update_head_to_new_branch( static int update_head_to_default(git_repository *repo) { - git_buf initialbranch = GIT_BUF_INIT; + git_str initialbranch = GIT_STR_INIT; const char *branch_name; int error = 0; @@ -158,24 +158,24 @@ static int update_head_to_default(git_repository *repo) initialbranch.ptr); done: - git_buf_dispose(&initialbranch); + git_str_dispose(&initialbranch); return error; } static int update_remote_head( git_repository *repo, git_remote *remote, - git_buf *target, + git_str *target, const char *reflog_message) { git_refspec *refspec; git_reference *remote_head = NULL; - git_buf remote_head_name = GIT_BUF_INIT; - git_buf remote_branch_name = GIT_BUF_INIT; + git_str remote_head_name = GIT_STR_INIT; + git_str remote_branch_name = GIT_STR_INIT; int error; /* Determine the remote tracking ref name from the local branch */ - refspec = git_remote__matching_refspec(remote, git_buf_cstr(target)); + refspec = git_remote__matching_refspec(remote, git_str_cstr(target)); if (refspec == NULL) { git_error_set(GIT_ERROR_NET, "the remote's default branch does not fit the refspec configuration"); @@ -183,13 +183,13 @@ static int update_remote_head( goto cleanup; } - if ((error = git_refspec_transform( + if ((error = git_refspec__transform( &remote_branch_name, refspec, - git_buf_cstr(target))) < 0) + git_str_cstr(target))) < 0) goto cleanup; - if ((error = git_buf_printf(&remote_head_name, + if ((error = git_str_printf(&remote_head_name, "%s%s/%s", GIT_REFS_REMOTES_DIR, git_remote_name(remote), @@ -199,15 +199,15 @@ static int update_remote_head( error = git_reference_symbolic_create( &remote_head, repo, - git_buf_cstr(&remote_head_name), - git_buf_cstr(&remote_branch_name), + git_str_cstr(&remote_head_name), + git_str_cstr(&remote_branch_name), true, reflog_message); cleanup: git_reference_free(remote_head); - git_buf_dispose(&remote_branch_name); - git_buf_dispose(&remote_head_name); + git_str_dispose(&remote_branch_name); + git_str_dispose(&remote_head_name); return error; } @@ -220,7 +220,7 @@ static int update_head_to_remote( size_t refs_len; const git_remote_head *remote_head, **refs; const git_oid *remote_head_id; - git_buf branch = GIT_BUF_INIT; + git_str branch = GIT_STR_INIT; if ((error = git_remote_ls(&refs, &refs_len, remote)) < 0) return error; @@ -235,7 +235,7 @@ static int update_head_to_remote( remote_head_id = &remote_head->oid; - error = git_remote_default_branch(&branch, remote); + error = git_remote__default_branch(&branch, remote); if (error == GIT_ENOTFOUND) { error = git_repository_set_head_detached( repo, remote_head_id); @@ -248,11 +248,11 @@ static int update_head_to_remote( error = update_head_to_new_branch( repo, remote_head_id, - git_buf_cstr(&branch), + git_str_cstr(&branch), reflog_message); cleanup: - git_buf_dispose(&branch); + git_str_dispose(&branch); return error; } @@ -264,36 +264,36 @@ static int update_head_to_branch( const char *reflog_message) { int retcode; - git_buf remote_branch_name = GIT_BUF_INIT; + git_str remote_branch_name = GIT_STR_INIT; git_reference *remote_ref = NULL; - git_buf default_branch = GIT_BUF_INIT; + git_str default_branch = GIT_STR_INIT; GIT_ASSERT_ARG(remote); GIT_ASSERT_ARG(branch); - if ((retcode = git_buf_printf(&remote_branch_name, GIT_REFS_REMOTES_DIR "%s/%s", + if ((retcode = git_str_printf(&remote_branch_name, GIT_REFS_REMOTES_DIR "%s/%s", git_remote_name(remote), branch)) < 0 ) goto cleanup; - if ((retcode = git_reference_lookup(&remote_ref, repo, git_buf_cstr(&remote_branch_name))) < 0) + if ((retcode = git_reference_lookup(&remote_ref, repo, git_str_cstr(&remote_branch_name))) < 0) goto cleanup; if ((retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch, reflog_message)) < 0) goto cleanup; - if ((retcode = git_remote_default_branch(&default_branch, remote)) < 0) + if ((retcode = git_remote__default_branch(&default_branch, remote)) < 0) goto cleanup; - if (!git_remote__matching_refspec(remote, git_buf_cstr(&default_branch))) + if (!git_remote__matching_refspec(remote, git_str_cstr(&default_branch))) goto cleanup; retcode = update_remote_head(repo, remote, &default_branch, reflog_message); cleanup: git_reference_free(remote_ref); - git_buf_dispose(&remote_branch_name); - git_buf_dispose(&default_branch); + git_str_dispose(&remote_branch_name); + git_str_dispose(&default_branch); return retcode; } @@ -392,7 +392,7 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) { int error; - git_buf reflog_message = GIT_BUF_INIT; + git_str reflog_message = GIT_STR_INIT; git_fetch_options fetch_opts; git_remote *remote; @@ -410,23 +410,23 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; - git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); - if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0) + if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0) goto cleanup; - error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message)); + error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message)); cleanup: git_remote_free(remote); - git_buf_dispose(&reflog_message); + git_str_dispose(&reflog_message); return error; } int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t local) { - git_buf fromurl = GIT_BUF_INIT; + git_str fromurl = GIT_STR_INIT; const char *path = url_or_path; bool is_url, is_local; @@ -446,7 +446,7 @@ int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t loc git_path_isdir(path); done: - git_buf_dispose(&fromurl); + git_str_dispose(&fromurl); return is_local; } @@ -586,8 +586,8 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_ { int error, flags; git_repository *src; - git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT; - git_buf reflog_message = GIT_BUF_INIT; + git_str src_odb = GIT_STR_INIT, dst_odb = GIT_STR_INIT, src_path = GIT_STR_INIT; + git_str reflog_message = GIT_STR_INIT; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(remote); @@ -606,13 +606,13 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_ return error; /* Copy .git/objects/ from the source to the target */ - if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) { - git_buf_dispose(&src_path); + if ((error = git_repository_open(&src, git_str_cstr(&src_path))) < 0) { + git_str_dispose(&src_path); return error; } - if (git_repository_item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 - || git_repository_item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) { + if (git_repository__item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 || + git_repository__item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) { error = -1; goto cleanup; } @@ -621,7 +621,7 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_ if (can_link(git_repository_path(src), git_repository_path(repo), link)) flags |= GIT_CPDIR_LINK_FILES; - error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb), + error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb), flags, GIT_OBJECT_DIR_MODE); /* @@ -631,25 +631,25 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_ */ if (error < 0 && link) { flags &= ~GIT_CPDIR_LINK_FILES; - error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb), + error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb), flags, GIT_OBJECT_DIR_MODE); } if (error < 0) goto cleanup; - git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); - if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_buf_cstr(&reflog_message))) != 0) + if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_str_cstr(&reflog_message))) != 0) goto cleanup; - error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message)); + error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message)); cleanup: - git_buf_dispose(&reflog_message); - git_buf_dispose(&src_path); - git_buf_dispose(&src_odb); - git_buf_dispose(&dst_odb); + git_str_dispose(&reflog_message); + git_str_dispose(&src_path); + git_str_dispose(&src_odb); + git_str_dispose(&dst_odb); git_repository_free(src); return error; } diff --git a/src/commit.c b/src/commit.c index 96259d5bb..752d98b02 100644 --- a/src/commit.c +++ b/src/commit.c @@ -14,10 +14,10 @@ #include "git2/mailmap.h" #include "git2/sys/commit.h" +#include "buf.h" #include "odb.h" #include "commit.h" #include "signature.h" -#include "message.h" #include "refs.h" #include "object.h" #include "array.h" @@ -42,7 +42,7 @@ void git_commit__free(void *_commit) } static int git_commit__create_buffer_internal( - git_buf *out, + git_str *out, const git_signature *author, const git_signature *committer, const char *message_encoding, @@ -67,17 +67,17 @@ static int git_commit__create_buffer_internal( git_signature__writebuf(out, "committer ", committer); if (message_encoding != NULL) - git_buf_printf(out, "encoding %s\n", message_encoding); + git_str_printf(out, "encoding %s\n", message_encoding); - git_buf_putc(out, '\n'); + git_str_putc(out, '\n'); - if (git_buf_puts(out, message) < 0) + if (git_str_puts(out, message) < 0) goto on_error; return 0; on_error: - git_buf_dispose(out); + git_str_dispose(out); return -1; } @@ -136,7 +136,7 @@ static int git_commit__create_internal( int error; git_odb *odb; git_reference *ref = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; const git_oid *current_id = NULL; git_array_oid_t parents = GIT_ARRAY_INIT; @@ -179,7 +179,7 @@ static int git_commit__create_internal( cleanup: git_array_clear(parents); git_reference_free(ref); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -545,7 +545,7 @@ const char *git_commit_message(const git_commit *commit) const char *git_commit_summary(git_commit *commit) { - git_buf summary = GIT_BUF_INIT; + git_str summary = GIT_STR_INIT; const char *msg, *space; bool space_contains_newline = false; @@ -570,17 +570,17 @@ const char *git_commit_summary(git_commit *commit) /* process any recorded whitespace */ if (space) { if(space_contains_newline) - git_buf_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */ + git_str_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */ else - git_buf_put(&summary, space, (msg - space)); /* otherwise copy it */ + git_str_put(&summary, space, (msg - space)); /* otherwise copy it */ space = NULL; } /* copy the next character */ - git_buf_putc(&summary, next_character); + git_str_putc(&summary, next_character); } } - commit->summary = git_buf_detach(&summary); + commit->summary = git_str_detach(&summary); if (!commit->summary) commit->summary = git__strdup(""); } @@ -678,11 +678,22 @@ int git_commit_nth_gen_ancestor( return 0; } -int git_commit_header_field(git_buf *out, const git_commit *commit, const char *field) +int git_commit_header_field( + git_buf *out, + const git_commit *commit, + const char *field) +{ + GIT_BUF_WRAP_PRIVATE(out, git_commit__header_field, commit, field); +} + +int git_commit__header_field( + git_str *out, + const git_commit *commit, + const char *field) { const char *eol, *buf = commit->raw_header; - git_buf_clear(out); + git_str_clear(out); while ((eol = strchr(buf, '\n'))) { /* We can skip continuations here */ @@ -706,22 +717,22 @@ int git_commit_header_field(git_buf *out, const git_commit *commit, const char * buf++; /* skip the SP */ - git_buf_put(out, buf, eol - buf); - if (git_buf_oom(out)) + git_str_put(out, buf, eol - buf); + if (git_str_oom(out)) goto oom; /* If the next line starts with SP, it's multi-line, we must continue */ while (eol[1] == ' ') { - git_buf_putc(out, '\n'); + git_str_putc(out, '\n'); buf = eol + 2; eol = strchr(buf, '\n'); if (!eol) goto malformed; - git_buf_put(out, buf, eol - buf); + git_str_put(out, buf, eol - buf); } - if (git_buf_oom(out)) + if (git_str_oom(out)) goto oom; return 0; @@ -738,7 +749,35 @@ oom: return -1; } -int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_repository *repo, git_oid *commit_id, const char *field) +int git_commit_extract_signature( + git_buf *signature_out, + git_buf *signed_data_out, + git_repository *repo, + git_oid *commit_id, + const char *field) +{ + git_str signature = GIT_STR_INIT, signed_data = GIT_STR_INIT; + int error; + + if ((error = git_buf_tostr(&signature, signature_out)) < 0 || + (error = git_buf_tostr(&signed_data, signed_data_out)) < 0 || + (error = git_commit__extract_signature(&signature, &signed_data, repo, commit_id, field)) < 0 || + (error = git_buf_fromstr(signature_out, &signature)) < 0 || + (error = git_buf_fromstr(signed_data_out, &signed_data)) < 0) + goto done; + +done: + git_str_dispose(&signature); + git_str_dispose(&signed_data); + return error; +} + +int git_commit__extract_signature( + git_str *signature, + git_str *signed_data, + git_repository *repo, + git_oid *commit_id, + const char *field) { git_odb_object *obj; git_odb *odb; @@ -746,8 +785,8 @@ int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_r const char *h, *eol; int error; - git_buf_clear(signature); - git_buf_clear(signed_data); + git_str_clear(signature); + git_str_clear(signed_data); if (!field) field = "gpgsig"; @@ -769,7 +808,7 @@ int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_r while ((h = strchr(buf, '\n')) && h[1] != '\0') { h++; if (git__prefixcmp(buf, field)) { - if (git_buf_put(signed_data, buf, h - buf) < 0) + if (git_str_put(signed_data, buf, h - buf) < 0) return -1; buf = h; @@ -788,25 +827,25 @@ int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_r h++; /* skip the SP */ - git_buf_put(signature, h, eol - h); - if (git_buf_oom(signature)) + git_str_put(signature, h, eol - h); + if (git_str_oom(signature)) goto oom; /* If the next line starts with SP, it's multi-line, we must continue */ while (eol[1] == ' ') { - git_buf_putc(signature, '\n'); + git_str_putc(signature, '\n'); h = eol + 2; eol = strchr(h, '\n'); if (!eol) goto malformed; - git_buf_put(signature, h, eol - h); + git_str_put(signature, h, eol - h); } - if (git_buf_oom(signature)) + if (git_str_oom(signature)) goto oom; - error = git_buf_puts(signed_data, eol+1); + error = git_str_puts(signed_data, eol+1); git_odb_object_free(obj); return error; } @@ -826,12 +865,29 @@ oom: cleanup: git_odb_object_free(obj); - git_buf_clear(signature); - git_buf_clear(signed_data); + git_str_clear(signature); + git_str_clear(signed_data); return error; } -int git_commit_create_buffer(git_buf *out, +int git_commit_create_buffer( + git_buf *out, + git_repository *repo, + const git_signature *author, + const git_signature *committer, + const char *message_encoding, + const char *message, + const git_tree *tree, + size_t parent_count, + const git_commit *parents[]) +{ + GIT_BUF_WRAP_PRIVATE(out, git_commit__create_buffer, repo, + author, committer, message_encoding, message, + tree, parent_count, parents); +} + +int git_commit__create_buffer( + git_str *out, git_repository *repo, const git_signature *author, const git_signature *committer, @@ -866,7 +922,7 @@ int git_commit_create_buffer(git_buf *out, /** * Append to 'out' properly marking continuations when there's a newline in 'content' */ -static int format_header_field(git_buf *out, const char *field, const char *content) +static int format_header_field(git_str *out, const char *field, const char *content) { const char *lf; @@ -874,19 +930,19 @@ static int format_header_field(git_buf *out, const char *field, const char *cont GIT_ASSERT_ARG(field); GIT_ASSERT_ARG(content); - git_buf_puts(out, field); - git_buf_putc(out, ' '); + git_str_puts(out, field); + git_str_putc(out, ' '); while ((lf = strchr(content, '\n')) != NULL) { - git_buf_put(out, content, lf - content); - git_buf_puts(out, "\n "); + git_str_put(out, content, lf - content); + git_str_puts(out, "\n "); content = lf + 1; } - git_buf_puts(out, content); - git_buf_putc(out, '\n'); + git_str_puts(out, content); + git_str_putc(out, '\n'); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } static const git_oid *commit_parent_from_commit(size_t n, void *payload) @@ -908,7 +964,7 @@ int git_commit_create_with_signature( int error = 0; const char *field; const char *header_end; - git_buf commit = GIT_BUF_INIT; + git_str commit = GIT_STR_INIT; git_commit *parsed; git_array_oid_t parents = GIT_ARRAY_INIT; @@ -933,7 +989,7 @@ int git_commit_create_with_signature( /* The header ends after the first LF */ header_end++; - git_buf_put(&commit, commit_content, header_end - commit_content); + git_str_put(&commit, commit_content, header_end - commit_content); if (signature != NULL) { field = signature_field ? signature_field : "gpgsig"; @@ -942,9 +998,9 @@ int git_commit_create_with_signature( goto cleanup; } - git_buf_puts(&commit, header_end); + git_str_puts(&commit, header_end); - if (git_buf_oom(&commit)) + if (git_str_oom(&commit)) return -1; if ((error = git_repository_odb__weakptr(&odb, repo)) < 0) @@ -955,7 +1011,7 @@ int git_commit_create_with_signature( cleanup: git_commit__free(parsed); - git_buf_dispose(&commit); + git_str_dispose(&commit); return error; } diff --git a/src/commit.h b/src/commit.h index 318ce5cba..9378eab2d 100644 --- a/src/commit.h +++ b/src/commit.h @@ -33,6 +33,29 @@ struct git_commit { char *body; }; +int git_commit__header_field( + git_str *out, + const git_commit *commit, + const char *field); + +int git_commit__extract_signature( + git_str *signature, + git_str *signed_data, + git_repository *repo, + git_oid *commit_id, + const char *field); + +int git_commit__create_buffer( + git_str *out, + git_repository *repo, + const git_signature *author, + const git_signature *committer, + const char *message_encoding, + const char *message, + const git_tree *tree, + size_t parent_count, + const git_commit *parents[]); + void git_commit__free(void *commit); int git_commit__parse(void *commit, git_odb_object *obj); int git_commit__parse_raw(void *commit, const char *data, size_t size); diff --git a/src/commit_graph.c b/src/commit_graph.c index df760b5f8..f9a4bd2b2 100644 --- a/src/commit_graph.c +++ b/src/commit_graph.c @@ -8,6 +8,7 @@ #include "commit_graph.h" #include "array.h" +#include "buf.h" #include "filebuf.h" #include "futils.h" #include "hash.h" @@ -308,12 +309,12 @@ int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, cgraph = git__calloc(1, sizeof(git_commit_graph)); GIT_ERROR_CHECK_ALLOC(cgraph); - error = git_buf_joinpath(&cgraph->filename, objects_dir, "info/commit-graph"); + error = git_str_joinpath(&cgraph->filename, objects_dir, "info/commit-graph"); if (error < 0) goto error; if (open_file) { - error = git_commit_graph_file_open(&cgraph->file, git_buf_cstr(&cgraph->filename)); + error = git_commit_graph_file_open(&cgraph->file, git_str_cstr(&cgraph->filename)); if (error < 0) goto error; cgraph->checked = 1; @@ -387,7 +388,7 @@ int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph cgraph->checked = 1; /* Best effort */ - error = git_commit_graph_file_open(&result, git_buf_cstr(&cgraph->filename)); + error = git_commit_graph_file_open(&result, git_str_cstr(&cgraph->filename)); if (error < 0) return error; @@ -407,7 +408,7 @@ void git_commit_graph_refresh(git_commit_graph *cgraph) return; if (cgraph->file - && git_commit_graph_file_needs_refresh(cgraph->file, git_buf_cstr(&cgraph->filename))) { + && git_commit_graph_file_needs_refresh(cgraph->file, git_str_cstr(&cgraph->filename))) { /* We just free the commit graph. The next time it is requested, it will be * re-loaded. */ git_commit_graph_file_free(cgraph->file); @@ -597,7 +598,7 @@ void git_commit_graph_free(git_commit_graph *cgraph) if (!cgraph) return; - git_buf_dispose(&cgraph->filename); + git_str_dispose(&cgraph->filename); git_commit_graph_file_free(cgraph->file); git__free(cgraph); } @@ -623,13 +624,13 @@ int git_commit_graph_writer_new(git_commit_graph_writer **out, const char *objec git_commit_graph_writer *w = git__calloc(1, sizeof(git_commit_graph_writer)); GIT_ERROR_CHECK_ALLOC(w); - if (git_buf_sets(&w->objects_info_dir, objects_info_dir) < 0) { + if (git_str_sets(&w->objects_info_dir, objects_info_dir) < 0) { git__free(w); return -1; } if (git_vector_init(&w->commits, 0, packed_commit__cmp) < 0) { - git_buf_dispose(&w->objects_info_dir); + git_str_dispose(&w->objects_info_dir); git__free(w); return -1; } @@ -649,7 +650,7 @@ void git_commit_graph_writer_free(git_commit_graph_writer *w) git_vector_foreach (&w->commits, i, packed_commit) packed_commit_free(packed_commit); git_vector_free(&w->commits); - git_buf_dispose(&w->objects_info_dir); + git_str_dispose(&w->objects_info_dir); git__free(w); } @@ -931,8 +932,8 @@ static int write_chunk_header( static int commit_graph_write_buf(const char *buf, size_t size, void *data) { - git_buf *b = (git_buf *)data; - return git_buf_put(b, buf, size); + git_str *b = (git_str *)data; + return git_str_put(b, buf, size); } struct commit_graph_write_hash_context { @@ -971,8 +972,8 @@ static int commit_graph_write( uint32_t extra_edge_list_count; uint32_t oid_fanout[256]; off64_t offset; - git_buf oid_lookup = GIT_BUF_INIT, commit_data = GIT_BUF_INIT, - extra_edge_list = GIT_BUF_INIT; + git_str oid_lookup = GIT_STR_INIT, commit_data = GIT_STR_INIT, + extra_edge_list = GIT_STR_INIT; git_oid cgraph_checksum = {{0}}; git_hash_ctx ctx; struct commit_graph_write_hash_context hash_cb_data = {0}; @@ -1011,7 +1012,7 @@ static int commit_graph_write( /* Fill the OID Lookup table. */ git_vector_foreach (&w->commits, i, packed_commit) { - error = git_buf_put(&oid_lookup, + error = git_str_put(&oid_lookup, (const char *)&packed_commit->sha1, sizeof(git_oid)); if (error < 0) goto cleanup; @@ -1026,7 +1027,7 @@ static int commit_graph_write( size_t *packed_index; unsigned int parentcount = (unsigned int)git_array_size(packed_commit->parents); - error = git_buf_put(&commit_data, + error = git_str_put(&commit_data, (const char *)&packed_commit->tree_oid, sizeof(git_oid)); if (error < 0) @@ -1038,7 +1039,7 @@ static int commit_graph_write( packed_index = git_array_get(packed_commit->parent_indices, 0); word = htonl((uint32_t)*packed_index); } - error = git_buf_put(&commit_data, (const char *)&word, sizeof(word)); + error = git_str_put(&commit_data, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; @@ -1050,7 +1051,7 @@ static int commit_graph_write( } else { word = htonl(0x80000000u | extra_edge_list_count); } - error = git_buf_put(&commit_data, (const char *)&word, sizeof(word)); + error = git_str_put(&commit_data, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; @@ -1061,7 +1062,7 @@ static int commit_graph_write( packed_commit->parent_indices, parent_i); word = htonl((uint32_t)(*packed_index | (parent_i + 1 == parentcount ? 0x80000000u : 0))); - error = git_buf_put(&extra_edge_list, + error = git_str_put(&extra_edge_list, (const char *)&word, sizeof(word)); if (error < 0) @@ -1075,18 +1076,18 @@ static int commit_graph_write( if (generation > GIT_COMMIT_GRAPH_GENERATION_NUMBER_MAX) generation = GIT_COMMIT_GRAPH_GENERATION_NUMBER_MAX; word = ntohl((uint32_t)((generation << 2) | ((commit_time >> 32ull) & 0x3ull))); - error = git_buf_put(&commit_data, (const char *)&word, sizeof(word)); + error = git_str_put(&commit_data, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; word = ntohl((uint32_t)(commit_time & 0xffffffffull)); - error = git_buf_put(&commit_data, (const char *)&word, sizeof(word)); + error = git_str_put(&commit_data, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; } /* Write the header. */ hdr.chunks = 3; - if (git_buf_len(&extra_edge_list) > 0) + if (git_str_len(&extra_edge_list) > 0) hdr.chunks++; error = write_cb((const char *)&hdr, sizeof(hdr), cb_data); if (error < 0) @@ -1101,17 +1102,17 @@ static int commit_graph_write( error = write_chunk_header(COMMIT_GRAPH_OID_LOOKUP_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&oid_lookup); + offset += git_str_len(&oid_lookup); error = write_chunk_header(COMMIT_GRAPH_COMMIT_DATA_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&commit_data); - if (git_buf_len(&extra_edge_list) > 0) { + offset += git_str_len(&commit_data); + if (git_str_len(&extra_edge_list) > 0) { error = write_chunk_header( COMMIT_GRAPH_EXTRA_EDGE_LIST_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&extra_edge_list); + offset += git_str_len(&extra_edge_list); } error = write_chunk_header(0, offset, write_cb, cb_data); if (error < 0) @@ -1121,13 +1122,13 @@ static int commit_graph_write( error = write_cb((const char *)oid_fanout, sizeof(oid_fanout), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&oid_lookup), git_buf_len(&oid_lookup), cb_data); + error = write_cb(git_str_cstr(&oid_lookup), git_str_len(&oid_lookup), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&commit_data), git_buf_len(&commit_data), cb_data); + error = write_cb(git_str_cstr(&commit_data), git_str_len(&commit_data), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&extra_edge_list), git_buf_len(&extra_edge_list), cb_data); + error = write_cb(git_str_cstr(&extra_edge_list), git_str_len(&extra_edge_list), cb_data); if (error < 0) goto cleanup; @@ -1140,9 +1141,9 @@ static int commit_graph_write( goto cleanup; cleanup: - git_buf_dispose(&oid_lookup); - git_buf_dispose(&commit_data); - git_buf_dispose(&extra_edge_list); + git_str_dispose(&oid_lookup); + git_str_dispose(&commit_data); + git_str_dispose(&extra_edge_list); git_hash_ctx_cleanup(&ctx); return error; } @@ -1171,21 +1172,21 @@ int git_commit_graph_writer_commit( { int error; int filebuf_flags = GIT_FILEBUF_DO_NOT_BUFFER; - git_buf commit_graph_path = GIT_BUF_INIT; + git_str commit_graph_path = GIT_STR_INIT; git_filebuf output = GIT_FILEBUF_INIT; /* TODO: support options and fill in defaults. */ GIT_UNUSED(opts); - error = git_buf_joinpath( - &commit_graph_path, git_buf_cstr(&w->objects_info_dir), "commit-graph"); + error = git_str_joinpath( + &commit_graph_path, git_str_cstr(&w->objects_info_dir), "commit-graph"); if (error < 0) return error; if (git_repository__fsync_gitdir) filebuf_flags |= GIT_FILEBUF_FSYNC; - error = git_filebuf_open(&output, git_buf_cstr(&commit_graph_path), filebuf_flags, 0644); - git_buf_dispose(&commit_graph_path); + error = git_filebuf_open(&output, git_str_cstr(&commit_graph_path), filebuf_flags, 0644); + git_str_dispose(&commit_graph_path); if (error < 0) return error; @@ -1199,9 +1200,17 @@ int git_commit_graph_writer_commit( } int git_commit_graph_writer_dump( - git_buf *cgraph, - git_commit_graph_writer *w, - git_commit_graph_writer_options *opts) + git_buf *cgraph, + git_commit_graph_writer *w, + git_commit_graph_writer_options *opts) +{ + GIT_BUF_WRAP_PRIVATE(cgraph, git_commit_graph__writer_dump, w, opts); +} + +int git_commit_graph__writer_dump( + git_str *cgraph, + git_commit_graph_writer *w, + git_commit_graph_writer_options *opts) { /* TODO: support options. */ GIT_UNUSED(opts); diff --git a/src/commit_graph.h b/src/commit_graph.h index 9d0a827de..4d2be431c 100644 --- a/src/commit_graph.h +++ b/src/commit_graph.h @@ -92,7 +92,7 @@ typedef struct git_commit_graph_entry { /* A wrapper for git_commit_graph_file to enable lazy loading in the ODB. */ struct git_commit_graph { /* The path to the commit-graph file. Something like ".git/objects/info/commit-graph". */ - git_buf filename; + git_str filename; /* The underlying commit-graph file. */ git_commit_graph_file *file; @@ -127,12 +127,17 @@ struct git_commit_graph_writer { * The path of the `objects/info` directory where the `commit-graph` will be * stored. */ - git_buf objects_info_dir; + git_str objects_info_dir; /* The list of packed commits. */ git_vector commits; }; +int git_commit_graph__writer_dump( + git_str *cgraph, + git_commit_graph_writer *w, + git_commit_graph_writer_options *opts); + /* * Returns whether the git_commit_graph_file needs to be reloaded since the * contents of the commit-graph file have changed on disk. diff --git a/src/common.h b/src/common.h index 9bb1116b5..640f94806 100644 --- a/src/common.h +++ b/src/common.h @@ -124,9 +124,9 @@ #define GIT_ERROR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; } /** - * Check a buffer allocation result, returning -1 if it failed. + * Check a string buffer allocation result, returning -1 if it failed. */ -#define GIT_ERROR_CHECK_ALLOC_BUF(buf) if ((void *)(buf) == NULL || git_buf_oom(buf)) { return -1; } +#define GIT_ERROR_CHECK_ALLOC_STR(buf) if ((void *)(buf) == NULL || git_str_oom(buf)) { return -1; } /** * Check a return value and propagate result if non-zero. @@ -202,6 +202,9 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v /* NOTE: other git_error functions are in the public errors.h header file */ +/* Forward declare git_str */ +typedef struct git_str git_str; + #include "util.h" #endif diff --git a/src/config.c b/src/config.c index 3251cd51f..9033a92c5 100644 --- a/src/config.c +++ b/src/config.c @@ -10,6 +10,7 @@ #include "git2/config.h" #include "git2/sys/config.h" +#include "buf.h" #include "config_backend.h" #include "regexp.h" #include "sysdir.h" @@ -848,7 +849,40 @@ static int is_readonly(const git_config *cfg) return 1; } -int git_config_get_path(git_buf *out, const git_config *cfg, const char *name) +static int git_config__parse_path(git_str *out, const char *value) +{ + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(value); + + if (value[0] == '~') { + if (value[1] != '\0' && value[1] != '/') { + git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported"); + return -1; + } + + return git_sysdir_expand_global_file(out, value[1] ? &value[2] : NULL); + } + + return git_str_sets(out, value); +} + +int git_config_parse_path(git_buf *out, const char *value) +{ + GIT_BUF_WRAP_PRIVATE(out, git_config__parse_path, value); +} + +int git_config_get_path( + git_buf *out, + const git_config *cfg, + const char *name) +{ + GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, cfg, name); +} + +int git_config__get_path( + git_str *out, + const git_config *cfg, + const char *name) { git_config_entry *entry; int error; @@ -856,7 +890,7 @@ int git_config_get_path(git_buf *out, const git_config *cfg, const char *name) if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0) return error; - error = git_config_parse_path(out, entry->value); + error = git_config__parse_path(out, entry->value); git_config_entry_free(entry); return error; @@ -884,18 +918,24 @@ int git_config_get_string( int git_config_get_string_buf( git_buf *out, const git_config *cfg, const char *name) { + GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, cfg, name); +} + +int git_config__get_string_buf( + git_str *out, const git_config *cfg, const char *name) +{ git_config_entry *entry; int ret; const char *str; - if ((ret = git_buf_sanitize(out)) < 0) - return ret; + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(cfg); ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS); str = !ret ? (entry->value ? entry->value : "") : NULL; if (str) - ret = git_buf_puts(out, str); + ret = git_str_puts(out, str); git_config_entry_free(entry); @@ -1087,101 +1127,112 @@ void git_config_iterator_free(git_config_iterator *iter) int git_config_find_global(git_buf *path) { - int error; - - if ((error = git_buf_sanitize(path)) < 0) - return error; + GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_GLOBAL); +} +int git_config__find_global(git_str *path) +{ return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL); } int git_config_find_xdg(git_buf *path) { - int error; - - if ((error = git_buf_sanitize(path)) < 0) - return error; + GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_XDG); +} +int git_config__find_xdg(git_str *path) +{ return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG); } int git_config_find_system(git_buf *path) { - int error; - - if ((error = git_buf_sanitize(path)) < 0) - return error; + GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_SYSTEM); +} +int git_config__find_system(git_str *path) +{ return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM); } int git_config_find_programdata(git_buf *path) { + git_str str = GIT_STR_INIT; + int error; + + if ((error = git_buf_tostr(&str, path)) == 0 && + (error = git_config__find_programdata(&str)) == 0) + error = git_buf_fromstr(path, &str); + + git_str_dispose(&str); + return error; +} + +int git_config__find_programdata(git_str *path) +{ int ret; - if ((ret = git_buf_sanitize(path)) < 0) - return ret; + ret = git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA); - ret = git_sysdir_find_programdata_file(path, - GIT_CONFIG_FILENAME_PROGRAMDATA); if (ret != GIT_OK) return ret; return git_path_validate_system_file_ownership(path->ptr); } -int git_config__global_location(git_buf *buf) +int git_config__global_location(git_str *buf) { - const git_buf *paths; + const git_str *paths; const char *sep, *start; if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0) return -1; /* no paths, so give up */ - if (!paths || !git_buf_len(paths)) + if (!paths || !git_str_len(paths)) return -1; /* find unescaped separator or end of string */ - for (sep = start = git_buf_cstr(paths); *sep; ++sep) { + for (sep = start = git_str_cstr(paths); *sep; ++sep) { if (*sep == GIT_PATH_LIST_SEPARATOR && (sep <= start || sep[-1] != '\\')) break; } - if (git_buf_set(buf, start, (size_t)(sep - start)) < 0) + if (git_str_set(buf, start, (size_t)(sep - start)) < 0) return -1; - return git_buf_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL); + return git_str_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL); } int git_config_open_default(git_config **out) { int error; git_config *cfg = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; if ((error = git_config_new(&cfg)) < 0) return error; - if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) { + if (!git_config__find_global(&buf) || + !git_config__global_location(&buf)) { error = git_config_add_file_ondisk(cfg, buf.ptr, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0); } - if (!error && !git_config_find_xdg(&buf)) + if (!error && !git_config__find_xdg(&buf)) error = git_config_add_file_ondisk(cfg, buf.ptr, GIT_CONFIG_LEVEL_XDG, NULL, 0); - if (!error && !git_config_find_system(&buf)) + if (!error && !git_config__find_system(&buf)) error = git_config_add_file_ondisk(cfg, buf.ptr, GIT_CONFIG_LEVEL_SYSTEM, NULL, 0); - if (!error && !git_config_find_programdata(&buf)) + if (!error && !git_config__find_programdata(&buf)) error = git_config_add_file_ondisk(cfg, buf.ptr, GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0); - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error) { git_config_free(cfg); @@ -1375,28 +1426,6 @@ fail_parse: return -1; } -int git_config_parse_path(git_buf *out, const char *value) -{ - int error; - - GIT_ASSERT_ARG(out); - GIT_ASSERT_ARG(value); - - if ((error = git_buf_sanitize(out)) < 0) - return error; - - if (value[0] == '~') { - if (value[1] != '\0' && value[1] != '/') { - git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported"); - return -1; - } - - return git_sysdir_expand_global_file(out, value[1] ? &value[2] : NULL); - } - - return git_buf_sets(out, value); -} - static int normalize_section(char *start, char *end) { char *scan; @@ -1459,7 +1488,7 @@ invalid: struct rename_data { git_config *config; - git_buf *name; + git_str *name; size_t old_len; }; @@ -1469,15 +1498,15 @@ static int rename_config_entries_cb( { int error = 0; struct rename_data *data = (struct rename_data *)payload; - size_t base_len = git_buf_len(data->name); + size_t base_len = git_str_len(data->name); if (base_len > 0 && - !(error = git_buf_puts(data->name, entry->name + data->old_len))) + !(error = git_str_puts(data->name, entry->name + data->old_len))) { error = git_config_set_string( - data->config, git_buf_cstr(data->name), entry->value); + data->config, git_str_cstr(data->name), entry->value); - git_buf_truncate(data->name, base_len); + git_str_truncate(data->name, base_len); } if (!error) @@ -1492,13 +1521,13 @@ int git_config_rename_section( const char *new_section_name) { git_config *config; - git_buf pattern = GIT_BUF_INIT, replace = GIT_BUF_INIT; + git_str pattern = GIT_STR_INIT, replace = GIT_STR_INIT; int error = 0; struct rename_data data; - git_buf_puts_escape_regex(&pattern, old_section_name); + git_str_puts_escape_regex(&pattern, old_section_name); - if ((error = git_buf_puts(&pattern, "\\..+")) < 0) + if ((error = git_str_puts(&pattern, "\\..+")) < 0) goto cleanup; if ((error = git_repository_config__weakptr(&config, repo)) < 0) @@ -1508,7 +1537,7 @@ int git_config_rename_section( data.name = &replace; data.old_len = strlen(old_section_name) + 1; - if ((error = git_buf_join(&replace, '.', new_section_name, "")) < 0) + if ((error = git_str_join(&replace, '.', new_section_name, "")) < 0) goto cleanup; if (new_section_name != NULL && @@ -1520,11 +1549,11 @@ int git_config_rename_section( } error = git_config_foreach_match( - config, git_buf_cstr(&pattern), rename_config_entries_cb, &data); + config, git_str_cstr(&pattern), rename_config_entries_cb, &data); cleanup: - git_buf_dispose(&pattern); - git_buf_dispose(&replace); + git_str_dispose(&pattern); + git_str_dispose(&replace); return error; } diff --git a/src/config.h b/src/config.h index a1d8f7d23..5dfc9da71 100644 --- a/src/config.h +++ b/src/config.h @@ -27,7 +27,12 @@ struct git_config { git_vector backends; }; -extern int git_config__global_location(git_buf *buf); +extern int git_config__global_location(git_str *buf); + +extern int git_config__find_global(git_str *path); +extern int git_config__find_xdg(git_str *path); +extern int git_config__find_system(git_str *path); +extern int git_config__find_programdata(git_str *path); extern int git_config_rename_section( git_repository *repo, @@ -51,6 +56,14 @@ extern int git_config__update_entry( bool overwrite_existing, bool only_if_existing); +int git_config__get_path( + git_str *out, + const git_config *cfg, + const char *name); + +int git_config__get_string_buf( + git_str *out, const git_config *cfg, const char *name); + /* * Lookup functions that cannot fail. These functions look up a config * value and return a fallback value if the value is missing or if any diff --git a/src/config_file.c b/src/config_file.c index 2f83a4070..9c3d2ceb8 100644 --- a/src/config_file.c +++ b/src/config_file.c @@ -11,7 +11,7 @@ #include "git2/sys/config.h" #include "array.h" -#include "buffer.h" +#include "str.h" #include "config_backend.h" #include "config_entries.h" #include "config_parse.h" @@ -41,7 +41,7 @@ typedef struct { bool locked; git_filebuf locked_buf; - git_buf locked_content; + git_str locked_content; config_file file; } config_file_backend; @@ -131,7 +131,7 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c static int config_file_is_modified(int *modified, config_file *file) { config_file *include; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_oid hash; uint32_t i; int error = 0; @@ -159,7 +159,7 @@ check_includes: } out: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -486,7 +486,7 @@ static int config_file_unlock(git_config_backend *_cfg, int success) } git_filebuf_cleanup(&cfg->locked_buf); - git_buf_dispose(&cfg->locked_content); + git_str_dispose(&cfg->locked_content); cfg->locked = false; return error; @@ -523,7 +523,7 @@ int git_config_backend_from_file(git_config_backend **out, const char *path) return 0; } -static int included_path(git_buf *out, const char *dir, const char *path) +static int included_path(git_str *out, const char *dir, const char *path) { /* From the user's home */ if (path[0] == '~' && path[1] == '/') @@ -535,7 +535,7 @@ static int included_path(git_buf *out, const char *dir, const char *path) /* Escape the values to write them to the file */ static char *escape_value(const char *ptr) { - git_buf buf; + git_str buf; size_t len; const char *esc; @@ -545,29 +545,29 @@ static char *escape_value(const char *ptr) if (!len) return git__calloc(1, sizeof(char)); - if (git_buf_init(&buf, len) < 0) + if (git_str_init(&buf, len) < 0) return NULL; while (*ptr != '\0') { if ((esc = strchr(git_config_escaped, *ptr)) != NULL) { - git_buf_putc(&buf, '\\'); - git_buf_putc(&buf, git_config_escapes[esc - git_config_escaped]); + git_str_putc(&buf, '\\'); + git_str_putc(&buf, git_config_escapes[esc - git_config_escaped]); } else { - git_buf_putc(&buf, *ptr); + git_str_putc(&buf, *ptr); } ptr++; } - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return NULL; - return git_buf_detach(&buf); + return git_str_detach(&buf); } static int parse_include(config_file_parse_data *parse_data, const char *file) { config_file *include; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; char *dir; int result; @@ -577,7 +577,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file) if ((result = git_path_dirname_r(&path, parse_data->file->path)) < 0) return result; - dir = git_buf_detach(&path); + dir = git_str_detach(&path); result = included_path(&path, dir, file); git__free(dir); @@ -588,7 +588,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file) GIT_ERROR_CHECK_ALLOC(include); memset(include, 0, sizeof(*include)); git_array_init(include->includes); - include->path = git_buf_detach(&path); + include->path = git_str_detach(&path); result = config_file_read(parse_data->entries, parse_data->repo, include, parse_data->level, parse_data->depth+1); @@ -608,38 +608,38 @@ static int do_match_gitdir( const char *condition, bool case_insensitive) { - git_buf pattern = GIT_BUF_INIT, gitdir = GIT_BUF_INIT; + git_str pattern = GIT_STR_INIT, gitdir = GIT_STR_INIT; int error; if (condition[0] == '.' && git_path_is_dirsep(condition[1])) { git_path_dirname_r(&pattern, cfg_file); - git_buf_joinpath(&pattern, pattern.ptr, condition + 2); + git_str_joinpath(&pattern, pattern.ptr, condition + 2); } else if (condition[0] == '~' && git_path_is_dirsep(condition[1])) git_sysdir_expand_global_file(&pattern, condition + 1); else if (!git_path_is_absolute(condition)) - git_buf_joinpath(&pattern, "**", condition); + git_str_joinpath(&pattern, "**", condition); else - git_buf_sets(&pattern, condition); + git_str_sets(&pattern, condition); if (git_path_is_dirsep(condition[strlen(condition) - 1])) - git_buf_puts(&pattern, "**"); + git_str_puts(&pattern, "**"); - if (git_buf_oom(&pattern)) { + if (git_str_oom(&pattern)) { error = -1; goto out; } - if ((error = git_repository_item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0) + if ((error = git_repository__item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0) goto out; if (git_path_is_dirsep(gitdir.ptr[gitdir.size - 1])) - git_buf_truncate(&gitdir, gitdir.size - 1); + git_str_truncate(&gitdir, gitdir.size - 1); *matches = wildmatch(pattern.ptr, gitdir.ptr, WM_PATHNAME | (case_insensitive ? WM_CASEFOLD : 0)) == WM_MATCH; out: - git_buf_dispose(&pattern); - git_buf_dispose(&gitdir); + git_str_dispose(&pattern); + git_str_dispose(&gitdir); return error; } @@ -667,7 +667,7 @@ static int conditional_match_onbranch( const char *cfg_file, const char *condition) { - git_buf reference = GIT_BUF_INIT, buf = GIT_BUF_INIT; + git_str reference = GIT_STR_INIT, buf = GIT_STR_INIT; int error; GIT_UNUSED(cfg_file); @@ -680,33 +680,33 @@ static int conditional_match_onbranch( * an endless recursion. */ - if ((error = git_buf_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 || + if ((error = git_str_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 || (error = git_futils_readbuffer(&reference, buf.ptr)) < 0) goto out; - git_buf_rtrim(&reference); + git_str_rtrim(&reference); if (git__strncmp(reference.ptr, GIT_SYMREF, strlen(GIT_SYMREF))) goto out; - git_buf_consume(&reference, reference.ptr + strlen(GIT_SYMREF)); + git_str_consume(&reference, reference.ptr + strlen(GIT_SYMREF)); if (git__strncmp(reference.ptr, GIT_REFS_HEADS_DIR, strlen(GIT_REFS_HEADS_DIR))) goto out; - git_buf_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR)); + git_str_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR)); /* * If the condition ends with a '/', then we should treat it as if * it had '**' appended. */ - if ((error = git_buf_sets(&buf, condition)) < 0) + if ((error = git_str_sets(&buf, condition)) < 0) goto out; if (git_path_is_dirsep(condition[strlen(condition) - 1]) && - (error = git_buf_puts(&buf, "**")) < 0) + (error = git_str_puts(&buf, "**")) < 0) goto out; *matches = wildmatch(buf.ptr, reference.ptr, WM_PATHNAME) == WM_MATCH; out: - git_buf_dispose(&reference); - git_buf_dispose(&buf); + git_str_dispose(&reference); + git_str_dispose(&buf); return error; @@ -763,7 +763,7 @@ static int read_on_variable( void *data) { config_file_parse_data *parse_data = (config_file_parse_data *)data; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_config_entry *entry; const char *c; int result = 0; @@ -777,19 +777,19 @@ static int read_on_variable( * here. Git appears to warn in most cases if it sees * un-namespaced config options. */ - git_buf_puts(&buf, current_section); - git_buf_putc(&buf, '.'); + git_str_puts(&buf, current_section); + git_str_putc(&buf, '.'); } for (c = var_name; *c; c++) - git_buf_putc(&buf, git__tolower(*c)); + git_str_putc(&buf, git__tolower(*c)); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; entry = git__calloc(1, sizeof(git_config_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_buf_detach(&buf); + entry->name = git_str_detach(&buf); entry->value = var_value ? git__strdup(var_value) : NULL; entry->level = parse_data->level; entry->include_depth = parse_data->depth; @@ -856,7 +856,7 @@ static int config_file_read( git_config_level_t level, int depth) { - git_buf contents = GIT_BUF_INIT; + git_str contents = GIT_STR_INIT; struct stat st; int error; @@ -877,36 +877,36 @@ static int config_file_read( goto out; out: - git_buf_dispose(&contents); + git_str_dispose(&contents); return error; } -static int write_section(git_buf *fbuf, const char *key) +static int write_section(git_str *fbuf, const char *key) { int result; const char *dot; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; /* All of this just for [section "subsection"] */ dot = strchr(key, '.'); - git_buf_putc(&buf, '['); + git_str_putc(&buf, '['); if (dot == NULL) { - git_buf_puts(&buf, key); + git_str_puts(&buf, key); } else { char *escaped; - git_buf_put(&buf, key, dot - key); + git_str_put(&buf, key, dot - key); escaped = escape_value(dot + 1); GIT_ERROR_CHECK_ALLOC(escaped); - git_buf_printf(&buf, " \"%s\"", escaped); + git_str_printf(&buf, " \"%s\"", escaped); git__free(escaped); } - git_buf_puts(&buf, "]\n"); + git_str_puts(&buf, "]\n"); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; - result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size); - git_buf_dispose(&buf); + result = git_str_put(fbuf, git_str_cstr(&buf), buf.size); + git_str_dispose(&buf); return result; } @@ -930,8 +930,8 @@ static const char *quotes_for_value(const char *value) } struct write_data { - git_buf *buf; - git_buf buffered_comment; + git_str *buf; + git_str buffered_comment; unsigned int in_section : 1, preg_replaced : 1; const char *orig_section; @@ -942,12 +942,12 @@ struct write_data { const char *value; }; -static int write_line_to(git_buf *buf, const char *line, size_t line_len) +static int write_line_to(git_str *buf, const char *line, size_t line_len) { - int result = git_buf_put(buf, line, line_len); + int result = git_str_put(buf, line, line_len); if (!result && line_len && line[line_len-1] != '\n') - result = git_buf_printf(buf, "\n"); + result = git_str_printf(buf, "\n"); return result; } @@ -963,7 +963,7 @@ static int write_value(struct write_data *write_data) int result; q = quotes_for_value(write_data->value); - result = git_buf_printf(write_data->buf, + result = git_str_printf(write_data->buf, "\t%s = %s%s%s\n", write_data->orig_name, q, write_data->value, q); /* If we are updating a single name/value, we're done. Setting `value` @@ -1002,8 +1002,8 @@ static int write_on_section( * If there were comments just before this section, dump them as well. */ if (!result) { - result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size); - git_buf_clear(&write_data->buffered_comment); + result = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size); + git_str_clear(&write_data->buffered_comment); } if (!result) @@ -1031,10 +1031,10 @@ static int write_on_variable( /* * If there were comments just before this variable, let's dump them as well. */ - if ((error = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0) + if ((error = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0) return error; - git_buf_clear(&write_data->buffered_comment); + git_str_clear(&write_data->buffered_comment); /* See if we are to update this name/value pair; first examine name */ if (write_data->in_section && @@ -1081,7 +1081,7 @@ static int write_on_eof( /* * If we've buffered comments when reaching EOF, make sure to dump them. */ - if ((result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0) + if ((result = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0) return result; /* If we are at the EOF and have not written our value (again, for a @@ -1108,7 +1108,7 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con { char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot; - git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT, contents = GIT_STR_INIT; git_config_parser parser = GIT_CONFIG_PARSER_INIT; git_filebuf file = GIT_FILEBUF_INIT; struct write_data write_data; @@ -1117,7 +1117,7 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con memset(&write_data, 0, sizeof(write_data)); if (cfg->locked) { - error = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content) == NULL ? "" : git_buf_cstr(&cfg->locked_content)); + error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content)); } else { if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, GIT_CONFIG_FILE_MODE)) < 0) @@ -1157,10 +1157,10 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con if (cfg->locked) { size_t len = buf.asize; /* Update our copy with the modified contents */ - git_buf_dispose(&cfg->locked_content); - git_buf_attach(&cfg->locked_content, git_buf_detach(&buf), len); + git_str_dispose(&cfg->locked_content); + git_str_attach(&cfg->locked_content, git_str_detach(&buf), len); } else { - git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf)); + git_filebuf_write(&file, git_str_cstr(&buf), git_str_len(&buf)); if ((error = git_filebuf_commit(&file)) < 0) goto done; @@ -1172,9 +1172,9 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con done: git__free(section); git__free(orig_section); - git_buf_dispose(&write_data.buffered_comment); - git_buf_dispose(&buf); - git_buf_dispose(&contents); + git_str_dispose(&write_data.buffered_comment); + git_str_dispose(&buf); + git_str_dispose(&contents); git_filebuf_cleanup(&file); git_config_parser_dispose(&parser); diff --git a/src/config_mem.c b/src/config_mem.c index 5b573a995..560229cf5 100644 --- a/src/config_mem.c +++ b/src/config_mem.c @@ -14,7 +14,7 @@ typedef struct { git_config_backend parent; git_config_entries *entries; - git_buf cfg; + git_str cfg; } config_memory_backend; typedef struct { @@ -38,7 +38,7 @@ static int read_variable_cb( void *payload) { config_memory_parse_data *parse_data = (config_memory_parse_data *) payload; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_config_entry *entry; const char *c; int result; @@ -52,19 +52,19 @@ static int read_variable_cb( * here. Git appears to warn in most cases if it sees * un-namespaced config options. */ - git_buf_puts(&buf, current_section); - git_buf_putc(&buf, '.'); + git_str_puts(&buf, current_section); + git_str_putc(&buf, '.'); } for (c = var_name; *c; c++) - git_buf_putc(&buf, git__tolower(*c)); + git_str_putc(&buf, git__tolower(*c)); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; entry = git__calloc(1, sizeof(git_config_entry)); GIT_ERROR_CHECK_ALLOC(entry); - entry->name = git_buf_detach(&buf); + entry->name = git_str_detach(&buf); entry->value = var_value ? git__strdup(var_value) : NULL; entry->level = parse_data->level; entry->include_depth = 0; @@ -178,7 +178,7 @@ static void config_memory_free(git_config_backend *_backend) return; git_config_entries_free(backend->entries); - git_buf_dispose(&backend->cfg); + git_str_dispose(&backend->cfg); git__free(backend); } @@ -194,7 +194,7 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si return -1; } - if (git_buf_set(&backend->cfg, cfg, len) < 0) { + if (git_str_set(&backend->cfg, cfg, len) < 0) { git_config_entries_free(backend->entries); git__free(backend); return -1; diff --git a/src/config_parse.c b/src/config_parse.c index 9f95e67d7..3159cbef7 100644 --- a/src/config_parse.c +++ b/src/config_parse.c @@ -67,7 +67,7 @@ static int parse_subsection_header(git_config_parser *reader, const char *line, int c, rpos; const char *first_quote, *last_quote; const char *line_start = line; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; size_t quoted_len, alloc_len, base_name_len = strlen(base_name); /* Skip any additional whitespace before our section name */ @@ -97,8 +97,8 @@ static int parse_subsection_header(git_config_parser *reader, const char *line, GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, base_name_len, quoted_len); GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2); - if (git_buf_grow(&buf, alloc_len) < 0 || - git_buf_printf(&buf, "%s.", base_name) < 0) + if (git_str_grow(&buf, alloc_len) < 0 || + git_str_printf(&buf, "%s.", base_name) < 0) goto end_error; rpos = 0; @@ -132,25 +132,25 @@ static int parse_subsection_header(git_config_parser *reader, const char *line, break; } - git_buf_putc(&buf, (char)c); + git_str_putc(&buf, (char)c); c = line[++rpos]; } while (line + rpos < last_quote); end_parse: - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) goto end_error; if (line[rpos] != '"' || line[rpos + 1] != ']') { set_parse_error(reader, rpos, "unexpected text after closing quotes"); - git_buf_dispose(&buf); + git_str_dispose(&buf); return -1; } - *section_name = git_buf_detach(&buf); + *section_name = git_str_detach(&buf); return (int)(&line[rpos + 2] - line_start); /* rpos is at the closing quote */ end_error: - git_buf_dispose(&buf); + git_str_dispose(&buf); return -1; } @@ -227,11 +227,11 @@ fail_parse: static int skip_bom(git_parse_ctx *parser) { - git_buf buf = GIT_BUF_INIT_CONST(parser->content, parser->content_len); - git_buf_bom_t bom; - int bom_offset = git_buf_detect_bom(&bom, &buf); + git_str buf = GIT_STR_INIT_CONST(parser->content, parser->content_len); + git_str_bom_t bom; + int bom_offset = git_str_detect_bom(&bom, &buf); - if (bom == GIT_BUF_BOM_UTF8) + if (bom == GIT_STR_BOM_UTF8) git_parse_advance_chars(parser, bom_offset); /* TODO: reference implementation is pretty stupid with BoM */ @@ -325,7 +325,7 @@ done: return 0; } -static int parse_multiline_variable(git_config_parser *reader, git_buf *value, int in_quotes) +static int parse_multiline_variable(git_config_parser *reader, git_str *value, int in_quotes) { int quote_count; bool multiline = true; @@ -358,7 +358,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_buf *value, i goto out; /* Add this line to the multiline var */ - if ((error = git_buf_puts(value, proc_line)) < 0) + if ((error = git_str_puts(value, proc_line)) < 0) goto out; next: @@ -445,18 +445,18 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var goto out; if (multiline) { - git_buf multi_value = GIT_BUF_INIT; - git_buf_attach(&multi_value, value, 0); + git_str multi_value = GIT_STR_INIT; + git_str_attach(&multi_value, value, 0); value = NULL; if (parse_multiline_variable(reader, &multi_value, quote_count % 2) < 0 || - git_buf_oom(&multi_value)) { + git_str_oom(&multi_value)) { error = -1; - git_buf_dispose(&multi_value); + git_str_dispose(&multi_value); goto out; } - value = git_buf_detach(&multi_value); + value = git_str_detach(&multi_value); } } diff --git a/src/crlf.c b/src/crlf.c index 406f7140f..7895ddec2 100644 --- a/src/crlf.c +++ b/src/crlf.c @@ -12,6 +12,7 @@ #include "git2/index.h" #include "git2/sys/filter.h" +#include "buf.h" #include "futils.h" #include "hash.h" #include "filter.h" @@ -152,7 +153,7 @@ static git_configmap_value output_eol(struct crlf_attrs *ca) GIT_INLINE(int) check_safecrlf( struct crlf_attrs *ca, const git_filter_source *src, - git_buf_text_stats *stats) + git_str_text_stats *stats) { const char *filename = git_filter_source_path(src); @@ -206,19 +207,19 @@ GIT_INLINE(int) check_safecrlf( static int crlf_apply_to_odb( struct crlf_attrs *ca, - git_buf *to, - const git_buf *from, + git_str *to, + const git_str *from, const git_filter_source *src) { - git_buf_text_stats stats; + git_str_text_stats stats; bool is_binary; int error; /* Binary attribute? Empty file? Nothing to do */ - if (ca->crlf_action == GIT_CRLF_BINARY || !git_buf_len(from)) + if (ca->crlf_action == GIT_CRLF_BINARY || from->size == 0) return GIT_PASSTHROUGH; - is_binary = git_buf_gather_text_stats(&stats, from, false); + is_binary = git_str_gather_text_stats(&stats, from, false); /* Heuristics to see if we can skip the conversion. * Straight from Core Git. @@ -246,22 +247,22 @@ static int crlf_apply_to_odb( return GIT_PASSTHROUGH; /* Actually drop the carriage returns */ - return git_buf_crlf_to_lf(to, from); + return git_str_crlf_to_lf(to, from); } static int crlf_apply_to_workdir( struct crlf_attrs *ca, - git_buf *to, - const git_buf *from) + git_str *to, + const git_str *from) { - git_buf_text_stats stats; + git_str_text_stats stats; bool is_binary; /* Empty file? Nothing to do. */ - if (git_buf_len(from) == 0 || output_eol(ca) != GIT_EOL_CRLF) + if (git_str_len(from) == 0 || output_eol(ca) != GIT_EOL_CRLF) return GIT_PASSTHROUGH; - is_binary = git_buf_gather_text_stats(&stats, from, false); + is_binary = git_str_gather_text_stats(&stats, from, false); /* If there are no LFs, or all LFs are part of a CRLF, nothing to do */ if (stats.lf == 0 || stats.lf == stats.crlf) @@ -280,7 +281,7 @@ static int crlf_apply_to_workdir( return GIT_PASSTHROUGH; } - return git_buf_lf_to_crlf(to, from); + return git_str_lf_to_crlf(to, from); } static int convert_attrs( @@ -368,22 +369,24 @@ static int crlf_check( static int crlf_apply( git_filter *self, void **payload, /* may be read and/or set */ - git_buf *to, - const git_buf *from, + git_str *to, + const git_str *from, const git_filter_source *src) { + int error = 0; + /* initialize payload in case `check` was bypassed */ if (!*payload) { - int error = crlf_check(self, payload, src, NULL); - - if (error < 0) + if ((error = crlf_check(self, payload, src, NULL)) < 0) return error; } if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE) - return crlf_apply_to_workdir(*payload, to, from); + error = crlf_apply_to_workdir(*payload, to, from); else - return crlf_apply_to_odb(*payload, to, from, src); + error = crlf_apply_to_odb(*payload, to, from, src); + + return error; } static int crlf_stream( diff --git a/src/describe.c b/src/describe.c index 103d0da5c..1033eac50 100644 --- a/src/describe.c +++ b/src/describe.c @@ -12,6 +12,7 @@ #include "git2/diff.h" #include "git2/status.h" +#include "buf.h" #include "commit.h" #include "commit_list.h" #include "oidmap.h" @@ -322,7 +323,7 @@ static unsigned long finish_depth_computation( return seen_commits; } -static int display_name(git_buf *buf, git_repository *repo, struct commit_name *n) +static int display_name(git_str *buf, git_repository *repo, struct commit_name *n) { if (n->prio == 2 && !n->tag) { if (git_tag_lookup(&n->tag, repo, &n->sha1) < 0) { @@ -346,9 +347,9 @@ static int display_name(git_buf *buf, git_repository *repo, struct commit_name * } if (n->tag) - git_buf_printf(buf, "%s", git_tag_name(n->tag)); + git_str_printf(buf, "%s", git_tag_name(n->tag)); else - git_buf_printf(buf, "%s", n->path); + git_str_printf(buf, "%s", n->path); return 0; } @@ -388,7 +389,7 @@ static int find_unique_abbrev_size( } static int show_suffix( - git_buf *buf, + git_str *buf, int depth, git_repository *repo, const git_oid *id, @@ -403,11 +404,11 @@ static int show_suffix( git_oid_fmt(hex_oid, id); - git_buf_printf(buf, "-%d-g", depth); + git_str_printf(buf, "-%d-g", depth); - git_buf_put(buf, hex_oid, size); + git_str_put(buf, hex_oid, size); - return git_buf_oom(buf) ? -1 : 0; + return git_str_oom(buf) ? -1 : 0; } #define MAX_CANDIDATES_TAGS FLAG_BITS - 1 @@ -769,7 +770,10 @@ static int normalize_format_options( return 0; } -int git_describe_format(git_buf *out, const git_describe_result *result, const git_describe_format_options *given) +static int git_describe__format( + git_str *out, + const git_describe_result *result, + const git_describe_format_options *given) { int error; git_repository *repo; @@ -782,10 +786,6 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g GIT_ERROR_CHECK_VERSION(given, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION, "git_describe_format_options"); normalize_format_options(&opts, given); - if ((error = git_buf_sanitize(out)) < 0) - return error; - - if (opts.always_use_long_format && opts.abbreviated_size == 0) { git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - " "'always_use_long_format' is incompatible with a zero" @@ -809,9 +809,9 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g } if (result->dirty && opts.dirty_suffix) - git_buf_puts(out, opts.dirty_suffix); + git_str_puts(out, opts.dirty_suffix); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } /* If we didn't find *any* tags, we fall back to the commit's id */ @@ -824,12 +824,12 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g return -1; git_oid_fmt(hex_oid, &result->commit_id); - git_buf_put(out, hex_oid, size); + git_str_put(out, hex_oid, size); if (result->dirty && opts.dirty_suffix) - git_buf_puts(out, opts.dirty_suffix); + git_str_puts(out, opts.dirty_suffix); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } /* Lastly, if we found a matching tag, we show that */ @@ -845,10 +845,18 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g } if (result->dirty && opts.dirty_suffix) { - git_buf_puts(out, opts.dirty_suffix); + git_str_puts(out, opts.dirty_suffix); } - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; +} + +int git_describe_format( + git_buf *out, + const git_describe_result *result, + const git_describe_format_options *given) +{ + GIT_BUF_WRAP_PRIVATE(out, git_describe__format, result, given); } void git_describe_result_free(git_describe_result *result) diff --git a/src/diff.c b/src/diff.c index 44b67ee06..9840d6050 100644 --- a/src/diff.c +++ b/src/diff.c @@ -8,6 +8,7 @@ #include "diff.h" #include "common.h" +#include "buf.h" #include "patch.h" #include "email.h" #include "commit.h" @@ -162,6 +163,7 @@ int git_diff_format_email( const git_diff_format_email_options *opts) { git_email_create_options email_create_opts = GIT_EMAIL_CREATE_OPTIONS_INIT; + git_str email = GIT_STR_INIT; int error; GIT_ASSERT_ARG(out); @@ -172,14 +174,29 @@ int git_diff_format_email( GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION, "git_format_email_options"); + /* This is a `git_buf` special case; subsequent calls append. */ + email.ptr = out->ptr; + email.asize = out->reserved; + email.size = out->size; + + out->ptr = git_str__initstr; + out->reserved = 0; + out->size = 0; + if ((opts->flags & GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER) != 0) email_create_opts.subject_prefix = ""; - - error = git_email__append_from_diff(out, diff, opts->patch_no, + error = git_email__append_from_diff(&email, diff, opts->patch_no, opts->total_patches, opts->id, opts->summary, opts->body, opts->author, &email_create_opts); + if (error < 0) + goto done; + + error = git_buf_fromstr(out, &email); + +done: + git_str_dispose(&email); return error; } @@ -282,7 +299,7 @@ static int flush_hunk(git_oid *result, git_hash_ctx *ctx) return 0; } -static void strip_spaces(git_buf *buf) +static void strip_spaces(git_str *buf) { char *src = buf->ptr, *dst = buf->ptr; char c; @@ -295,7 +312,7 @@ static void strip_spaces(git_buf *buf) } } - git_buf_truncate(buf, len); + git_str_truncate(buf, len); } static int diff_patchid_print_callback_to_buf( @@ -305,7 +322,7 @@ static int diff_patchid_print_callback_to_buf( void *payload) { struct patch_id_args *args = (struct patch_id_args *) payload; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error = 0; if (line->origin == GIT_DIFF_LINE_CONTEXT_EOFNL || @@ -331,7 +348,7 @@ static int diff_patchid_print_callback_to_buf( args->first_file = 0; out: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } diff --git a/src/diff.h b/src/diff.h index 69233b39f..4b0339809 100644 --- a/src/diff.h +++ b/src/diff.h @@ -14,9 +14,7 @@ #include "git2/sys/diff.h" #include "git2/oid.h" -#include <stdio.h> #include "vector.h" -#include "buffer.h" #include "iterator.h" #include "repository.h" #include "pool.h" @@ -53,7 +51,7 @@ struct git_diff { }; extern int git_diff_delta__format_file_header( - git_buf *out, + git_str *out, const git_diff_delta *delta, const char *oldpfx, const char *newpfx, diff --git a/src/diff_driver.c b/src/diff_driver.c index a3892d35e..f6b51d8ba 100644 --- a/src/diff_driver.c +++ b/src/diff_driver.c @@ -90,7 +90,7 @@ static int diff_driver_add_patterns( int error = 0; const char *scan, *end; git_diff_driver_pattern *pat = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; for (scan = regex_str; scan; scan = end) { /* get pattern to fill in */ @@ -105,10 +105,10 @@ static int diff_driver_add_patterns( } if ((end = strchr(scan, '\n')) != NULL) { - error = git_buf_set(&buf, scan, end - scan); + error = git_str_set(&buf, scan, end - scan); end++; } else { - error = git_buf_sets(&buf, scan); + error = git_str_sets(&buf, scan); } if (error < 0) break; @@ -122,7 +122,7 @@ static int diff_driver_add_patterns( if (error && pat != NULL) (void)git_array_pop(drv->fn_patterns); /* release last item */ - git_buf_dispose(&buf); + git_str_dispose(&buf); /* We want to ignore bad patterns, so return success regardless */ return 0; @@ -237,7 +237,7 @@ static int git_diff_driver_load( git_diff_driver *drv; size_t namelen; git_config *cfg = NULL; - git_buf name = GIT_BUF_INIT; + git_str name = GIT_STR_INIT; git_config_entry *ce = NULL; bool found_driver = false; @@ -260,7 +260,7 @@ static int git_diff_driver_load( goto done; } - if ((error = git_buf_printf(&name, "diff.%s.binary", driver_name)) < 0) + if ((error = git_str_printf(&name, "diff.%s.binary", driver_name)) < 0) goto done; switch (git_config__get_bool_force(cfg, name.ptr, -1)) { @@ -281,8 +281,8 @@ static int git_diff_driver_load( /* TODO: warn if diff.<name>.command or diff.<name>.textconv are set */ - git_buf_truncate(&name, namelen + strlen("diff..")); - if ((error = git_buf_PUTS(&name, "xfuncname")) < 0) + git_str_truncate(&name, namelen + strlen("diff..")); + if ((error = git_str_PUTS(&name, "xfuncname")) < 0) goto done; if ((error = git_config_get_multivar_foreach( @@ -292,8 +292,8 @@ static int git_diff_driver_load( git_error_clear(); /* no diff.<driver>.xfuncname, so just continue */ } - git_buf_truncate(&name, namelen + strlen("diff..")); - if ((error = git_buf_PUTS(&name, "funcname")) < 0) + git_str_truncate(&name, namelen + strlen("diff..")); + if ((error = git_str_PUTS(&name, "funcname")) < 0) goto done; if ((error = git_config_get_multivar_foreach( @@ -309,8 +309,8 @@ static int git_diff_driver_load( found_driver = true; } - git_buf_truncate(&name, namelen + strlen("diff..")); - if ((error = git_buf_PUTS(&name, "wordregex")) < 0) + git_str_truncate(&name, namelen + strlen("diff..")); + if ((error = git_str_PUTS(&name, "wordregex")) < 0) goto done; if ((error = git_config__lookup_entry(&ce, cfg, name.ptr, false)) < 0) @@ -340,7 +340,7 @@ static int git_diff_driver_load( done: git_config_entry_free(ce); - git_buf_dispose(&name); + git_str_dispose(&name); git_config_free(cfg); if (!*out) { @@ -420,11 +420,11 @@ void git_diff_driver_update_options( int git_diff_driver_content_is_binary( git_diff_driver *driver, const char *content, size_t content_len) { - git_buf search = GIT_BUF_INIT; + git_str search = GIT_STR_INIT; GIT_UNUSED(driver); - git_buf_attach_notowned(&search, content, + git_str_attach_notowned(&search, content, min(content_len, GIT_FILTER_BYTES_TO_CHECK_NUL)); /* TODO: provide encoding / binary detection callbacks that can @@ -432,15 +432,15 @@ int git_diff_driver_content_is_binary( * let's just use the simple NUL-byte detection that core git uses. */ - /* previously was: if (git_buf_is_binary(&search)) */ - if (git_buf_contains_nul(&search)) + /* previously was: if (git_str_is_binary(&search)) */ + if (git_str_contains_nul(&search)) return 1; return 0; } static int diff_context_line__simple( - git_diff_driver *driver, git_buf *line) + git_diff_driver *driver, git_str *line) { char firstch = line->ptr[0]; GIT_UNUSED(driver); @@ -448,7 +448,7 @@ static int diff_context_line__simple( } static int diff_context_line__pattern_match( - git_diff_driver *driver, git_buf *line) + git_diff_driver *driver, git_str *line) { size_t i, maxi = git_array_size(driver->fn_patterns); git_regmatch pmatch[2]; @@ -462,9 +462,9 @@ static int diff_context_line__pattern_match( /* use pmatch data to trim line data */ i = (pmatch[1].start >= 0) ? 1 : 0; - git_buf_consume(line, git_buf_cstr(line) + pmatch[i].start); - git_buf_truncate(line, pmatch[i].end - pmatch[i].start); - git_buf_rtrim(line); + git_str_consume(line, git_str_cstr(line) + pmatch[i].start); + git_str_truncate(line, pmatch[i].end - pmatch[i].start); + git_str_rtrim(line); return true; } @@ -482,9 +482,9 @@ static long diff_context_find( { git_diff_find_context_payload *ctxt = payload; - if (git_buf_set(&ctxt->line, line, (size_t)line_len) < 0) + if (git_str_set(&ctxt->line, line, (size_t)line_len) < 0) return -1; - git_buf_rtrim(&ctxt->line); + git_str_rtrim(&ctxt->line); if (!ctxt->line.size) return -1; @@ -511,14 +511,14 @@ void git_diff_find_context_init( payload_out->driver = driver; payload_out->match_line = (driver->type == DIFF_DRIVER_PATTERNLIST) ? diff_context_line__pattern_match : diff_context_line__simple; - git_buf_init(&payload_out->line, 0); + git_str_init(&payload_out->line, 0); } } void git_diff_find_context_clear(git_diff_find_context_payload *payload) { if (payload) { - git_buf_dispose(&payload->line); + git_str_dispose(&payload->line); payload->driver = NULL; } } diff --git a/src/diff_driver.h b/src/diff_driver.h index a03a67e67..03711e89e 100644 --- a/src/diff_driver.h +++ b/src/diff_driver.h @@ -10,7 +10,7 @@ #include "common.h" #include "attr_file.h" -#include "buffer.h" +#include "str.h" typedef struct git_diff_driver_registry git_diff_driver_registry; @@ -34,12 +34,12 @@ typedef long (*git_diff_find_context_fn)( const char *, long, char *, long, void *); typedef int (*git_diff_find_context_line)( - git_diff_driver *, git_buf *); + git_diff_driver *, git_str *); typedef struct { git_diff_driver *driver; git_diff_find_context_line match_line; - git_buf line; + git_str line; } git_diff_find_context_payload; void git_diff_find_context_init( diff --git a/src/diff_file.c b/src/diff_file.c index eeaf4a5a2..78e332f22 100644 --- a/src/diff_file.c +++ b/src/diff_file.c @@ -178,7 +178,7 @@ static int diff_file_content_commit_to_str( git_diff_file_content *fc, bool check_status) { char oid[GIT_OID_HEXSZ+1]; - git_buf content = GIT_BUF_INIT; + git_str content = GIT_STR_INIT; const char *status = ""; if (check_status) { @@ -217,11 +217,11 @@ static int diff_file_content_commit_to_str( } git_oid_tostr(oid, sizeof(oid), &fc->file->id); - if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0) + if (git_str_printf(&content, "Subproject commit %s%s\n", oid, status) < 0) return -1; - fc->map.len = git_buf_len(&content); - fc->map.data = git_buf_detach(&content); + fc->map.len = git_str_len(&content); + fc->map.data = git_str_detach(&content); fc->flags |= GIT_DIFF_FLAG__FREE_DATA; return 0; @@ -270,24 +270,24 @@ static int diff_file_content_load_blob( } static int diff_file_content_load_workdir_symlink_fake( - git_diff_file_content *fc, git_buf *path) + git_diff_file_content *fc, git_str *path) { - git_buf target = GIT_BUF_INIT; + git_str target = GIT_STR_INIT; int error; if ((error = git_futils_readbuffer(&target, path->ptr)) < 0) return error; - fc->map.len = git_buf_len(&target); - fc->map.data = git_buf_detach(&target); + fc->map.len = git_str_len(&target); + fc->map.data = git_str_detach(&target); fc->flags |= GIT_DIFF_FLAG__FREE_DATA; - git_buf_dispose(&target); + git_str_dispose(&target); return error; } static int diff_file_content_load_workdir_symlink( - git_diff_file_content *fc, git_buf *path) + git_diff_file_content *fc, git_str *path) { ssize_t alloc_len, read_len; int symlink_supported, error; @@ -309,7 +309,7 @@ static int diff_file_content_load_workdir_symlink( fc->flags |= GIT_DIFF_FLAG__FREE_DATA; - read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len); + read_len = p_readlink(git_str_cstr(path), fc->map.data, alloc_len); if (read_len < 0) { git_error_set(GIT_ERROR_OS, "failed to read symlink '%s'", fc->file->path); return -1; @@ -321,13 +321,13 @@ static int diff_file_content_load_workdir_symlink( static int diff_file_content_load_workdir_file( git_diff_file_content *fc, - git_buf *path, + git_str *path, git_diff_options *diff_opts) { int error = 0; git_filter_list *fl = NULL; - git_file fd = git_futils_open_ro(git_buf_cstr(path)); - git_buf raw = GIT_BUF_INIT; + git_file fd = git_futils_open_ro(git_str_cstr(path)); + git_str raw = GIT_STR_INIT; if (fd < 0) return fd; @@ -360,7 +360,7 @@ static int diff_file_content_load_workdir_file( } if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) { - git_buf out = GIT_BUF_INIT; + git_str out = GIT_STR_INIT; error = git_filter_list__convert_buf(&out, fl, &raw); @@ -383,7 +383,7 @@ static int diff_file_content_load_workdir( git_diff_options *diff_opts) { int error = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; if (fc->file->mode == GIT_FILEMODE_COMMIT) return diff_file_content_commit_to_str(fc, true); @@ -406,7 +406,7 @@ static int diff_file_content_load_workdir( fc->file->flags |= GIT_DIFF_FLAG_VALID_ID; } - git_buf_dispose(&path); + git_str_dispose(&path); return error; } diff --git a/src/diff_generate.c b/src/diff_generate.c index aba9e52ba..dc690aa9b 100644 --- a/src/diff_generate.c +++ b/src/diff_generate.c @@ -586,7 +586,7 @@ int git_diff__oid_for_entry( const git_oid *update_match) { git_diff_generated *diff; - git_buf full_path = GIT_BUF_INIT; + git_str full_path = GIT_STR_INIT; git_index_entry entry = *src; git_filter_list *fl = NULL; int error = 0; @@ -606,7 +606,7 @@ int git_diff__oid_for_entry( if (p_stat(full_path.ptr, &st) < 0) { error = git_path_set_error(errno, entry.path, "stat"); - git_buf_dispose(&full_path); + git_str_dispose(&full_path); return error; } @@ -669,7 +669,7 @@ int git_diff__oid_for_entry( } } - git_buf_dispose(&full_path); + git_str_dispose(&full_path); return error; } @@ -1023,7 +1023,7 @@ static int handle_unmatched_new_item( /* do not advance into directories that contain a .git file */ if (recurse_into_dir && !contains_oitem) { - git_buf *full = NULL; + git_str *full = NULL; if (git_iterator_current_workdir_path(&full, info->new_iter) < 0) return -1; if (full && git_path_contains(full, DOT_GIT)) { diff --git a/src/diff_print.c b/src/diff_print.c index 062e267b0..03d25b087 100644 --- a/src/diff_print.c +++ b/src/diff_print.c @@ -7,6 +7,7 @@ #include "common.h" +#include "buf.h" #include "diff.h" #include "diff_file.h" #include "patch_generate.h" @@ -21,7 +22,7 @@ typedef struct { git_diff_line_cb print_cb; void *payload; - git_buf *buf; + git_str *buf; git_diff_line line; const char *old_prefix; @@ -34,7 +35,7 @@ typedef struct { static int diff_print_info_init__common( diff_print_info *pi, - git_buf *out, + git_str *out, git_repository *repo, git_diff_format_t format, git_diff_line_cb cb, @@ -65,7 +66,7 @@ static int diff_print_info_init__common( static int diff_print_info_init_fromdiff( diff_print_info *pi, - git_buf *out, + git_str *out, git_diff *diff, git_diff_format_t format, git_diff_line_cb cb, @@ -89,7 +90,7 @@ static int diff_print_info_init_fromdiff( static int diff_print_info_init_frompatch( diff_print_info *pi, - git_buf *out, + git_str *out, git_patch *patch, git_diff_format_t format, git_diff_line_cb cb, @@ -142,7 +143,7 @@ static int diff_print_one_name_only( const git_diff_delta *delta, float progress, void *data) { diff_print_info *pi = data; - git_buf *out = pi->buf; + git_str *out = pi->buf; GIT_UNUSED(progress); @@ -150,15 +151,15 @@ static int diff_print_one_name_only( delta->status == GIT_DELTA_UNMODIFIED) return 0; - git_buf_clear(out); - git_buf_puts(out, delta->new_file.path); - git_buf_putc(out, '\n'); - if (git_buf_oom(out)) + git_str_clear(out); + git_str_puts(out, delta->new_file.path); + git_str_putc(out, '\n'); + if (git_str_oom(out)) return -1; pi->line.origin = GIT_DIFF_LINE_FILE_HDR; - pi->line.content = git_buf_cstr(out); - pi->line.content_len = git_buf_len(out); + pi->line.content = git_str_cstr(out); + pi->line.content_len = git_str_len(out); return pi->print_cb(delta, NULL, &pi->line, pi->payload); } @@ -167,7 +168,7 @@ static int diff_print_one_name_status( const git_diff_delta *delta, float progress, void *data) { diff_print_info *pi = data; - git_buf *out = pi->buf; + git_str *out = pi->buf; char old_suffix, new_suffix, code = git_diff_status_char(delta->status); int(*strcomp)(const char *, const char *) = pi->strcomp ? pi->strcomp : git__strcmp; @@ -180,26 +181,26 @@ static int diff_print_one_name_status( old_suffix = diff_pick_suffix(delta->old_file.mode); new_suffix = diff_pick_suffix(delta->new_file.mode); - git_buf_clear(out); + git_str_clear(out); if (delta->old_file.path != delta->new_file.path && strcomp(delta->old_file.path,delta->new_file.path) != 0) - git_buf_printf(out, "%c\t%s%c %s%c\n", code, + git_str_printf(out, "%c\t%s%c %s%c\n", code, delta->old_file.path, old_suffix, delta->new_file.path, new_suffix); else if (delta->old_file.mode != delta->new_file.mode && delta->old_file.mode != 0 && delta->new_file.mode != 0) - git_buf_printf(out, "%c\t%s%c %s%c\n", code, + git_str_printf(out, "%c\t%s%c %s%c\n", code, delta->old_file.path, old_suffix, delta->new_file.path, new_suffix); else if (old_suffix != ' ') - git_buf_printf(out, "%c\t%s%c\n", code, delta->old_file.path, old_suffix); + git_str_printf(out, "%c\t%s%c\n", code, delta->old_file.path, old_suffix); else - git_buf_printf(out, "%c\t%s\n", code, delta->old_file.path); - if (git_buf_oom(out)) + git_str_printf(out, "%c\t%s\n", code, delta->old_file.path); + if (git_str_oom(out)) return -1; pi->line.origin = GIT_DIFF_LINE_FILE_HDR; - pi->line.content = git_buf_cstr(out); - pi->line.content_len = git_buf_len(out); + pi->line.content = git_str_cstr(out); + pi->line.content_len = git_str_len(out); return pi->print_cb(delta, NULL, &pi->line, pi->payload); } @@ -208,7 +209,7 @@ static int diff_print_one_raw( const git_diff_delta *delta, float progress, void *data) { diff_print_info *pi = data; - git_buf *out = pi->buf; + git_str *out = pi->buf; int id_abbrev; char code = git_diff_status_char(delta->status); char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1]; @@ -218,7 +219,7 @@ static int diff_print_one_raw( if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ') return 0; - git_buf_clear(out); + git_str_clear(out); id_abbrev = delta->old_file.mode ? delta->old_file.id_abbrev : delta->new_file.id_abbrev; @@ -233,43 +234,43 @@ static int diff_print_one_raw( git_oid_tostr(start_oid, pi->id_strlen + 1, &delta->old_file.id); git_oid_tostr(end_oid, pi->id_strlen + 1, &delta->new_file.id); - git_buf_printf( + git_str_printf( out, (pi->id_strlen <= GIT_OID_HEXSZ) ? ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c", delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code); if (delta->similarity > 0) - git_buf_printf(out, "%03u", delta->similarity); + git_str_printf(out, "%03u", delta->similarity); if (delta->old_file.path != delta->new_file.path) - git_buf_printf( + git_str_printf( out, "\t%s %s\n", delta->old_file.path, delta->new_file.path); else - git_buf_printf( + git_str_printf( out, "\t%s\n", delta->old_file.path ? delta->old_file.path : delta->new_file.path); - if (git_buf_oom(out)) + if (git_str_oom(out)) return -1; pi->line.origin = GIT_DIFF_LINE_FILE_HDR; - pi->line.content = git_buf_cstr(out); - pi->line.content_len = git_buf_len(out); + pi->line.content = git_str_cstr(out); + pi->line.content_len = git_str_len(out); return pi->print_cb(delta, NULL, &pi->line, pi->payload); } static int diff_print_modes( - git_buf *out, const git_diff_delta *delta) + git_str *out, const git_diff_delta *delta) { - git_buf_printf(out, "old mode %o\n", delta->old_file.mode); - git_buf_printf(out, "new mode %o\n", delta->new_file.mode); + git_str_printf(out, "old mode %o\n", delta->old_file.mode); + git_str_printf(out, "new mode %o\n", delta->new_file.mode); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } static int diff_print_oid_range( - git_buf *out, const git_diff_delta *delta, int id_strlen, + git_str *out, const git_diff_delta *delta, int id_strlen, bool print_index) { char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1]; @@ -295,34 +296,34 @@ static int diff_print_oid_range( if (delta->old_file.mode == delta->new_file.mode) { if (print_index) - git_buf_printf(out, "index %s..%s %o\n", + git_str_printf(out, "index %s..%s %o\n", start_oid, end_oid, delta->old_file.mode); } else { if (delta->old_file.mode == 0) - git_buf_printf(out, "new file mode %o\n", delta->new_file.mode); + git_str_printf(out, "new file mode %o\n", delta->new_file.mode); else if (delta->new_file.mode == 0) - git_buf_printf(out, "deleted file mode %o\n", delta->old_file.mode); + git_str_printf(out, "deleted file mode %o\n", delta->old_file.mode); else diff_print_modes(out, delta); if (print_index) - git_buf_printf(out, "index %s..%s\n", start_oid, end_oid); + git_str_printf(out, "index %s..%s\n", start_oid, end_oid); } - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } static int diff_delta_format_path( - git_buf *out, const char *prefix, const char *filename) + git_str *out, const char *prefix, const char *filename) { - if (git_buf_joinpath(out, prefix, filename) < 0) + if (git_str_joinpath(out, prefix, filename) < 0) return -1; - return git_buf_quote(out); + return git_str_quote(out); } static int diff_delta_format_with_paths( - git_buf *out, + git_str *out, const git_diff_delta *delta, const char *template, const char *oldpath, @@ -334,14 +335,14 @@ static int diff_delta_format_with_paths( if (git_oid_is_zero(&delta->new_file.id)) newpath = "/dev/null"; - return git_buf_printf(out, template, oldpath, newpath); + return git_str_printf(out, template, oldpath, newpath); } static int diff_delta_format_similarity_header( - git_buf *out, + git_str *out, const git_diff_delta *delta) { - git_buf old_path = GIT_BUF_INIT, new_path = GIT_BUF_INIT; + git_str old_path = GIT_STR_INIT, new_path = GIT_STR_INIT; const char *type; int error = 0; @@ -357,13 +358,13 @@ static int diff_delta_format_similarity_header( else type = "copy"; - if ((error = git_buf_puts(&old_path, delta->old_file.path)) < 0 || - (error = git_buf_puts(&new_path, delta->new_file.path)) < 0 || - (error = git_buf_quote(&old_path)) < 0 || - (error = git_buf_quote(&new_path)) < 0) + if ((error = git_str_puts(&old_path, delta->old_file.path)) < 0 || + (error = git_str_puts(&new_path, delta->new_file.path)) < 0 || + (error = git_str_quote(&old_path)) < 0 || + (error = git_str_quote(&new_path)) < 0) goto done; - git_buf_printf(out, + git_str_printf(out, "similarity index %d%%\n" "%s from %s\n" "%s to %s\n", @@ -371,12 +372,12 @@ static int diff_delta_format_similarity_header( type, old_path.ptr, type, new_path.ptr); - if (git_buf_oom(out)) + if (git_str_oom(out)) error = -1; done: - git_buf_dispose(&old_path); - git_buf_dispose(&new_path); + git_str_dispose(&old_path); + git_str_dispose(&new_path); return error; } @@ -398,14 +399,14 @@ static bool delta_is_unchanged(const git_diff_delta *delta) } int git_diff_delta__format_file_header( - git_buf *out, + git_str *out, const git_diff_delta *delta, const char *oldpfx, const char *newpfx, int id_strlen, bool print_index) { - git_buf old_path = GIT_BUF_INIT, new_path = GIT_BUF_INIT; + git_str old_path = GIT_STR_INIT, new_path = GIT_STR_INIT; bool unchanged = delta_is_unchanged(delta); int error = 0; @@ -422,9 +423,9 @@ int git_diff_delta__format_file_header( &new_path, newpfx, delta->new_file.path)) < 0) goto done; - git_buf_clear(out); + git_str_clear(out); - git_buf_printf(out, "diff --git %s %s\n", + git_str_printf(out, "diff --git %s %s\n", old_path.ptr, new_path.ptr); if (unchanged && delta->old_file.mode != delta->new_file.mode) @@ -446,12 +447,12 @@ int git_diff_delta__format_file_header( "--- %s\n+++ %s\n", old_path.ptr, new_path.ptr); } - if (git_buf_oom(out)) + if (git_str_oom(out)) error = -1; done: - git_buf_dispose(&old_path); - git_buf_dispose(&new_path); + git_str_dispose(&old_path); + git_str_dispose(&new_path); return error; } @@ -467,7 +468,7 @@ static int format_binary( "delta" : "literal"; const char *scan, *end; - git_buf_printf(pi->buf, "%s %" PRIuZ "\n", typename, inflatedlen); + git_str_printf(pi->buf, "%s %" PRIuZ "\n", typename, inflatedlen); pi->line.num_lines++; for (scan = data, end = data + datalen; scan < end; ) { @@ -476,22 +477,22 @@ static int format_binary( chunk_len = 52; if (chunk_len <= 26) - git_buf_putc(pi->buf, (char)chunk_len + 'A' - 1); + git_str_putc(pi->buf, (char)chunk_len + 'A' - 1); else - git_buf_putc(pi->buf, (char)chunk_len - 26 + 'a' - 1); + git_str_putc(pi->buf, (char)chunk_len - 26 + 'a' - 1); - git_buf_encode_base85(pi->buf, scan, chunk_len); - git_buf_putc(pi->buf, '\n'); + git_str_encode_base85(pi->buf, scan, chunk_len); + git_str_putc(pi->buf, '\n'); - if (git_buf_oom(pi->buf)) + if (git_str_oom(pi->buf)) return -1; scan += chunk_len; pi->line.num_lines++; } - git_buf_putc(pi->buf, '\n'); + git_str_putc(pi->buf, '\n'); - if (git_buf_oom(pi->buf)) + if (git_str_oom(pi->buf)) return -1; return 0; @@ -501,7 +502,7 @@ static int diff_print_patch_file_binary_noshow( diff_print_info *pi, git_diff_delta *delta, const char *old_pfx, const char *new_pfx) { - git_buf old_path = GIT_BUF_INIT, new_path = GIT_BUF_INIT; + git_str old_path = GIT_STR_INIT, new_path = GIT_STR_INIT; int error; if ((error = diff_delta_format_path(&old_path, old_pfx, delta->old_file.path)) < 0 || @@ -513,8 +514,8 @@ static int diff_print_patch_file_binary_noshow( pi->line.num_lines = 1; done: - git_buf_dispose(&old_path); - git_buf_dispose(&new_path); + git_str_dispose(&old_path); + git_str_dispose(&new_path); return error; } @@ -534,7 +535,7 @@ static int diff_print_patch_file_binary( pi, delta, old_pfx, new_pfx); pre_binary_size = pi->buf->size; - git_buf_printf(pi->buf, "GIT binary patch\n"); + git_str_printf(pi->buf, "GIT binary patch\n"); pi->line.num_lines++; if ((error = format_binary(pi, binary->new_file.type, binary->new_file.data, @@ -543,7 +544,7 @@ static int diff_print_patch_file_binary( binary->old_file.datalen, binary->old_file.inflatedlen)) < 0) { if (error == GIT_EBUFS) { git_error_clear(); - git_buf_truncate(pi->buf, pre_binary_size); + git_str_truncate(pi->buf, pre_binary_size); return diff_print_patch_file_binary_noshow( pi, delta, old_pfx, new_pfx); @@ -589,8 +590,8 @@ static int diff_print_patch_file( return error; pi->line.origin = GIT_DIFF_LINE_FILE_HDR; - pi->line.content = git_buf_cstr(pi->buf); - pi->line.content_len = git_buf_len(pi->buf); + pi->line.content = git_str_cstr(pi->buf); + pi->line.content_len = git_str_len(pi->buf); return pi->print_cb(delta, NULL, &pi->line, pi->payload); } @@ -607,15 +608,15 @@ static int diff_print_patch_binary( pi->new_prefix ? pi->new_prefix : DIFF_NEW_PREFIX_DEFAULT; int error; - git_buf_clear(pi->buf); + git_str_clear(pi->buf); if ((error = diff_print_patch_file_binary( pi, (git_diff_delta *)delta, old_pfx, new_pfx, binary)) < 0) return error; pi->line.origin = GIT_DIFF_LINE_BINARY; - pi->line.content = git_buf_cstr(pi->buf); - pi->line.content_len = git_buf_len(pi->buf); + pi->line.content = git_str_cstr(pi->buf); + pi->line.content_len = git_str_len(pi->buf); return pi->print_cb(delta, NULL, &pi->line, pi->payload); } @@ -659,7 +660,7 @@ int git_diff_print( void *payload) { int error; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; diff_print_info pi; git_diff_file_cb print_file = NULL; git_diff_binary_cb print_binary = NULL; @@ -704,7 +705,7 @@ int git_diff_print( } out: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -714,7 +715,7 @@ int git_diff_print_callback__to_buf( const git_diff_line *line, void *payload) { - git_buf *output = payload; + git_str *output = payload; GIT_UNUSED(delta); GIT_UNUSED(hunk); if (!output) { @@ -725,9 +726,9 @@ int git_diff_print_callback__to_buf( if (line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION || line->origin == GIT_DIFF_LINE_CONTEXT) - git_buf_putc(output, line->origin); + git_str_putc(output, line->origin); - return git_buf_put(output, line->content, line->content_len); + return git_str_put(output, line->content, line->content_len); } int git_diff_print_callback__to_file_handle( @@ -761,18 +762,24 @@ int git_diff_print_callback__to_file_handle( return 0; } -/* print a git_diff to a git_buf */ +/* print a git_diff to a git_str */ int git_diff_to_buf(git_buf *out, git_diff *diff, git_diff_format_t format) { + git_str str = GIT_STR_INIT; int error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(diff); - if ((error = git_buf_sanitize(out)) < 0) - return error; + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_diff_print(diff, format, git_diff_print_callback__to_buf, &str)) < 0) + goto done; + + error = git_buf_fromstr(out, &str); - return git_diff_print(diff, format, git_diff_print_callback__to_buf, out); +done: + git_str_dispose(&str); + return error; } /* print a git_patch to an output callback */ @@ -781,7 +788,7 @@ int git_patch_print( git_diff_line_cb print_cb, void *payload) { - git_buf temp = GIT_BUF_INIT; + git_str temp = GIT_STR_INIT; diff_print_info pi; int error; @@ -799,20 +806,20 @@ int git_patch_print( } out: - git_buf_dispose(&temp); + git_str_dispose(&temp); return error; } -/* print a git_patch to a git_buf */ +/* print a git_patch to a git_str */ int git_patch_to_buf(git_buf *out, git_patch *patch) { - int error; + GIT_BUF_WRAP_PRIVATE(out, git_patch__to_buf, patch); +} +int git_patch__to_buf(git_str *out, git_patch *patch) +{ GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(patch); - if ((error = git_buf_sanitize(out)) < 0) - return error; - return git_patch_print(patch, git_diff_print_callback__to_buf, out); } diff --git a/src/diff_stats.c b/src/diff_stats.c index 41a25bf8a..228f6f892 100644 --- a/src/diff_stats.c +++ b/src/diff_stats.c @@ -5,8 +5,10 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "common.h" +#include "diff_stats.h" +#include "buf.h" +#include "common.h" #include "vector.h" #include "diff.h" #include "patch_generate.h" @@ -47,7 +49,7 @@ static int digits_for_value(size_t val) } static int diff_file_stats_full_to_buf( - git_buf *out, + git_str *out, const git_diff_delta *delta, const diff_file_stats *filestat, const git_diff_stats *stats, @@ -70,12 +72,12 @@ static int diff_file_stats_full_to_buf( if ((common_dirlen = git_path_common_dirlen(old_path, new_path)) && common_dirlen <= INT_MAX) { - error = git_buf_printf(out, " %.*s{%s"DIFF_RENAME_FILE_SEPARATOR"%s}", + error = git_str_printf(out, " %.*s{%s"DIFF_RENAME_FILE_SEPARATOR"%s}", (int) common_dirlen, old_path, old_path + common_dirlen, new_path + common_dirlen); } else { - error = git_buf_printf(out, " %s" DIFF_RENAME_FILE_SEPARATOR "%s", + error = git_str_printf(out, " %s" DIFF_RENAME_FILE_SEPARATOR "%s", old_path, new_path); } @@ -83,7 +85,7 @@ static int diff_file_stats_full_to_buf( goto on_error; } else { adddel_path = new_path ? new_path : old_path; - if (git_buf_printf(out, " %s", adddel_path) < 0) + if (git_str_printf(out, " %s", adddel_path) < 0) goto on_error; padding = stats->max_name - strlen(adddel_path); @@ -92,28 +94,28 @@ static int diff_file_stats_full_to_buf( padding += strlen(DIFF_RENAME_FILE_SEPARATOR); } - if (git_buf_putcn(out, ' ', padding) < 0 || - git_buf_puts(out, " | ") < 0) + if (git_str_putcn(out, ' ', padding) < 0 || + git_str_puts(out, " | ") < 0) goto on_error; if (delta->flags & GIT_DIFF_FLAG_BINARY) { - if (git_buf_printf(out, + if (git_str_printf(out, "Bin %" PRId64 " -> %" PRId64 " bytes", old_size, new_size) < 0) goto on_error; } else { - if (git_buf_printf(out, + if (git_str_printf(out, "%*" PRIuZ, stats->max_digits, filestat->insertions + filestat->deletions) < 0) goto on_error; if (filestat->insertions || filestat->deletions) { - if (git_buf_putc(out, ' ') < 0) + if (git_str_putc(out, ' ') < 0) goto on_error; if (!width) { - if (git_buf_putcn(out, '+', filestat->insertions) < 0 || - git_buf_putcn(out, '-', filestat->deletions) < 0) + if (git_str_putcn(out, '+', filestat->insertions) < 0 || + git_str_putcn(out, '-', filestat->deletions) < 0) goto on_error; } else { size_t total = filestat->insertions + filestat->deletions; @@ -122,21 +124,21 @@ static int diff_file_stats_full_to_buf( size_t plus = full * filestat->insertions / total; size_t minus = full - plus; - if (git_buf_putcn(out, '+', max(plus, 1)) < 0 || - git_buf_putcn(out, '-', max(minus, 1)) < 0) + if (git_str_putcn(out, '+', max(plus, 1)) < 0 || + git_str_putcn(out, '-', max(minus, 1)) < 0) goto on_error; } } } - git_buf_putc(out, '\n'); + git_str_putc(out, '\n'); on_error: - return (git_buf_oom(out) ? -1 : 0); + return (git_str_oom(out) ? -1 : 0); } static int diff_file_stats_number_to_buf( - git_buf *out, + git_str *out, const git_diff_delta *delta, const diff_file_stats *filestats) { @@ -144,29 +146,29 @@ static int diff_file_stats_number_to_buf( const char *path = delta->new_file.path; if (delta->flags & GIT_DIFF_FLAG_BINARY) - error = git_buf_printf(out, "%-8c" "%-8c" "%s\n", '-', '-', path); + error = git_str_printf(out, "%-8c" "%-8c" "%s\n", '-', '-', path); else - error = git_buf_printf(out, "%-8" PRIuZ "%-8" PRIuZ "%s\n", + error = git_str_printf(out, "%-8" PRIuZ "%-8" PRIuZ "%s\n", filestats->insertions, filestats->deletions, path); return error; } static int diff_file_stats_summary_to_buf( - git_buf *out, + git_str *out, const git_diff_delta *delta) { if (delta->old_file.mode != delta->new_file.mode) { if (delta->old_file.mode == 0) { - git_buf_printf(out, " create mode %06o %s\n", + git_str_printf(out, " create mode %06o %s\n", delta->new_file.mode, delta->new_file.path); } else if (delta->new_file.mode == 0) { - git_buf_printf(out, " delete mode %06o %s\n", + git_str_printf(out, " delete mode %06o %s\n", delta->old_file.mode, delta->old_file.path); } else { - git_buf_printf(out, " mode change %06o => %06o %s\n", + git_str_printf(out, " mode change %06o => %06o %s\n", delta->old_file.mode, delta->new_file.mode, delta->new_file.path); } } @@ -279,6 +281,15 @@ int git_diff_stats_to_buf( git_diff_stats_format_t format, size_t width) { + GIT_BUF_WRAP_PRIVATE(out, git_diff__stats_to_buf, stats, format, width); +} + +int git_diff__stats_to_buf( + git_str *out, + const git_diff_stats *stats, + git_diff_stats_format_t format, + size_t width) +{ int error = 0; size_t i; const git_diff_delta *delta; @@ -320,23 +331,23 @@ int git_diff_stats_to_buf( } if (format & GIT_DIFF_STATS_FULL || format & GIT_DIFF_STATS_SHORT) { - git_buf_printf( + git_str_printf( out, " %" PRIuZ " file%s changed", stats->files_changed, stats->files_changed != 1 ? "s" : ""); if (stats->insertions || stats->deletions == 0) - git_buf_printf( + git_str_printf( out, ", %" PRIuZ " insertion%s(+)", stats->insertions, stats->insertions != 1 ? "s" : ""); if (stats->deletions || stats->insertions == 0) - git_buf_printf( + git_str_printf( out, ", %" PRIuZ " deletion%s(-)", stats->deletions, stats->deletions != 1 ? "s" : ""); - git_buf_putc(out, '\n'); + git_str_putc(out, '\n'); - if (git_buf_oom(out)) + if (git_str_oom(out)) return -1; } diff --git a/src/message.h b/src/diff_stats.h index 251727b22..c71862b4e 100644 --- a/src/message.h +++ b/src/diff_stats.h @@ -4,14 +4,15 @@ * 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_message_h__ -#define INCLUDE_message_h__ +#ifndef INCLUDE_diff_stats_h__ +#define INCLUDE_diff_stats_h__ #include "common.h" -#include "git2/message.h" -#include "buffer.h" - -int git_message__prettify(git_buf *message_out, const char *message, int strip_comments); +int git_diff__stats_to_buf( + git_str *out, + const git_diff_stats *stats, + git_diff_stats_format_t format, + size_t width); #endif diff --git a/src/diff_tform.c b/src/diff_tform.c index 597e64e45..be55de6c3 100644 --- a/src/diff_tform.c +++ b/src/diff_tform.c @@ -444,7 +444,7 @@ typedef struct { git_iterator_t src; git_repository *repo; git_diff_file *file; - git_buf data; + git_str data; git_odb_object *odb_obj; git_blob *blob; } similarity_info; @@ -458,7 +458,7 @@ static int similarity_init( info->file = similarity_get_file(diff, file_idx); info->odb_obj = NULL; info->blob = NULL; - git_buf_init(&info->data, 0); + git_str_init(&info->data, 0); if (info->file->size > 0 || info->src == GIT_ITERATOR_WORKDIR) return 0; @@ -529,7 +529,7 @@ static void similarity_unload(similarity_info *info) if (info->blob) git_blob_free(info->blob); else - git_buf_dispose(&info->data); + git_str_dispose(&info->data); } #define FLAG_SET(opts,flag_name) (((opts)->flags & flag_name) != 0) diff --git a/src/email.c b/src/email.c index df63b6ec3..3459c0540 100644 --- a/src/email.c +++ b/src/email.c @@ -7,9 +7,11 @@ #include "email.h" -#include "buffer.h" #include "common.h" +#include "buf.h" #include "diff_generate.h" +#include "diff_stats.h" +#include "patch.h" #include "git2/email.h" #include "git2/patch.h" @@ -32,7 +34,7 @@ GIT_INLINE(int) include_prefix( } static int append_prefix( - git_buf *out, + git_str *out, size_t patch_idx, size_t patch_count, git_email_create_options *opts) @@ -40,16 +42,16 @@ static int append_prefix( const char *subject_prefix = opts->subject_prefix ? opts->subject_prefix : "PATCH"; - git_buf_putc(out, '['); + git_str_putc(out, '['); if (*subject_prefix) - git_buf_puts(out, subject_prefix); + git_str_puts(out, subject_prefix); if (opts->reroll_number) { if (*subject_prefix) - git_buf_putc(out, ' '); + git_str_putc(out, ' '); - git_buf_printf(out, "v%" PRIuZ, opts->reroll_number); + git_str_printf(out, "v%" PRIuZ, opts->reroll_number); } if ((opts->flags & GIT_EMAIL_CREATE_ALWAYS_NUMBER) != 0 || @@ -58,20 +60,20 @@ static int append_prefix( opts->start_number : 1; if (*subject_prefix || opts->reroll_number) - git_buf_putc(out, ' '); + git_str_putc(out, ' '); - git_buf_printf(out, "%" PRIuZ "/%" PRIuZ, + git_str_printf(out, "%" PRIuZ "/%" PRIuZ, patch_idx + (start_number - 1), patch_count + (start_number - 1)); } - git_buf_puts(out, "]"); + git_str_puts(out, "]"); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } static int append_subject( - git_buf *out, + git_str *out, size_t patch_idx, size_t patch_count, const char *summary, @@ -88,25 +90,25 @@ static int append_subject( summary_len = (nl - summary); } - if ((error = git_buf_puts(out, "Subject: ")) < 0) + if ((error = git_str_puts(out, "Subject: ")) < 0) return error; if (prefix && (error = append_prefix(out, patch_idx, patch_count, opts)) < 0) return error; - if (prefix && summary_len && (error = git_buf_putc(out, ' ')) < 0) + if (prefix && summary_len && (error = git_str_putc(out, ' ')) < 0) return error; if (summary_len && - (error = git_buf_put(out, summary, summary_len)) < 0) + (error = git_str_put(out, summary, summary_len)) < 0) return error; - return git_buf_putc(out, '\n'); + return git_str_putc(out, '\n'); } static int append_header( - git_buf *out, + git_str *out, size_t patch_idx, size_t patch_count, const git_oid *commit_id, @@ -119,20 +121,20 @@ static int append_header( int error; if ((error = git_oid_fmt(id, commit_id)) < 0 || - (error = git_buf_printf(out, "From %.*s %s\n", GIT_OID_HEXSZ, id, EMAIL_TIMESTAMP)) < 0 || - (error = git_buf_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 || + (error = git_str_printf(out, "From %.*s %s\n", GIT_OID_HEXSZ, id, EMAIL_TIMESTAMP)) < 0 || + (error = git_str_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 || (error = git__date_rfc2822_fmt(date, sizeof(date), &author->when)) < 0 || - (error = git_buf_printf(out, "Date: %s\n", date)) < 0 || + (error = git_str_printf(out, "Date: %s\n", date)) < 0 || (error = append_subject(out, patch_idx, patch_count, summary, opts)) < 0) return error; - if ((error = git_buf_putc(out, '\n')) < 0) + if ((error = git_str_putc(out, '\n')) < 0) return error; return 0; } -static int append_body(git_buf *out, const char *body) +static int append_body(git_str *out, const char *body) { size_t body_len; int error; @@ -142,16 +144,16 @@ static int append_body(git_buf *out, const char *body) body_len = strlen(body); - if ((error = git_buf_puts(out, body)) < 0) + if ((error = git_str_puts(out, body)) < 0) return error; if (body_len && body[body_len - 1] != '\n') - error = git_buf_putc(out, '\n'); + error = git_str_putc(out, '\n'); return error; } -static int append_diffstat(git_buf *out, git_diff *diff) +static int append_diffstat(git_str *out, git_diff *diff) { git_diff_stats *stats = NULL; unsigned int format_flags; @@ -160,14 +162,14 @@ static int append_diffstat(git_buf *out, git_diff *diff) format_flags = GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY; if ((error = git_diff_get_stats(&stats, diff)) == 0 && - (error = git_diff_stats_to_buf(out, stats, format_flags, 0)) == 0) - error = git_buf_putc(out, '\n'); + (error = git_diff__stats_to_buf(out, stats, format_flags, 0)) == 0) + error = git_str_putc(out, '\n'); git_diff_stats_free(stats); return error; } -static int append_patches(git_buf *out, git_diff *diff) +static int append_patches(git_str *out, git_diff *diff) { size_t i, deltas; int error = 0; @@ -178,7 +180,7 @@ static int append_patches(git_buf *out, git_diff *diff) git_patch *patch = NULL; if ((error = git_patch_from_diff(&patch, diff, i)) >= 0) - error = git_patch_to_buf(out, patch); + error = git_patch__to_buf(out, patch); git_patch_free(patch); @@ -190,7 +192,7 @@ static int append_patches(git_buf *out, git_diff *diff) } int git_email__append_from_diff( - git_buf *out, + git_str *out, git_diff *diff, size_t patch_idx, size_t patch_count, @@ -216,14 +218,12 @@ int git_email__append_from_diff( if (given_opts) memcpy(&opts, given_opts, sizeof(git_email_create_options)); - git_buf_sanitize(out); - if ((error = append_header(out, patch_idx, patch_count, commit_id, summary, author, &opts)) == 0 && (error = append_body(out, body)) == 0 && - (error = git_buf_puts(out, "---\n")) == 0 && + (error = git_str_puts(out, "---\n")) == 0 && (error = append_diffstat(out, diff)) == 0 && (error = append_patches(out, diff)) == 0) - error = git_buf_puts(out, "--\nlibgit2 " LIBGIT2_VERSION "\n\n"); + error = git_str_puts(out, "--\nlibgit2 " LIBGIT2_VERSION "\n\n"); return error; } @@ -239,15 +239,19 @@ int git_email_create_from_diff( const git_signature *author, const git_email_create_options *given_opts) { + git_str email = GIT_STR_INIT; int error; - git_buf_sanitize(out); - git_buf_clear(out); + git_buf_tostr(&email, out); - error = git_email__append_from_diff(out, diff, patch_idx, + error = git_email__append_from_diff(&email, diff, patch_idx, patch_count, commit_id, summary, body, author, given_opts); + if (error == 0) + error = git_buf_fromstr(out, &email); + + git_str_dispose(&email); return error; } diff --git a/src/email.h b/src/email.h index 7aeb462ab..083e56d5c 100644 --- a/src/email.h +++ b/src/email.h @@ -12,7 +12,7 @@ #include "git2/email.h" extern int git_email__append_from_diff( - git_buf *out, + git_str *out, git_diff *diff, size_t patch_idx, size_t patch_count, diff --git a/src/errors.c b/src/errors.c index ce883b2da..3614b9ce5 100644 --- a/src/errors.c +++ b/src/errors.c @@ -9,7 +9,7 @@ #include "threadstate.h" #include "posix.h" -#include "buffer.h" +#include "str.h" #include "libgit2.h" /******************************************** @@ -29,7 +29,7 @@ static git_error g_git_uninitialized_error = { static void set_error_from_buffer(int error_class) { git_error *error = &GIT_THREADSTATE->error_t; - git_buf *buf = &GIT_THREADSTATE->error_buf; + git_str *buf = &GIT_THREADSTATE->error_buf; error->message = buf->ptr; error->klass = error_class; @@ -39,11 +39,11 @@ static void set_error_from_buffer(int error_class) static void set_error(int error_class, char *string) { - git_buf *buf = &GIT_THREADSTATE->error_buf; + git_str *buf = &GIT_THREADSTATE->error_buf; - git_buf_clear(buf); + git_str_clear(buf); if (string) { - git_buf_puts(buf, string); + git_str_puts(buf, string); git__free(string); } @@ -70,20 +70,20 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0; #endif int error_code = (error_class == GIT_ERROR_OS) ? errno : 0; - git_buf *buf = &GIT_THREADSTATE->error_buf; + git_str *buf = &GIT_THREADSTATE->error_buf; - git_buf_clear(buf); + git_str_clear(buf); if (fmt) { - git_buf_vprintf(buf, fmt, ap); + git_str_vprintf(buf, fmt, ap); if (error_class == GIT_ERROR_OS) - git_buf_PUTS(buf, ": "); + git_str_PUTS(buf, ": "); } if (error_class == GIT_ERROR_OS) { #ifdef GIT_WIN32 char * win32_error = git_win32_get_error_message(win32_error_code); if (win32_error) { - git_buf_puts(buf, win32_error); + git_str_puts(buf, win32_error); git__free(win32_error); SetLastError(0); @@ -91,26 +91,26 @@ void git_error_vset(int error_class, const char *fmt, va_list ap) else #endif if (error_code) - git_buf_puts(buf, strerror(error_code)); + git_str_puts(buf, strerror(error_code)); if (error_code) errno = 0; } - if (!git_buf_oom(buf)) + if (!git_str_oom(buf)) set_error_from_buffer(error_class); } int git_error_set_str(int error_class, const char *string) { - git_buf *buf = &GIT_THREADSTATE->error_buf; + git_str *buf = &GIT_THREADSTATE->error_buf; GIT_ASSERT_ARG(string); - git_buf_clear(buf); - git_buf_puts(buf, string); + git_str_clear(buf); + git_str_puts(buf, string); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) return -1; set_error_from_buffer(error_class); @@ -142,7 +142,7 @@ const git_error *git_error_last(void) int git_error_state_capture(git_error_state *state, int error_code) { git_error *error = GIT_THREADSTATE->last_error; - git_buf *error_buf = &GIT_THREADSTATE->error_buf; + git_str *error_buf = &GIT_THREADSTATE->error_buf; memset(state, 0, sizeof(git_error_state)); @@ -158,7 +158,7 @@ int git_error_state_capture(git_error_state *state, int error_code) if (state->oom) state->error_msg.message = g_git_oom_error.message; else - state->error_msg.message = git_buf_detach(error_buf); + state->error_msg.message = git_str_detach(error_buf); } git_error_clear(); diff --git a/src/fetchhead.c b/src/fetchhead.c index 88c567e48..6511124ef 100644 --- a/src/fetchhead.c +++ b/src/fetchhead.c @@ -10,7 +10,7 @@ #include "git2/types.h" #include "git2/oid.h" -#include "buffer.h" +#include "str.h" #include "futils.h" #include "filebuf.h" #include "refs.h" @@ -44,7 +44,7 @@ static char *sanitized_remote_url(const char *remote_url) int error; if (git_net_url_parse(&url, remote_url) == 0) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git__free(url.username); git__free(url.password); @@ -53,7 +53,7 @@ static char *sanitized_remote_url(const char *remote_url) if ((error = git_net_url_fmt(&buf, &url)) < 0) goto fallback; - sanitized = git_buf_detach(&buf); + sanitized = git_str_detach(&buf); } fallback: @@ -143,22 +143,22 @@ static int fetchhead_ref_write( int git_fetchhead_write(git_repository *repo, git_vector *fetchhead_refs) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; unsigned int i; git_fetchhead_ref *fetchhead_ref; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(fetchhead_refs); - if (git_buf_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0) + if (git_str_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0) return -1; if (git_filebuf_open(&file, path.ptr, GIT_FILEBUF_APPEND, GIT_REFS_FILE_MODE) < 0) { - git_buf_dispose(&path); + git_str_dispose(&path); return -1; } - git_buf_dispose(&path); + git_str_dispose(&path); git_vector_sort(fetchhead_refs); @@ -171,7 +171,7 @@ int git_fetchhead_write(git_repository *repo, git_vector *fetchhead_refs) static int fetchhead_ref_parse( git_oid *oid, unsigned int *is_merge, - git_buf *ref_name, + git_str *ref_name, const char **remote_url, char *line, size_t line_num) @@ -259,12 +259,12 @@ static int fetchhead_ref_parse( *remote_url = desc; } - git_buf_clear(ref_name); + git_str_clear(ref_name); if (type) - git_buf_join(ref_name, '/', type, name); + git_str_join(ref_name, '/', type, name); else if(name) - git_buf_puts(ref_name, name); + git_str_puts(ref_name, name); return error; } @@ -273,7 +273,7 @@ int git_repository_fetchhead_foreach(git_repository *repo, git_repository_fetchhead_foreach_cb cb, void *payload) { - git_buf path = GIT_BUF_INIT, file = GIT_BUF_INIT, name = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, file = GIT_STR_INIT, name = GIT_STR_INIT; const char *ref_name; git_oid oid; const char *remote_url; @@ -285,10 +285,10 @@ int git_repository_fetchhead_foreach(git_repository *repo, GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(cb); - if (git_buf_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0) + if (git_str_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0) return -1; - if ((error = git_futils_readbuffer(&file, git_buf_cstr(&path))) < 0) + if ((error = git_futils_readbuffer(&file, git_str_cstr(&path))) < 0) goto done; buffer = file.ptr; @@ -300,8 +300,8 @@ int git_repository_fetchhead_foreach(git_repository *repo, &oid, &is_merge, &name, &remote_url, line, line_num)) < 0) goto done; - if (git_buf_len(&name) > 0) - ref_name = git_buf_cstr(&name); + if (git_str_len(&name) > 0) + ref_name = git_str_cstr(&name); else ref_name = NULL; @@ -319,9 +319,9 @@ int git_repository_fetchhead_foreach(git_repository *repo, } done: - git_buf_dispose(&file); - git_buf_dispose(&path); - git_buf_dispose(&name); + git_str_dispose(&file); + git_str_dispose(&path); + git_str_dispose(&name); return error; } diff --git a/src/filebuf.c b/src/filebuf.c index 4296b2226..10f8c5813 100644 --- a/src/filebuf.c +++ b/src/filebuf.c @@ -195,21 +195,21 @@ static int write_deflate(git_filebuf *file, void *source, size_t len) #define MAX_SYMLINK_DEPTH 5 -static int resolve_symlink(git_buf *out, const char *path) +static int resolve_symlink(git_str *out, const char *path) { int i, error, root; ssize_t ret; struct stat st; - git_buf curpath = GIT_BUF_INIT, target = GIT_BUF_INIT; + git_str curpath = GIT_STR_INIT, target = GIT_STR_INIT; - if ((error = git_buf_grow(&target, GIT_PATH_MAX + 1)) < 0 || - (error = git_buf_puts(&curpath, path)) < 0) + if ((error = git_str_grow(&target, GIT_PATH_MAX + 1)) < 0 || + (error = git_str_puts(&curpath, path)) < 0) return error; for (i = 0; i < MAX_SYMLINK_DEPTH; i++) { error = p_lstat(curpath.ptr, &st); if (error < 0 && errno == ENOENT) { - error = git_buf_puts(out, curpath.ptr); + error = git_str_puts(out, curpath.ptr); goto cleanup; } @@ -220,7 +220,7 @@ static int resolve_symlink(git_buf *out, const char *path) } if (!S_ISLNK(st.st_mode)) { - error = git_buf_puts(out, curpath.ptr); + error = git_str_puts(out, curpath.ptr); goto cleanup; } @@ -243,16 +243,16 @@ static int resolve_symlink(git_buf *out, const char *path) root = git_path_root(target.ptr); if (root >= 0) { - if ((error = git_buf_sets(&curpath, target.ptr)) < 0) + if ((error = git_str_sets(&curpath, target.ptr)) < 0) goto cleanup; } else { - git_buf dir = GIT_BUF_INIT; + git_str dir = GIT_STR_INIT; if ((error = git_path_dirname_r(&dir, curpath.ptr)) < 0) goto cleanup; - git_buf_swap(&curpath, &dir); - git_buf_dispose(&dir); + git_str_swap(&curpath, &dir); + git_str_dispose(&dir); if ((error = git_path_apply_relative(&curpath, target.ptr)) < 0) goto cleanup; @@ -263,8 +263,8 @@ static int resolve_symlink(git_buf *out, const char *path) error = -1; cleanup: - git_buf_dispose(&curpath); - git_buf_dispose(&target); + git_str_dispose(&curpath); + git_str_dispose(&target); return error; } @@ -332,13 +332,13 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo /* If we are writing to a temp file */ if (flags & GIT_FILEBUF_TEMPORARY) { - git_buf tmp_path = GIT_BUF_INIT; + git_str tmp_path = GIT_STR_INIT; /* Open the file as temporary for locking */ file->fd = git_futils_mktmp(&tmp_path, path, mode); if (file->fd < 0) { - git_buf_dispose(&tmp_path); + git_str_dispose(&tmp_path); goto cleanup; } file->fd_is_open = true; @@ -346,17 +346,17 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo /* No original path */ file->path_original = NULL; - file->path_lock = git_buf_detach(&tmp_path); + file->path_lock = git_str_detach(&tmp_path); GIT_ERROR_CHECK_ALLOC(file->path_lock); } else { - git_buf resolved_path = GIT_BUF_INIT; + git_str resolved_path = GIT_STR_INIT; if ((error = resolve_symlink(&resolved_path, path)) < 0) goto cleanup; /* Save the original path of the file */ path_len = resolved_path.size; - file->path_original = git_buf_detach(&resolved_path); + file->path_original = git_str_detach(&resolved_path); /* create the locking path by appending ".lock" to the original */ GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH); diff --git a/src/filter.c b/src/filter.c index 73497cb30..417d9cb8b 100644 --- a/src/filter.c +++ b/src/filter.c @@ -7,6 +7,7 @@ #include "filter.h" +#include "buf.h" #include "common.h" #include "futils.h" #include "hash.h" @@ -36,7 +37,7 @@ typedef struct { struct git_filter_list { git_array_t(git_filter_entry) filters; git_filter_source source; - git_buf *temp_buf; + git_str *temp_buf; char path[GIT_FLEX_ARRAY]; }; @@ -68,7 +69,7 @@ static void git_filter_global_shutdown(void); static int filter_def_scan_attrs( - git_buf *attrs, size_t *nattr, size_t *nmatch, const char *attr_str) + git_str *attrs, size_t *nattr, size_t *nmatch, const char *attr_str) { const char *start, *scan = attr_str; int has_eq; @@ -92,9 +93,9 @@ static int filter_def_scan_attrs( (*nmatch)++; if (has_eq) - git_buf_putc(attrs, '='); - git_buf_put(attrs, start, scan - start); - git_buf_putc(attrs, '\0'); + git_str_putc(attrs, '='); + git_str_put(attrs, start, scan - start); + git_str_putc(attrs, '\0'); } } @@ -152,7 +153,7 @@ static int filter_registry_insert( { git_filter_def *fdef; size_t nattr = 0, nmatch = 0, alloc_len; - git_buf attrs = GIT_BUF_INIT; + git_str attrs = GIT_STR_INIT; if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0) return -1; @@ -171,7 +172,7 @@ static int filter_registry_insert( fdef->priority = priority; fdef->nattrs = nattr; fdef->nmatches = nmatch; - fdef->attrdata = git_buf_detach(&attrs); + fdef->attrdata = git_str_detach(&attrs); filter_def_set_attrs(fdef); @@ -710,7 +711,7 @@ size_t git_filter_list_length(const git_filter_list *fl) struct buf_stream { git_writestream parent; - git_buf *target; + git_str *target; bool complete; }; @@ -721,7 +722,7 @@ static int buf_stream_write( GIT_ASSERT_ARG(buf_stream); GIT_ASSERT(buf_stream->complete == 0); - return git_buf_put(buf_stream->target, buffer, len); + return git_str_put(buf_stream->target, buffer, len); } static int buf_stream_close(git_writestream *s) @@ -740,7 +741,7 @@ static void buf_stream_free(git_writestream *s) GIT_UNUSED(s); } -static void buf_stream_init(struct buf_stream *writer, git_buf *target) +static void buf_stream_init(struct buf_stream *writer, git_str *target) { memset(writer, 0, sizeof(struct buf_stream)); @@ -749,7 +750,7 @@ static void buf_stream_init(struct buf_stream *writer, git_buf *target) writer->parent.free = buf_stream_free; writer->target = target; - git_buf_clear(target); + git_str_clear(target); } int git_filter_list_apply_to_buffer( @@ -758,12 +759,18 @@ int git_filter_list_apply_to_buffer( const char *in, size_t in_len) { + GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_buffer, filters, in, in_len); +} + +int git_filter_list__apply_to_buffer( + git_str *out, + git_filter_list *filters, + const char *in, + size_t in_len) +{ struct buf_stream writer; int error; - if ((error = git_buf_sanitize(out)) < 0) - return error; - buf_stream_init(&writer, out); if ((error = git_filter_list_stream_buffer(filters, @@ -775,23 +782,23 @@ int git_filter_list_apply_to_buffer( } int git_filter_list__convert_buf( - git_buf *out, + git_str *out, git_filter_list *filters, - git_buf *in) + git_str *in) { int error; if (!filters || git_filter_list_length(filters) == 0) { - git_buf_swap(out, in); - git_buf_dispose(in); + git_str_swap(out, in); + git_str_dispose(in); return 0; } - error = git_filter_list_apply_to_buffer(out, filters, + error = git_filter_list__apply_to_buffer(out, filters, in->ptr, in->size); if (!error) - git_buf_dispose(in); + git_str_dispose(in); return error; } @@ -802,6 +809,15 @@ int git_filter_list_apply_to_file( git_repository *repo, const char *path) { + GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_file, filters, repo, path); +} + +int git_filter_list__apply_to_file( + git_str *out, + git_filter_list *filters, + git_repository *repo, + const char *path) +{ struct buf_stream writer; int error; @@ -815,7 +831,7 @@ int git_filter_list_apply_to_file( return error; } -static int buf_from_blob(git_buf *out, git_blob *blob) +static int buf_from_blob(git_str *out, git_blob *blob) { git_object_size_t rawsize = git_blob_rawsize(blob); @@ -824,7 +840,7 @@ static int buf_from_blob(git_buf *out, git_blob *blob) return -1; } - git_buf_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize); + git_str_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize); return 0; } @@ -833,6 +849,14 @@ int git_filter_list_apply_to_blob( git_filter_list *filters, git_blob *blob) { + GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_blob, filters, blob); +} + +int git_filter_list__apply_to_blob( + git_str *out, + git_filter_list *filters, + git_blob *blob) +{ struct buf_stream writer; int error; @@ -849,12 +873,13 @@ int git_filter_list_apply_to_blob( struct buffered_stream { git_writestream parent; git_filter *filter; - int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *); + int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *); + int (*legacy_write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *); const git_filter_source *source; void **payload; - git_buf input; - git_buf temp_buf; - git_buf *output; + git_str input; + git_str temp_buf; + git_str *output; git_writestream *target; }; @@ -864,13 +889,13 @@ static int buffered_stream_write( struct buffered_stream *buffered_stream = (struct buffered_stream *)s; GIT_ASSERT_ARG(buffered_stream); - return git_buf_put(&buffered_stream->input, buffer, len); + return git_str_put(&buffered_stream->input, buffer, len); } static int buffered_stream_close(git_writestream *s) { struct buffered_stream *buffered_stream = (struct buffered_stream *)s; - git_buf *writebuf; + git_str *writebuf; git_error_state error_state = {0}; int error; @@ -886,9 +911,6 @@ static int buffered_stream_close(git_writestream *s) if (error == GIT_PASSTHROUGH) { writebuf = &buffered_stream->input; } else if (error == 0) { - if ((error = git_buf_sanitize(buffered_stream->output)) < 0) - return error; - writebuf = buffered_stream->output; } else { /* close stream before erroring out taking care @@ -911,8 +933,8 @@ static void buffered_stream_free(git_writestream *s) struct buffered_stream *buffered_stream = (struct buffered_stream *)s; if (buffered_stream) { - git_buf_dispose(&buffered_stream->input); - git_buf_dispose(&buffered_stream->temp_buf); + git_str_dispose(&buffered_stream->input); + git_str_dispose(&buffered_stream->temp_buf); git__free(buffered_stream); } } @@ -920,8 +942,8 @@ static void buffered_stream_free(git_writestream *s) int git_filter_buffered_stream_new( git_writestream **out, git_filter *filter, - int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *), - git_buf *temp_buf, + int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *), + git_str *temp_buf, void **payload, const git_filter_source *source, git_writestream *target) @@ -940,12 +962,43 @@ int git_filter_buffered_stream_new( buffered_stream->target = target; if (temp_buf) - git_buf_clear(temp_buf); + git_str_clear(temp_buf); *out = (git_writestream *)buffered_stream; return 0; } +#ifndef GIT_DEPRECATE_HARD +static int buffered_legacy_stream_new( + git_writestream **out, + git_filter *filter, + int (*legacy_write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *), + git_str *temp_buf, + void **payload, + const git_filter_source *source, + git_writestream *target) +{ + struct buffered_stream *buffered_stream = git__calloc(1, sizeof(struct buffered_stream)); + GIT_ERROR_CHECK_ALLOC(buffered_stream); + + buffered_stream->parent.write = buffered_stream_write; + buffered_stream->parent.close = buffered_stream_close; + buffered_stream->parent.free = buffered_stream_free; + buffered_stream->filter = filter; + buffered_stream->legacy_write_fn = legacy_write_fn; + buffered_stream->output = temp_buf ? temp_buf : &buffered_stream->temp_buf; + buffered_stream->payload = payload; + buffered_stream->source = source; + buffered_stream->target = target; + + if (temp_buf) + git_str_clear(temp_buf); + + *out = (git_writestream *)buffered_stream; + return 0; +} +#endif + static int setup_stream( git_writestream **out, git_filter_entry *fe, @@ -961,7 +1014,7 @@ static int setup_stream( */ if (!fe->filter->stream) { /* Create a stream that proxies the one-shot apply */ - return git_filter_buffered_stream_new(out, + return buffered_legacy_stream_new(out, fe->filter, fe->filter->apply, filters->temp_buf, &fe->payload, &filters->source, last_stream); } @@ -1032,7 +1085,7 @@ int git_filter_list_stream_file( git_writestream *target) { char buf[FILTERIO_BUFSIZE]; - git_buf abspath = GIT_BUF_INIT; + git_str abspath = GIT_STR_INIT; const char *base = repo ? git_repository_workdir(repo) : NULL; git_vector filter_streams = GIT_VECTOR_INIT; git_writestream *stream_start; @@ -1067,7 +1120,7 @@ done: if (fd >= 0) p_close(fd); filter_streams_free(&filter_streams); - git_buf_dispose(&abspath); + git_str_dispose(&abspath); return error; } @@ -1101,7 +1154,7 @@ int git_filter_list_stream_blob( git_blob *blob, git_writestream *target) { - git_buf in = GIT_BUF_INIT; + git_str in = GIT_STR_INIT; if (buf_from_blob(&in, blob) < 0) return -1; @@ -1125,22 +1178,12 @@ int git_filter_list_stream_data( git_buf *data, git_writestream *target) { - int error; - - if ((error = git_buf_sanitize(data)) < 0) - return error; - return git_filter_list_stream_buffer(filters, data->ptr, data->size, target); } int git_filter_list_apply_to_data( git_buf *tgt, git_filter_list *filters, git_buf *src) { - int error; - - if ((error = git_buf_sanitize(src)) < 0) - return error; - return git_filter_list_apply_to_buffer(tgt, filters, src->ptr, src->size); } diff --git a/src/filter.h b/src/filter.h index 241791276..58cb4b424 100644 --- a/src/filter.h +++ b/src/filter.h @@ -19,7 +19,7 @@ typedef struct { git_filter_options options; git_attr_session *attr_session; - git_buf *temp_buf; + git_str *temp_buf; } git_filter_session; #define GIT_FILTER_SESSION_INIT {GIT_FILTER_OPTIONS_INIT, 0} @@ -36,14 +36,35 @@ extern int git_filter_list__load( git_filter_mode_t mode, git_filter_session *filter_session); +int git_filter_list__apply_to_buffer( + git_str *out, + git_filter_list *filters, + const char *in, + size_t in_len); +int git_filter_list__apply_to_file( + git_str *out, + git_filter_list *filters, + git_repository *repo, + const char *path); +int git_filter_list__apply_to_blob( + git_str *out, + git_filter_list *filters, + git_blob *blob); + /* * The given input buffer will be converted to the given output buffer. * The input buffer will be freed (_if_ it was allocated). */ extern int git_filter_list__convert_buf( - git_buf *out, + git_str *out, + git_filter_list *filters, + git_str *in); + +extern int git_filter_list__apply_to_file( + git_str *out, git_filter_list *filters, - git_buf *in); + git_repository *repo, + const char *path); /* * Available filters @@ -55,8 +76,8 @@ extern git_filter *git_ident_filter_new(void); extern int git_filter_buffered_stream_new( git_writestream **out, git_filter *filter, - int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *), - git_buf *temp_buf, + int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *), + git_str *temp_buf, void **payload, const git_filter_source *source, git_writestream *target); diff --git a/src/futils.c b/src/futils.c index d28b231ce..9a15ceeb9 100644 --- a/src/futils.c +++ b/src/futils.c @@ -22,17 +22,17 @@ int git_futils_mkpath2file(const char *file_path, const mode_t mode) GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST | GIT_MKDIR_VERIFY_DIR); } -int git_futils_mktmp(git_buf *path_out, const char *filename, mode_t mode) +int git_futils_mktmp(git_str *path_out, const char *filename, mode_t mode) { int fd; mode_t mask; p_umask(mask = p_umask(0)); - git_buf_sets(path_out, filename); - git_buf_puts(path_out, "_git2_XXXXXX"); + git_str_sets(path_out, filename); + git_str_puts(path_out, "_git2_XXXXXX"); - if (git_buf_oom(path_out)) + if (git_str_oom(path_out)) return -1; if ((fd = p_mkstemp(path_out->ptr)) < 0) { @@ -145,12 +145,12 @@ mode_t git_futils_canonical_mode(mode_t raw_mode) return 0; } -int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len) +int git_futils_readbuffer_fd(git_str *buf, git_file fd, size_t len) { ssize_t read_size = 0; size_t alloc_len; - git_buf_clear(buf); + git_str_clear(buf); if (!git__is_ssizet(len)) { git_error_set(GIT_ERROR_INVALID, "read too large"); @@ -158,7 +158,7 @@ int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len) } GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, len, 1); - if (git_buf_grow(buf, alloc_len) < 0) + if (git_str_grow(buf, alloc_len) < 0) return -1; /* p_read loops internally to read len bytes */ @@ -166,7 +166,7 @@ int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len) if (read_size != (ssize_t)len) { git_error_set(GIT_ERROR_OS, "failed to read descriptor"); - git_buf_dispose(buf); + git_str_dispose(buf); return -1; } @@ -177,7 +177,7 @@ int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len) } int git_futils_readbuffer_updated( - git_buf *out, + git_str *out, const char *path, unsigned char checksum[GIT_HASH_SHA1_SIZE], int *updated) @@ -185,7 +185,7 @@ int git_futils_readbuffer_updated( int error; git_file fd; struct stat st; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; unsigned char checksum_new[GIT_HASH_SHA1_SIZE]; GIT_ASSERT_ARG(out); @@ -220,7 +220,7 @@ int git_futils_readbuffer_updated( if (checksum) { if ((error = git_hash_buf(checksum_new, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0) { - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -228,7 +228,7 @@ int git_futils_readbuffer_updated( * If we were given a checksum, we only want to use it if it's different */ if (!memcmp(checksum, checksum_new, GIT_HASH_SHA1_SIZE)) { - git_buf_dispose(&buf); + git_str_dispose(&buf); if (updated) *updated = 0; @@ -244,19 +244,19 @@ int git_futils_readbuffer_updated( if (updated != NULL) *updated = 1; - git_buf_swap(out, &buf); - git_buf_dispose(&buf); + git_str_swap(out, &buf); + git_str_dispose(&buf); return 0; } -int git_futils_readbuffer(git_buf *buf, const char *path) +int git_futils_readbuffer(git_str *buf, const char *path) { return git_futils_readbuffer_updated(buf, path, NULL, NULL); } int git_futils_writebuffer( - const git_buf *buf, const char *path, int flags, mode_t mode) + const git_str *buf, const char *path, int flags, mode_t mode) { int fd, do_fsync = 0, error = 0; @@ -276,7 +276,7 @@ int git_futils_writebuffer( return fd; } - if ((error = p_write(fd, git_buf_cstr(buf), git_buf_len(buf))) < 0) { + if ((error = p_write(fd, git_str_cstr(buf), git_str_len(buf))) < 0) { git_error_set(GIT_ERROR_OS, "could not write to '%s'", path); (void)p_close(fd); return error; @@ -418,7 +418,7 @@ GIT_INLINE(int) mkdir_validate_mode( } GIT_INLINE(int) mkdir_canonicalize( - git_buf *path, + git_str *path, uint32_t flags) { ssize_t root_len; @@ -450,7 +450,7 @@ GIT_INLINE(int) mkdir_canonicalize( * the root), we don't have anything to do. */ if (path->size <= (size_t)root_len) - git_buf_clear(path); + git_str_clear(path); return 0; } @@ -460,16 +460,16 @@ int git_futils_mkdir( mode_t mode, uint32_t flags) { - git_buf make_path = GIT_BUF_INIT, parent_path = GIT_BUF_INIT; + git_str make_path = GIT_STR_INIT, parent_path = GIT_STR_INIT; const char *relative; struct git_futils_mkdir_options opts = { 0 }; struct stat st; size_t depth = 0; int len = 0, root_len, error; - if ((error = git_buf_puts(&make_path, path)) < 0 || + if ((error = git_str_puts(&make_path, path)) < 0 || (error = mkdir_canonicalize(&make_path, flags)) < 0 || - (error = git_buf_puts(&parent_path, make_path.ptr)) < 0 || + (error = git_str_puts(&parent_path, make_path.ptr)) < 0 || make_path.size == 0) goto done; @@ -541,8 +541,8 @@ int git_futils_mkdir( parent_path.size ? parent_path.ptr : NULL, mode, flags, &opts); done: - git_buf_dispose(&make_path); - git_buf_dispose(&parent_path); + git_str_dispose(&make_path); + git_str_dispose(&parent_path); return error; } @@ -558,7 +558,7 @@ int git_futils_mkdir_relative( uint32_t flags, struct git_futils_mkdir_options *opts) { - git_buf make_path = GIT_BUF_INIT; + git_str make_path = GIT_STR_INIT; ssize_t root = 0, min_root_len; char lastch = '/', *tail; struct stat st; @@ -578,7 +578,7 @@ int git_futils_mkdir_relative( /* if we are not supposed to make the whole path, reset root */ if ((flags & GIT_MKDIR_PATH) == 0) - root = git_buf_rfind(&make_path, '/'); + root = git_str_rfind(&make_path, '/'); /* advance root past drive name or network mount prefix */ min_root_len = git_path_root(make_path.ptr); @@ -673,7 +673,7 @@ retry_lstat: } done: - git_buf_dispose(&make_path); + git_str_dispose(&make_path); return error; } @@ -697,13 +697,13 @@ static int futils__error_cannot_rmdir(const char *path, const char *filemsg) return -1; } -static int futils__rm_first_parent(git_buf *path, const char *ceiling) +static int futils__rm_first_parent(git_str *path, const char *ceiling) { int error = GIT_ENOTFOUND; struct stat st; while (error == GIT_ENOTFOUND) { - git_buf_rtruncate_at_char(path, '/'); + git_str_rtruncate_at_char(path, '/'); if (!path->size || git__prefixcmp(path->ptr, ceiling) != 0) error = 0; @@ -722,7 +722,7 @@ static int futils__rm_first_parent(git_buf *path, const char *ceiling) return error; } -static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path) +static int futils__rmdir_recurs_foreach(void *opaque, git_str *path) { int error = 0; futils__rmdir_data *data = opaque; @@ -810,7 +810,7 @@ int git_futils_rmdir_r( const char *path, const char *base, uint32_t flags) { int error; - git_buf fullpath = GIT_BUF_INIT; + git_str fullpath = GIT_STR_INIT; futils__rmdir_data data; /* build path and find "root" where we should start calling mkdir */ @@ -834,7 +834,7 @@ int git_futils_rmdir_r( error = 0; } - git_buf_dispose(&fullpath); + git_str_dispose(&fullpath); return error; } @@ -938,7 +938,7 @@ static int cp_link(const char *from, const char *to, size_t link_size) typedef struct { const char *to_root; - git_buf to; + git_str to; ssize_t from_prefix; uint32_t flags; uint32_t mkdir_flags; @@ -947,7 +947,7 @@ typedef struct { #define GIT_CPDIR__MKDIR_DONE_FOR_TO_ROOT (1u << 10) -static int _cp_r_mkdir(cp_r_info *info, git_buf *from) +static int _cp_r_mkdir(cp_r_info *info, git_str *from) { int error = 0; @@ -969,7 +969,7 @@ static int _cp_r_mkdir(cp_r_info *info, git_buf *from) return error; } -static int _cp_r_callback(void *ref, git_buf *from) +static int _cp_r_callback(void *ref, git_str *from) { int error = 0; cp_r_info *info = ref; @@ -980,7 +980,7 @@ static int _cp_r_callback(void *ref, git_buf *from) from->ptr[git_path_basename_offset(from)] == '.') return 0; - if ((error = git_buf_joinpath( + if ((error = git_str_joinpath( &info->to, info->to_root, from->ptr + info->from_prefix)) < 0) return error; @@ -1064,10 +1064,10 @@ int git_futils_cp_r( mode_t dirmode) { int error; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; cp_r_info info; - if (git_buf_joinpath(&path, from, "") < 0) /* ensure trailing slash */ + if (git_str_joinpath(&path, from, "") < 0) /* ensure trailing slash */ return -1; memset(&info, 0, sizeof(info)); @@ -1075,7 +1075,7 @@ int git_futils_cp_r( info.flags = flags; info.dirmode = dirmode; info.from_prefix = path.size; - git_buf_init(&info.to, 0); + git_str_init(&info.to, 0); /* precalculate mkdir flags */ if ((flags & GIT_CPDIR_CREATE_EMPTY_DIRS) == 0) { @@ -1093,8 +1093,8 @@ int git_futils_cp_r( error = _cp_r_callback(&info, &path); - git_buf_dispose(&path); - git_buf_dispose(&info.to); + git_str_dispose(&path); + git_str_dispose(&info.to); return error; } diff --git a/src/futils.h b/src/futils.h index 373cc3042..eea69adde 100644 --- a/src/futils.h +++ b/src/futils.h @@ -21,13 +21,13 @@ * * Read whole files into an in-memory buffer for processing */ -extern int git_futils_readbuffer(git_buf *obj, const char *path); +extern int git_futils_readbuffer(git_str *obj, const char *path); extern int git_futils_readbuffer_updated( - git_buf *obj, + git_str *obj, const char *path, unsigned char checksum[GIT_HASH_SHA1_SIZE], int *updated); -extern int git_futils_readbuffer_fd(git_buf *obj, git_file fd, size_t len); +extern int git_futils_readbuffer_fd(git_str *obj, git_file fd, size_t len); /* Additional constants for `git_futils_writebuffer`'s `open_flags`. We * support these internally and they will be removed before the `open` call. @@ -37,7 +37,7 @@ extern int git_futils_readbuffer_fd(git_buf *obj, git_file fd, size_t len); #endif extern int git_futils_writebuffer( - const git_buf *buf, const char *path, int open_flags, mode_t mode); + const git_str *buf, const char *path, int open_flags, mode_t mode); /** * File utils @@ -177,7 +177,7 @@ extern int git_futils_rmdir_r(const char *path, const char *base, uint32_t flags * Writes the filename into path_out. * @return On success, an open file descriptor, else an error code < 0. */ -extern int git_futils_mktmp(git_buf *path_out, const char *filename, mode_t mode); +extern int git_futils_mktmp(git_str *path_out, const char *filename, mode_t mode); /** * Move a file on the filesystem, create the diff --git a/src/hash.c b/src/hash.c index 222eadf40..92e7ff219 100644 --- a/src/hash.c +++ b/src/hash.c @@ -101,7 +101,7 @@ int git_hash_buf( int git_hash_vec( unsigned char *out, - git_buf_vec *vec, + git_str_vec *vec, size_t n, git_hash_algorithm_t algorithm) { diff --git a/src/hash.h b/src/hash.h index ec91fa43a..10b14a904 100644 --- a/src/hash.h +++ b/src/hash.h @@ -16,7 +16,7 @@ typedef struct { void *data; size_t len; -} git_buf_vec; +} git_str_vec; typedef enum { GIT_HASH_ALGORITHM_NONE = 0, @@ -40,6 +40,6 @@ int git_hash_update(git_hash_ctx *c, const void *data, size_t len); int git_hash_final(unsigned char *out, git_hash_ctx *c); int git_hash_buf(unsigned char *out, const void *data, size_t len, git_hash_algorithm_t algorithm); -int git_hash_vec(unsigned char *out, git_buf_vec *vec, size_t n, git_hash_algorithm_t algorithm); +int git_hash_vec(unsigned char *out, git_str_vec *vec, size_t n, git_hash_algorithm_t algorithm); #endif diff --git a/src/ident.c b/src/ident.c index e5aab80ed..53095864e 100644 --- a/src/ident.c +++ b/src/ident.c @@ -9,7 +9,7 @@ #include "git2/sys/filter.h" #include "filter.h" -#include "buffer.h" +#include "str.h" static int ident_find_id( const char **id_start, const char **id_end, const char *start, size_t len) @@ -40,7 +40,7 @@ static int ident_find_id( } static int ident_insert_id( - git_buf *to, const git_buf *from, const git_filter_source *src) + git_str *to, const git_str *from, const git_filter_source *src) { char oid[GIT_OID_HEXSZ+1]; const char *id_start, *id_end, *from_end = from->ptr + from->size; @@ -60,20 +60,20 @@ static int ident_insert_id( 5 /* "$Id: " */ + GIT_OID_HEXSZ + 2 /* " $" */ + (size_t)(from_end - id_end); - if (git_buf_grow(to, need_size) < 0) + if (git_str_grow(to, need_size) < 0) return -1; - git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr)); - git_buf_put(to, "$Id: ", 5); - git_buf_put(to, oid, GIT_OID_HEXSZ); - git_buf_put(to, " $", 2); - git_buf_put(to, id_end, (size_t)(from_end - id_end)); + git_str_set(to, from->ptr, (size_t)(id_start - from->ptr)); + git_str_put(to, "$Id: ", 5); + git_str_put(to, oid, GIT_OID_HEXSZ); + git_str_put(to, " $", 2); + git_str_put(to, id_end, (size_t)(from_end - id_end)); - return git_buf_oom(to) ? -1 : 0; + return git_str_oom(to) ? -1 : 0; } static int ident_remove_id( - git_buf *to, const git_buf *from) + git_str *to, const git_str *from) { const char *id_start, *id_end, *from_end = from->ptr + from->size; size_t need_size; @@ -84,27 +84,27 @@ static int ident_remove_id( need_size = (size_t)(id_start - from->ptr) + 4 /* "$Id$" */ + (size_t)(from_end - id_end); - if (git_buf_grow(to, need_size) < 0) + if (git_str_grow(to, need_size) < 0) return -1; - git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr)); - git_buf_put(to, "$Id$", 4); - git_buf_put(to, id_end, (size_t)(from_end - id_end)); + git_str_set(to, from->ptr, (size_t)(id_start - from->ptr)); + git_str_put(to, "$Id$", 4); + git_str_put(to, id_end, (size_t)(from_end - id_end)); - return git_buf_oom(to) ? -1 : 0; + return git_str_oom(to) ? -1 : 0; } static int ident_apply( git_filter *self, void **payload, - git_buf *to, - const git_buf *from, + git_str *to, + const git_str *from, const git_filter_source *src) { GIT_UNUSED(self); GIT_UNUSED(payload); /* Don't filter binary files */ - if (git_buf_is_binary(from)) + if (git_str_is_binary(from)) return GIT_PASSTHROUGH; if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE) diff --git a/src/ignore.c b/src/ignore.c index 9ead96ba6..eb9fd8a9e 100644 --- a/src/ignore.c +++ b/src/ignore.c @@ -105,7 +105,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match size_t i; git_attr_fnmatch *rule; char *path; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; *out = 0; @@ -115,12 +115,12 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match /* path of the file relative to the workdir, so we match the rules in subdirs */ if (match->containing_dir) { - git_buf_puts(&buf, match->containing_dir); + git_str_puts(&buf, match->containing_dir); } - if (git_buf_puts(&buf, match->pattern) < 0) + if (git_str_puts(&buf, match->pattern) < 0) return -1; - path = git_buf_detach(&buf); + path = git_str_detach(&buf); git_vector_foreach(rules, i, rule) { if (!(rule->flags & GIT_ATTR_FNMATCH_HASWILD)) { @@ -133,12 +133,12 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match continue; } - git_buf_clear(&buf); + git_str_clear(&buf); if (rule->containing_dir) - git_buf_puts(&buf, rule->containing_dir); - git_buf_puts(&buf, rule->pattern); + git_str_puts(&buf, rule->containing_dir); + git_str_puts(&buf, rule->pattern); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) goto out; /* @@ -151,7 +151,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match effective_flags &= ~WM_PATHNAME; /* if we found a match, we want to keep this rule */ - if ((wildmatch(git_buf_cstr(&buf), path, effective_flags)) == WM_MATCH) { + if ((wildmatch(git_str_cstr(&buf), path, effective_flags)) == WM_MATCH) { *out = 1; error = 0; goto out; @@ -162,7 +162,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match out: git__free(path); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -295,7 +295,7 @@ int git_ignore__for_path( { int error = 0; const char *workdir = git_repository_workdir(repo); - git_buf infopath = GIT_BUF_INIT; + git_str infopath = GIT_STR_INIT; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(ignores); @@ -314,19 +314,19 @@ int git_ignore__for_path( /* given a unrooted path in a non-bare repo, resolve it */ if (workdir && git_path_root(path) < 0) { - git_buf local = GIT_BUF_INIT; + git_str local = GIT_STR_INIT; if ((error = git_path_dirname_r(&local, path)) < 0 || (error = git_path_resolve_relative(&local, 0)) < 0 || (error = git_path_to_dir(&local)) < 0 || - (error = git_buf_joinpath(&ignores->dir, workdir, local.ptr)) < 0 || + (error = git_str_joinpath(&ignores->dir, workdir, local.ptr)) < 0 || (error = git_path_validate_workdir_buf(repo, &ignores->dir)) < 0) { /* Nothing, we just want to stop on the first error */ } - git_buf_dispose(&local); + git_str_dispose(&local); } else { - if (!(error = git_buf_joinpath(&ignores->dir, path, ""))) + if (!(error = git_str_joinpath(&ignores->dir, path, ""))) error = git_path_validate_filesystem(ignores->dir.ptr, ignores->dir.size); } @@ -349,7 +349,7 @@ int git_ignore__for_path( } /* load .git/info/exclude if possible */ - if ((error = git_repository_item_path(&infopath, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || + if ((error = git_repository__item_path(&infopath, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 || (error = push_ignore_file(ignores, &ignores->ign_global, infopath.ptr, GIT_IGNORE_FILE_INREPO)) < 0) { if (error != GIT_ENOTFOUND) goto cleanup; @@ -363,7 +363,7 @@ int git_ignore__for_path( git_repository_attr_cache(repo)->cfg_excl_file); cleanup: - git_buf_dispose(&infopath); + git_str_dispose(&infopath); if (error < 0) git_ignore__free(ignores); @@ -372,7 +372,7 @@ cleanup: int git_ignore__push_dir(git_ignores *ign, const char *dir) { - if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0) + if (git_str_joinpath(&ign->dir, ign->dir.ptr, dir) < 0) return -1; ign->depth++; @@ -409,7 +409,7 @@ int git_ignore__pop_dir(git_ignores *ign) } if (--ign->depth > 0) { - git_buf_rtruncate_at_char(&ign->dir, '/'); + git_str_rtruncate_at_char(&ign->dir, '/'); git_path_to_dir(&ign->dir); } @@ -435,7 +435,7 @@ void git_ignore__free(git_ignores *ignores) } git_vector_free(&ignores->ign_global); - git_buf_dispose(&ignores->dir); + git_str_dispose(&ignores->dir); } static bool ignore_lookup_in_rules( @@ -604,7 +604,7 @@ int git_ignore__check_pathspec_for_exact_ignores( size_t i; git_attr_fnmatch *match; int ignored; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; const char *filename; git_index *idx; @@ -645,7 +645,7 @@ int git_ignore__check_pathspec_for_exact_ignores( } git_index_free(idx); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } diff --git a/src/ignore.h b/src/ignore.h index 5895d3faa..799195258 100644 --- a/src/ignore.h +++ b/src/ignore.h @@ -26,7 +26,7 @@ */ typedef struct { git_repository *repo; - git_buf dir; /* current directory reflected in ign_path */ + git_str dir; /* current directory reflected in ign_path */ git_attr_file *ign_internal; git_vector ign_path; git_vector ign_global; diff --git a/src/index.c b/src/index.c index 2e24fff69..b8aa310d3 100644 --- a/src/index.c +++ b/src/index.c @@ -641,7 +641,7 @@ static int compare_checksum(git_index *index) int git_index_read(git_index *index, int force) { int error = 0, updated; - git_buf buffer = GIT_BUF_INIT; + git_str buffer = GIT_STR_INIT; git_futils_filestamp stamp = index->stamp; if (!index->index_file_path) @@ -687,7 +687,7 @@ int git_index_read(git_index *index, int force) index->dirty = 0; } - git_buf_dispose(&buffer); + git_str_dispose(&buffer); return error; } @@ -969,7 +969,7 @@ static int index_entry_init( { int error = 0; git_index_entry *entry = NULL; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; struct stat st; git_oid oid; git_repository *repo; @@ -992,7 +992,7 @@ static int index_entry_init( return -1; error = git_path_lstat(path.ptr, &st); - git_buf_dispose(&path); + git_str_dispose(&path); if (error < 0) return error; @@ -1525,7 +1525,7 @@ int git_index_add_from_buffer( static int add_repo_as_submodule(git_index_entry **out, git_index *index, const char *path) { git_repository *sub; - git_buf abspath = GIT_BUF_INIT; + git_str abspath = GIT_STR_INIT; git_repository *repo = INDEX_OWNER(index); git_reference *head; git_index_entry *entry; @@ -1556,7 +1556,7 @@ static int add_repo_as_submodule(git_index_entry **out, git_index *index, const git_reference_free(head); git_repository_free(sub); - git_buf_dispose(&abspath); + git_str_dispose(&abspath); *out = entry; return 0; @@ -1722,12 +1722,12 @@ int git_index_remove(git_index *index, const char *path, int stage) int git_index_remove_directory(git_index *index, const char *dir, int stage) { - git_buf pfx = GIT_BUF_INIT; + git_str pfx = GIT_STR_INIT; int error = 0; size_t pos; git_index_entry *entry; - if (!(error = git_buf_sets(&pfx, dir)) && + if (!(error = git_str_sets(&pfx, dir)) && !(error = git_path_to_dir(&pfx))) index_find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY); @@ -1746,7 +1746,7 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage) /* removed entry at 'pos' so we don't need to increment */ } - git_buf_dispose(&pfx); + git_str_dispose(&pfx); return error; } @@ -2892,7 +2892,7 @@ done: return error; } -static int write_extension(git_filebuf *file, struct index_extension *header, git_buf *data) +static int write_extension(git_filebuf *file, struct index_extension *header, git_str *data) { struct index_extension ondisk; @@ -2904,30 +2904,30 @@ static int write_extension(git_filebuf *file, struct index_extension *header, gi return git_filebuf_write(file, data->ptr, data->size); } -static int create_name_extension_data(git_buf *name_buf, git_index_name_entry *conflict_name) +static int create_name_extension_data(git_str *name_buf, git_index_name_entry *conflict_name) { int error = 0; if (conflict_name->ancestor == NULL) - error = git_buf_put(name_buf, "\0", 1); + error = git_str_put(name_buf, "\0", 1); else - error = git_buf_put(name_buf, conflict_name->ancestor, strlen(conflict_name->ancestor) + 1); + error = git_str_put(name_buf, conflict_name->ancestor, strlen(conflict_name->ancestor) + 1); if (error != 0) goto on_error; if (conflict_name->ours == NULL) - error = git_buf_put(name_buf, "\0", 1); + error = git_str_put(name_buf, "\0", 1); else - error = git_buf_put(name_buf, conflict_name->ours, strlen(conflict_name->ours) + 1); + error = git_str_put(name_buf, conflict_name->ours, strlen(conflict_name->ours) + 1); if (error != 0) goto on_error; if (conflict_name->theirs == NULL) - error = git_buf_put(name_buf, "\0", 1); + error = git_str_put(name_buf, "\0", 1); else - error = git_buf_put(name_buf, conflict_name->theirs, strlen(conflict_name->theirs) + 1); + error = git_str_put(name_buf, conflict_name->theirs, strlen(conflict_name->theirs) + 1); on_error: return error; @@ -2935,7 +2935,7 @@ on_error: static int write_name_extension(git_index *index, git_filebuf *file) { - git_buf name_buf = GIT_BUF_INIT; + git_str name_buf = GIT_STR_INIT; git_vector *out = &index->names; git_index_name_entry *conflict_name; struct index_extension extension; @@ -2953,28 +2953,28 @@ static int write_name_extension(git_index *index, git_filebuf *file) error = write_extension(file, &extension, &name_buf); - git_buf_dispose(&name_buf); + git_str_dispose(&name_buf); done: return error; } -static int create_reuc_extension_data(git_buf *reuc_buf, git_index_reuc_entry *reuc) +static int create_reuc_extension_data(git_str *reuc_buf, git_index_reuc_entry *reuc) { int i; int error = 0; - if ((error = git_buf_put(reuc_buf, reuc->path, strlen(reuc->path) + 1)) < 0) + if ((error = git_str_put(reuc_buf, reuc->path, strlen(reuc->path) + 1)) < 0) return error; for (i = 0; i < 3; i++) { - if ((error = git_buf_printf(reuc_buf, "%o", reuc->mode[i])) < 0 || - (error = git_buf_put(reuc_buf, "\0", 1)) < 0) + if ((error = git_str_printf(reuc_buf, "%o", reuc->mode[i])) < 0 || + (error = git_str_put(reuc_buf, "\0", 1)) < 0) return error; } for (i = 0; i < 3; i++) { - if (reuc->mode[i] && (error = git_buf_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_RAWSZ)) < 0) + if (reuc->mode[i] && (error = git_str_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_RAWSZ)) < 0) return error; } @@ -2983,7 +2983,7 @@ static int create_reuc_extension_data(git_buf *reuc_buf, git_index_reuc_entry *r static int write_reuc_extension(git_index *index, git_filebuf *file) { - git_buf reuc_buf = GIT_BUF_INIT; + git_str reuc_buf = GIT_STR_INIT; git_vector *out = &index->reuc; git_index_reuc_entry *reuc; struct index_extension extension; @@ -3001,7 +3001,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file) error = write_extension(file, &extension, &reuc_buf); - git_buf_dispose(&reuc_buf); + git_str_dispose(&reuc_buf); done: return error; @@ -3010,7 +3010,7 @@ done: static int write_tree_extension(git_index *index, git_filebuf *file) { struct index_extension extension; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; if (index->tree == NULL) @@ -3025,7 +3025,7 @@ static int write_tree_extension(git_index *index, git_filebuf *file) error = write_extension(file, &extension, &buf); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -3115,13 +3115,13 @@ static int read_tree_cb( { read_tree_data *data = payload; git_index_entry *entry = NULL, *old_entry; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; size_t pos; if (git_tree_entry__is_tree(tentry)) return 0; - if (git_buf_joinpath(&path, root, tentry->filename) < 0) + if (git_str_joinpath(&path, root, tentry->filename) < 0) return -1; if (index_entry_create(&entry, INDEX_OWNER(data->index), path.ptr, NULL, false) < 0) @@ -3143,7 +3143,7 @@ static int read_tree_cb( } index_entry_adjust_namemask(entry, path.size); - git_buf_dispose(&path); + git_str_dispose(&path); if (git_vector_insert(data->new_entries, entry) < 0) { index_entry_free(entry); @@ -3540,7 +3540,7 @@ static int index_apply_to_all( size_t i; git_pathspec ps; const char *match; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; GIT_ASSERT_ARG(index); @@ -3569,7 +3569,7 @@ static int index_apply_to_all( } /* index manipulation may alter entry, so don't depend on it */ - if ((error = git_buf_sets(&path, entry->path)) < 0) + if ((error = git_str_sets(&path, entry->path)) < 0) break; switch (action) { @@ -3598,7 +3598,7 @@ static int index_apply_to_all( } } - git_buf_dispose(&path); + git_str_dispose(&path); git_pathspec__clear(&ps); return error; diff --git a/src/indexer.c b/src/indexer.c index 16ed7bfae..213ad7581 100644 --- a/src/indexer.c +++ b/src/indexer.c @@ -48,7 +48,7 @@ struct git_indexer { off64_t off; off64_t entry_start; git_object_t entry_type; - git_buf entry_data; + git_str entry_data; git_packfile_stream stream; size_t nr_objects; git_vector objects; @@ -137,7 +137,7 @@ int git_indexer_new( { git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; git_indexer *idx; - git_buf path = GIT_BUF_INIT, tmp_path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, tmp_path = GIT_STR_INIT; static const char suff[] = "/pack"; int error, fd = -1; @@ -150,7 +150,7 @@ int git_indexer_new( idx->progress_cb = opts.progress_cb; idx->progress_payload = opts.progress_cb_payload; idx->mode = mode ? mode : GIT_PACK_FILE_MODE; - git_buf_init(&idx->entry_data, 0); + git_str_init(&idx->entry_data, 0); if ((error = git_hash_ctx_init(&idx->hash_ctx, GIT_HASH_ALGORITHM_SHA1)) < 0 || (error = git_hash_ctx_init(&idx->trailer, GIT_HASH_ALGORITHM_SHA1)) < 0 || @@ -162,17 +162,17 @@ int git_indexer_new( if (git_repository__fsync_gitdir) idx->do_fsync = 1; - error = git_buf_joinpath(&path, prefix, suff); + error = git_str_joinpath(&path, prefix, suff); if (error < 0) goto cleanup; - fd = git_futils_mktmp(&tmp_path, git_buf_cstr(&path), idx->mode); - git_buf_dispose(&path); + fd = git_futils_mktmp(&tmp_path, git_str_cstr(&path), idx->mode); + git_str_dispose(&path); if (fd < 0) goto cleanup; - error = git_packfile_alloc(&idx->pack, git_buf_cstr(&tmp_path)); - git_buf_dispose(&tmp_path); + error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path)); + git_str_dispose(&tmp_path); if (error < 0) goto cleanup; @@ -188,14 +188,14 @@ cleanup: if (fd != -1) p_close(fd); - if (git_buf_len(&tmp_path) > 0) - p_unlink(git_buf_cstr(&tmp_path)); + if (git_str_len(&tmp_path) > 0) + p_unlink(git_str_cstr(&tmp_path)); if (idx->pack != NULL) p_unlink(idx->pack->pack_name); - git_buf_dispose(&path); - git_buf_dispose(&tmp_path); + git_str_dispose(&path); + git_str_dispose(&tmp_path); git__free(idx); return -1; } @@ -245,7 +245,7 @@ static int hash_object_stream(git_indexer*idx, git_packfile_stream *stream) break; if (idx->do_verify) - git_buf_put(&idx->entry_data, idx->objbuf, read); + git_str_put(&idx->entry_data, idx->objbuf, read); git_hash_update(&idx->hash_ctx, idx->objbuf, read); } while (read > 0); @@ -730,7 +730,7 @@ static int read_stream_object(git_indexer *idx, git_indexer_progress *stats) git_mwindow_close(&w); idx->entry_start = entry_start; git_hash_init(&idx->hash_ctx); - git_buf_clear(&idx->entry_data); + git_str_clear(&idx->entry_data); if (type == GIT_OBJECT_REF_DELTA || type == GIT_OBJECT_OFS_DELTA) { error = advance_delta_offset(idx, type); @@ -876,7 +876,7 @@ on_error: return error; } -static int index_path(git_buf *path, git_indexer *idx, const char *suffix) +static int index_path(git_str *path, git_indexer *idx, const char *suffix) { const char prefix[] = "pack-"; size_t slash = (size_t)path->size; @@ -885,17 +885,17 @@ static int index_path(git_buf *path, git_indexer *idx, const char *suffix) while (slash > 0 && path->ptr[slash - 1] != '/') slash--; - if (git_buf_grow(path, slash + 1 + strlen(prefix) + + if (git_str_grow(path, slash + 1 + strlen(prefix) + GIT_OID_HEXSZ + strlen(suffix) + 1) < 0) return -1; - git_buf_truncate(path, slash); - git_buf_puts(path, prefix); - git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash); + git_str_truncate(path, slash); + git_str_puts(path, prefix); + git_oid_fmt(path->ptr + git_str_len(path), &idx->hash); path->size += GIT_OID_HEXSZ; - git_buf_puts(path, suffix); + git_str_puts(path, suffix); - return git_buf_oom(path) ? -1 : 0; + return git_str_oom(path) ? -1 : 0; } /** @@ -915,7 +915,7 @@ static int inject_object(git_indexer *idx, git_oid *id) struct git_pack_entry *pentry = NULL; git_oid foo = {{0}}; unsigned char hdr[64]; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; off64_t entry_start; const void *data; size_t len, hdr_len; @@ -956,7 +956,7 @@ static int inject_object(git_indexer *idx, git_oid *id) idx->pack->mwf.size += buf.size; entry->crc = htonl(crc32(entry->crc, (unsigned char *)buf.ptr, (uInt)buf.size)); - git_buf_dispose(&buf); + git_str_dispose(&buf); /* Write a fake trailer so the pack functions play ball */ @@ -1152,7 +1152,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) unsigned int i, long_offsets = 0, left; int error; struct git_pack_idx_header hdr; - git_buf filename = GIT_BUF_INIT; + git_str filename = GIT_STR_INIT; struct entry *entry; git_oid trailer_hash, file_hash; git_filebuf index_file = {0}; @@ -1226,10 +1226,10 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) * files with different contents have different names */ git_oid_cpy(&idx->hash, &trailer_hash); - git_buf_sets(&filename, idx->pack->pack_name); - git_buf_shorten(&filename, strlen("pack")); - git_buf_puts(&filename, "idx"); - if (git_buf_oom(&filename)) + git_str_sets(&filename, idx->pack->pack_name); + git_str_shorten(&filename, strlen("pack")); + git_str_puts(&filename, "idx"); + if (git_str_oom(&filename)) return -1; if (git_filebuf_open(&index_file, filename.ptr, @@ -1336,23 +1336,23 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) goto on_error; /* And don't forget to rename the packfile to its new place. */ - if (p_rename(idx->pack->pack_name, git_buf_cstr(&filename)) < 0) + if (p_rename(idx->pack->pack_name, git_str_cstr(&filename)) < 0) goto on_error; /* And fsync the parent directory if we're asked to. */ if (idx->do_fsync && - git_futils_fsync_parent(git_buf_cstr(&filename)) < 0) + git_futils_fsync_parent(git_str_cstr(&filename)) < 0) goto on_error; idx->pack_committed = 1; - git_buf_dispose(&filename); + git_str_dispose(&filename); return 0; on_error: git_mwindow_free_all(&idx->pack->mwf); git_filebuf_cleanup(&index_file); - git_buf_dispose(&filename); + git_str_dispose(&filename); return -1; } @@ -1389,7 +1389,7 @@ void git_indexer_free(git_indexer *idx) git_hash_ctx_cleanup(&idx->trailer); git_hash_ctx_cleanup(&idx->hash_ctx); - git_buf_dispose(&idx->entry_data); + git_str_dispose(&idx->entry_data); git_oidmap_free(idx->expected_oids); git__free(idx); } diff --git a/src/iterator.c b/src/iterator.c index ce9f305ef..5549c636a 100644 --- a/src/iterator.c +++ b/src/iterator.c @@ -424,7 +424,7 @@ typedef struct { git_tree *tree; /* path to this particular frame (folder) */ - git_buf path; + git_str path; /* a sorted list of the entries for this frame (folder), these are * actually pointers to the iterator's entry pool. @@ -441,7 +441,7 @@ typedef struct { * parent path. */ git_vector similar_trees; - git_array_t(git_buf) similar_paths; + git_array_t(git_str) similar_paths; } tree_iterator_frame; typedef struct { @@ -450,7 +450,7 @@ typedef struct { git_array_t(tree_iterator_frame) frames; git_index_entry entry; - git_buf entry_path; + git_str entry_path; /* a pool of entries to reduce the number of allocations */ git_pool entry_pool; @@ -508,20 +508,20 @@ static int tree_iterator_entry_sort_icase(const void *ptr_a, const void *ptr_b) } static int tree_iterator_compute_path( - git_buf *out, + git_str *out, tree_iterator_entry *entry) { - git_buf_clear(out); + git_str_clear(out); if (entry->parent_path) - git_buf_joinpath(out, entry->parent_path, entry->tree_entry->filename); + git_str_joinpath(out, entry->parent_path, entry->tree_entry->filename); else - git_buf_puts(out, entry->tree_entry->filename); + git_str_puts(out, entry->tree_entry->filename); if (git_tree_entry__is_tree(entry->tree_entry)) - git_buf_putc(out, '/'); + git_str_putc(out, '/'); - if (git_buf_oom(out)) + if (git_str_oom(out)) return -1; return 0; @@ -601,7 +601,7 @@ GIT_INLINE(int) tree_iterator_frame_push_neighbors( tree_iterator_entry *entry, *new_entry; git_tree *tree = NULL; git_tree_entry *tree_entry; - git_buf *path; + git_str *path; size_t new_size, i; int error = 0; @@ -621,7 +621,7 @@ GIT_INLINE(int) tree_iterator_frame_push_neighbors( path = git_array_alloc(parent_frame->similar_paths); GIT_ERROR_CHECK_ALLOC(path); - memset(path, 0, sizeof(git_buf)); + memset(path, 0, sizeof(git_str)); if ((error = tree_iterator_compute_path(path, entry)) < 0) break; @@ -681,7 +681,7 @@ done: static int tree_iterator_frame_pop(tree_iterator *iter) { tree_iterator_frame *frame; - git_buf *buf = NULL; + git_str *buf = NULL; git_tree *tree; size_t i; @@ -694,7 +694,7 @@ static int tree_iterator_frame_pop(tree_iterator *iter) do { buf = git_array_pop(frame->similar_paths); - git_buf_dispose(buf); + git_str_dispose(buf); } while (buf != NULL); git_array_clear(frame->similar_paths); @@ -704,7 +704,7 @@ static int tree_iterator_frame_pop(tree_iterator *iter) git_vector_free(&frame->similar_trees); - git_buf_dispose(&frame->path); + git_str_dispose(&frame->path); return 0; } @@ -892,7 +892,7 @@ static void tree_iterator_clear(tree_iterator *iter) git_array_clear(iter->frames); git_pool_clear(&iter->entry_pool); - git_buf_clear(&iter->entry_path); + git_str_clear(&iter->entry_path); iterator_clear(&iter->base); } @@ -925,7 +925,7 @@ static void tree_iterator_free(git_iterator *i) tree_iterator_clear(iter); git_tree_free(iter->root); - git_buf_dispose(&iter->entry_path); + git_str_dispose(&iter->entry_path); } int git_iterator_for_tree( @@ -1040,11 +1040,11 @@ typedef struct { /* info about the current entry */ git_index_entry entry; - git_buf current_path; + git_str current_path; int current_is_ignored; /* temporary buffer for advance_over */ - git_buf tmp_buf; + git_str tmp_buf; } filesystem_iterator; @@ -1266,7 +1266,7 @@ static int filesystem_iterator_entry_hash( filesystem_iterator *iter, filesystem_iterator_entry *entry) { - git_buf fullpath = GIT_BUF_INIT; + git_str fullpath = GIT_STR_INIT; int error; if (S_ISDIR(entry->st.st_mode)) { @@ -1278,11 +1278,11 @@ static int filesystem_iterator_entry_hash( return git_repository_hashfile(&entry->id, iter->base.repo, entry->path, GIT_OBJECT_BLOB, NULL); - if (!(error = git_buf_joinpath(&fullpath, iter->root, entry->path)) && + if (!(error = git_str_joinpath(&fullpath, iter->root, entry->path)) && !(error = git_path_validate_workdir_buf(iter->base.repo, &fullpath))) error = git_odb_hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB); - git_buf_dispose(&fullpath); + git_str_dispose(&fullpath); return error; } @@ -1337,7 +1337,7 @@ static int filesystem_iterator_frame_push( { filesystem_iterator_frame *new_frame = NULL; git_path_diriter diriter = GIT_PATH_DIRITER_INIT; - git_buf root = GIT_BUF_INIT; + git_str root = GIT_STR_INIT; const char *path; filesystem_iterator_entry *entry; struct stat statbuf; @@ -1356,11 +1356,11 @@ static int filesystem_iterator_frame_push( memset(new_frame, 0, sizeof(filesystem_iterator_frame)); if (frame_entry) - git_buf_joinpath(&root, iter->root, frame_entry->path); + git_str_joinpath(&root, iter->root, frame_entry->path); else - git_buf_puts(&root, iter->root); + git_str_puts(&root, iter->root); - if (git_buf_oom(&root) || + if (git_str_oom(&root) || git_path_validate_workdir_buf(iter->base.repo, &root) < 0) { error = -1; goto done; @@ -1471,7 +1471,7 @@ done: if (error < 0) git_array_pop(iter->frames); - git_buf_dispose(&root); + git_str_dispose(&root); git_path_diriter_free(&diriter); return error; } @@ -1551,7 +1551,7 @@ static int filesystem_iterator_is_dir( const filesystem_iterator_entry *entry) { struct stat st; - git_buf fullpath = GIT_BUF_INIT; + git_str fullpath = GIT_STR_INIT; int error = 0; if (S_ISDIR(entry->st.st_mode)) { @@ -1564,7 +1564,7 @@ static int filesystem_iterator_is_dir( goto done; } - if ((error = git_buf_joinpath(&fullpath, iter->root, entry->path)) < 0 || + if ((error = git_str_joinpath(&fullpath, iter->root, entry->path)) < 0 || (error = git_path_validate_workdir_buf(iter->base.repo, &fullpath)) < 0 || (error = p_stat(fullpath.ptr, &st)) < 0) goto done; @@ -1572,7 +1572,7 @@ static int filesystem_iterator_is_dir( *is_dir = S_ISDIR(st.st_mode); done: - git_buf_dispose(&fullpath); + git_str_dispose(&fullpath); return error; } @@ -1673,7 +1673,7 @@ static int filesystem_iterator_advance_into( return filesystem_iterator_advance(out, i); } -int git_iterator_current_workdir_path(git_buf **out, git_iterator *i) +int git_iterator_current_workdir_path(git_str **out, git_iterator *i) { filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base); const git_index_entry *entry; @@ -1684,10 +1684,10 @@ int git_iterator_current_workdir_path(git_buf **out, git_iterator *i) return 0; } - git_buf_truncate(&iter->current_path, iter->root_len); + git_str_truncate(&iter->current_path, iter->root_len); if (git_iterator_current(&entry, i) < 0 || - git_buf_puts(&iter->current_path, entry->path) < 0) + git_str_puts(&iter->current_path, entry->path) < 0) return -1; *out = &iter->current_path; @@ -1790,8 +1790,8 @@ static int filesystem_iterator_advance_over( return filesystem_iterator_advance(out, i); } - git_buf_clear(&iter->tmp_buf); - if ((error = git_buf_puts(&iter->tmp_buf, entry->path)) < 0) + git_str_clear(&iter->tmp_buf); + if ((error = git_str_puts(&iter->tmp_buf, entry->path)) < 0) return error; base = iter->tmp_buf.ptr; @@ -1858,7 +1858,7 @@ static void filesystem_iterator_clear(filesystem_iterator *iter) git_array_clear(iter->frames); git_ignore__free(&iter->ignores); - git_buf_dispose(&iter->tmp_buf); + git_str_dispose(&iter->tmp_buf); iterator_clear(&iter->base); } @@ -1892,7 +1892,7 @@ static void filesystem_iterator_free(git_iterator *i) { filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base); git__free(iter->root); - git_buf_dispose(&iter->current_path); + git_str_dispose(&iter->current_path); git_tree_free(iter->tree); if (iter->index) git_index_snapshot_release(&iter->index_snapshot, iter->index); @@ -1946,7 +1946,7 @@ static int iterator_for_filesystem( iter->root[root_len] = '\0'; iter->root_len = root_len; - if ((error = git_buf_puts(&iter->current_path, iter->root)) < 0) + if ((error = git_str_puts(&iter->current_path, iter->root)) < 0) goto on_error; if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0) @@ -2024,7 +2024,7 @@ typedef struct { /* the pseudotree entry */ git_index_entry tree_entry; - git_buf tree_buf; + git_str tree_buf; bool skip_tree; const git_index_entry *entry; @@ -2064,8 +2064,8 @@ static bool index_iterator_create_pseudotree( if ((dirsep = strchr(relative_path, '/')) == NULL) return false; - git_buf_clear(&iter->tree_buf); - git_buf_put(&iter->tree_buf, path, (dirsep - path) + 1); + git_str_clear(&iter->tree_buf); + git_str_put(&iter->tree_buf, path, (dirsep - path) + 1); iter->tree_entry.mode = GIT_FILEMODE_TREE; iter->tree_entry.path = iter->tree_buf.ptr; @@ -2230,7 +2230,7 @@ static void index_iterator_free(git_iterator *i) index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base); git_index_snapshot_release(&iter->entries, iter->base.index); - git_buf_dispose(&iter->tree_buf); + git_str_dispose(&iter->tree_buf); } int git_iterator_for_index( diff --git a/src/iterator.h b/src/iterator.h index 30465df2f..e55c1047a 100644 --- a/src/iterator.h +++ b/src/iterator.h @@ -11,7 +11,7 @@ #include "git2/index.h" #include "vector.h" -#include "buffer.h" +#include "str.h" #include "ignore.h" typedef struct git_iterator git_iterator; @@ -278,11 +278,11 @@ extern bool git_iterator_current_tree_is_ignored(git_iterator *iter); /** * Get full path of the current item from a workdir iterator. This will - * return NULL for a non-workdir iterator. The git_buf is still owned by + * return NULL for a non-workdir iterator. The git_str is still owned by * the iterator; this is exposed just for efficiency. */ extern int git_iterator_current_workdir_path( - git_buf **path, git_iterator *iter); + git_str **path, git_iterator *iter); /** * Retrieve the index stored in the iterator. diff --git a/src/libgit2.c b/src/libgit2.c index cc793b458..b3a72de18 100644 --- a/src/libgit2.c +++ b/src/libgit2.c @@ -9,6 +9,7 @@ #include <git2.h> #include "alloc.h" +#include "buf.h" #include "cache.h" #include "common.h" #include "filter.h" @@ -192,15 +193,17 @@ int git_libgit2_opts(int key, ...) { int sysdir = va_arg(ap, int); git_buf *out = va_arg(ap, git_buf *); - const git_buf *tmp; + git_str str = GIT_STR_INIT; + const git_str *tmp; int level; - if ((error = config_level_to_sysdir(&level, sysdir)) < 0 || - (error = git_buf_sanitize(out)) < 0 || - (error = git_sysdir_get(&tmp, level)) < 0) + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = config_level_to_sysdir(&level, sysdir)) < 0 || + (error = git_sysdir_get(&tmp, level)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) break; - error = git_buf_sets(out, tmp->ptr); + error = git_buf_fromstr(out, &str); } break; @@ -237,13 +240,15 @@ int git_libgit2_opts(int key, ...) case GIT_OPT_GET_TEMPLATE_PATH: { git_buf *out = va_arg(ap, git_buf *); - const git_buf *tmp; + git_str str = GIT_STR_INIT; + const git_str *tmp; - if ((error = git_buf_sanitize(out)) < 0 || - (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0) + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0 || + (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0) break; - error = git_buf_sets(out, tmp->ptr); + error = git_buf_fromstr(out, &str); } break; @@ -306,9 +311,13 @@ int git_libgit2_opts(int key, ...) case GIT_OPT_GET_USER_AGENT: { git_buf *out = va_arg(ap, git_buf *); - if ((error = git_buf_sanitize(out)) < 0) + git_str str = GIT_STR_INIT; + + if ((error = git_buf_tostr(&str, out)) < 0 || + (error = git_str_puts(&str, git__user_agent)) < 0) break; - error = git_buf_sets(out, git__user_agent); + + error = git_buf_fromstr(out, &str); } break; diff --git a/src/mailmap.c b/src/mailmap.c index b69d55e2e..38ae01645 100644 --- a/src/mailmap.c +++ b/src/mailmap.c @@ -8,6 +8,7 @@ #include "mailmap.h" #include "common.h" +#include "config.h" #include "path.h" #include "repository.h" #include "signature.h" @@ -90,21 +91,21 @@ static int advance_until( /* * Parse a single entry from a mailmap file. * - * The output git_bufs will be non-owning, and should be copied before being + * The output git_strs will be non-owning, and should be copied before being * persisted. */ static int parse_mailmap_entry( - git_buf *real_name, git_buf *real_email, - git_buf *replace_name, git_buf *replace_email, + git_str *real_name, git_str *real_email, + git_str *replace_name, git_str *replace_email, git_parse_ctx *ctx) { const char *start; size_t len; - git_buf_clear(real_name); - git_buf_clear(real_email); - git_buf_clear(replace_name); - git_buf_clear(replace_email); + git_str_clear(real_name); + git_str_clear(real_email); + git_str_clear(replace_name); + git_str_clear(replace_email); git_parse_advance_ws(ctx); if (is_eol(ctx)) @@ -114,8 +115,8 @@ static int parse_mailmap_entry( if (advance_until(&start, &len, ctx, '<') < 0) return -1; - git_buf_attach_notowned(real_name, start, len); - git_buf_rtrim(real_name); + git_str_attach_notowned(real_name, start, len); + git_str_rtrim(real_name); /* * If this is the last email in the line, this is the email to replace, @@ -126,19 +127,19 @@ static int parse_mailmap_entry( /* If we aren't at the end of the line, parse a second name and email */ if (!is_eol(ctx)) { - git_buf_attach_notowned(real_email, start, len); + git_str_attach_notowned(real_email, start, len); git_parse_advance_ws(ctx); if (advance_until(&start, &len, ctx, '<') < 0) return -1; - git_buf_attach_notowned(replace_name, start, len); - git_buf_rtrim(replace_name); + git_str_attach_notowned(replace_name, start, len); + git_str_rtrim(replace_name); if (advance_until(&start, &len, ctx, '>') < 0) return -1; } - git_buf_attach_notowned(replace_email, start, len); + git_str_attach_notowned(replace_email, start, len); if (!is_eol(ctx)) return -1; @@ -231,10 +232,10 @@ static int mailmap_add_buffer(git_mailmap *mm, const char *buf, size_t len) git_parse_ctx ctx; /* Scratch buffers containing the real parsed names & emails */ - git_buf real_name = GIT_BUF_INIT; - git_buf real_email = GIT_BUF_INIT; - git_buf replace_name = GIT_BUF_INIT; - git_buf replace_email = GIT_BUF_INIT; + git_str real_name = GIT_STR_INIT; + git_str real_email = GIT_STR_INIT; + git_str replace_name = GIT_STR_INIT; + git_str replace_email = GIT_STR_INIT; /* Buffers may not contain '\0's. */ if (memchr(buf, '\0', len) != NULL) @@ -263,10 +264,10 @@ static int mailmap_add_buffer(git_mailmap *mm, const char *buf, size_t len) } cleanup: - git_buf_dispose(&real_name); - git_buf_dispose(&real_email); - git_buf_dispose(&replace_name); - git_buf_dispose(&replace_email); + git_str_dispose(&real_name); + git_str_dispose(&real_email); + git_str_dispose(&replace_name); + git_str_dispose(&replace_email); return error; } @@ -289,7 +290,7 @@ static int mailmap_add_blob( { git_object *object = NULL; git_blob *blob = NULL; - git_buf content = GIT_BUF_INIT; + git_str content = GIT_STR_INIT; int error; GIT_ASSERT_ARG(mm); @@ -312,7 +313,7 @@ static int mailmap_add_blob( goto cleanup; cleanup: - git_buf_dispose(&content); + git_str_dispose(&content); git_blob_free(blob); git_object_free(object); return error; @@ -322,8 +323,8 @@ static int mailmap_add_file_ondisk( git_mailmap *mm, const char *path, git_repository *repo) { const char *base = repo ? git_repository_workdir(repo) : NULL; - git_buf fullpath = GIT_BUF_INIT; - git_buf content = GIT_BUF_INIT; + git_str fullpath = GIT_STR_INIT; + git_str content = GIT_STR_INIT; int error; error = git_path_join_unrooted(&fullpath, path, base, NULL); @@ -343,8 +344,8 @@ static int mailmap_add_file_ondisk( goto cleanup; cleanup: - git_buf_dispose(&fullpath); - git_buf_dispose(&content); + git_str_dispose(&fullpath); + git_str_dispose(&content); return error; } @@ -352,8 +353,8 @@ cleanup: static void mailmap_add_from_repository(git_mailmap *mm, git_repository *repo) { git_config *config = NULL; - git_buf rev_buf = GIT_BUF_INIT; - git_buf path_buf = GIT_BUF_INIT; + git_str rev_buf = GIT_STR_INIT; + git_str path_buf = GIT_STR_INIT; const char *rev = NULL; const char *path = NULL; @@ -363,9 +364,9 @@ static void mailmap_add_from_repository(git_mailmap *mm, git_repository *repo) /* Try to load 'mailmap.file' and 'mailmap.blob' cfgs from the repo */ if (git_repository_config(&config, repo) == 0) { - if (git_config_get_string_buf(&rev_buf, config, MM_BLOB_CONFIG) == 0) + if (git_config__get_string_buf(&rev_buf, config, MM_BLOB_CONFIG) == 0) rev = rev_buf.ptr; - if (git_config_get_path(&path_buf, config, MM_FILE_CONFIG) == 0) + if (git_config__get_path(&path_buf, config, MM_FILE_CONFIG) == 0) path = path_buf.ptr; } @@ -387,8 +388,8 @@ static void mailmap_add_from_repository(git_mailmap *mm, git_repository *repo) if (path != NULL) mailmap_add_file_ondisk(mm, path, repo); - git_buf_dispose(&rev_buf); - git_buf_dispose(&path_buf); + git_str_dispose(&rev_buf); + git_str_dispose(&path_buf); git_config_free(config); } diff --git a/src/merge.c b/src/merge.c index d838e4ba9..ae1d453ec 100644 --- a/src/merge.c +++ b/src/merge.c @@ -8,7 +8,7 @@ #include "merge.h" #include "posix.h" -#include "buffer.h" +#include "str.h" #include "repository.h" #include "revwalk.h" #include "commit_list.h" @@ -591,7 +591,7 @@ int git_repository_mergehead_foreach( git_repository_mergehead_foreach_cb cb, void *payload) { - git_buf merge_head_path = GIT_BUF_INIT, merge_head_file = GIT_BUF_INIT; + git_str merge_head_path = GIT_STR_INIT, merge_head_file = GIT_STR_INIT; char *buffer, *line; size_t line_num = 1; git_oid oid; @@ -600,12 +600,12 @@ int git_repository_mergehead_foreach( GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(cb); - if ((error = git_buf_joinpath(&merge_head_path, repo->gitdir, + if ((error = git_str_joinpath(&merge_head_path, repo->gitdir, GIT_MERGE_HEAD_FILE)) < 0) return error; if ((error = git_futils_readbuffer(&merge_head_file, - git_buf_cstr(&merge_head_path))) < 0) + git_str_cstr(&merge_head_path))) < 0) goto cleanup; buffer = merge_head_file.ptr; @@ -635,8 +635,8 @@ int git_repository_mergehead_foreach( } cleanup: - git_buf_dispose(&merge_head_path); - git_buf_dispose(&merge_head_file); + git_str_dispose(&merge_head_path); + git_str_dispose(&merge_head_file); return error; } @@ -893,7 +893,7 @@ static int merge_conflict_invoke_driver( git_merge_driver_source *src) { git_index_entry *result; - git_buf buf = GIT_BUF_INIT; + git_buf buf = {0}; const char *path; uint32_t mode; git_odb *odb = NULL; @@ -2473,14 +2473,14 @@ static int write_merge_head( size_t heads_len) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; size_t i; int error = 0; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(heads); - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_HEAD_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_HEAD_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0) goto cleanup; @@ -2495,7 +2495,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -2503,12 +2503,12 @@ cleanup: static int write_merge_mode(git_repository *repo) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; int error = 0; GIT_ASSERT_ARG(repo); - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MODE_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MODE_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0) goto cleanup; @@ -2521,7 +2521,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -2719,7 +2719,7 @@ static int write_merge_msg( size_t heads_len) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; struct merge_msg_entry *entries; git_vector matching = GIT_VECTOR_INIT; size_t i; @@ -2740,7 +2740,7 @@ static int write_merge_msg( for (i = 0; i < heads_len; i++) entries[i].merge_head = heads[i]; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) < 0 || (error = git_filebuf_write(&file, "Merge ", 6)) < 0) goto cleanup; @@ -2822,7 +2822,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); git_vector_free(&matching); git__free(entries); @@ -3114,7 +3114,7 @@ int git_merge__append_conflicts_to_merge_msg( git_index *index) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; const char *last = NULL; size_t i; int error; @@ -3122,7 +3122,7 @@ int git_merge__append_conflicts_to_merge_msg( if (!git_index_has_conflicts(index)) return 0; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_APPEND, GIT_MERGE_FILE_MODE)) < 0) goto cleanup; @@ -3146,7 +3146,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } diff --git a/src/merge_driver.c b/src/merge_driver.c index 17c386a14..be4d3bf8a 100644 --- a/src/merge_driver.c +++ b/src/merge_driver.c @@ -110,7 +110,7 @@ int git_merge_driver__builtin_apply( merged_out->ptr = (char *)result.ptr; merged_out->size = result.len; - merged_out->asize = result.len; + merged_out->reserved = 0; result.ptr = NULL; done: diff --git a/src/message.c b/src/message.c index 327b984fc..ec0103a33 100644 --- a/src/message.c +++ b/src/message.c @@ -5,7 +5,9 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "message.h" +#include "buf.h" + +#include "git2/message.h" static size_t line_length_without_trailing_spaces(const char *line, size_t len) { @@ -21,17 +23,17 @@ static size_t line_length_without_trailing_spaces(const char *line, size_t len) /* Greatly inspired from git.git "stripspace" */ /* see https://github.com/git/git/blob/497215d8811ac7b8955693ceaad0899ecd894ed2/builtin/stripspace.c#L4-67 */ -int git_message_prettify(git_buf *message_out, const char *message, int strip_comments, char comment_char) +static int git_message__prettify( + git_str *message_out, + const char *message, + int strip_comments, + char comment_char) { const size_t message_len = strlen(message); int consecutive_empty_lines = 0; size_t i, line_length, rtrimmed_line_length; char *next_newline; - int error; - - if ((error = git_buf_sanitize(message_out)) < 0) - return error; for (i = 0; i < strlen(message); i += line_length) { next_newline = memchr(message + i, '\n', message_len - i); @@ -53,12 +55,21 @@ int git_message_prettify(git_buf *message_out, const char *message, int strip_co } if (consecutive_empty_lines > 0 && message_out->size > 0) - git_buf_putc(message_out, '\n'); + git_str_putc(message_out, '\n'); consecutive_empty_lines = 0; - git_buf_put(message_out, message + i, rtrimmed_line_length); - git_buf_putc(message_out, '\n'); + git_str_put(message_out, message + i, rtrimmed_line_length); + git_str_putc(message_out, '\n'); } - return git_buf_oom(message_out) ? -1 : 0; + return git_str_oom(message_out) ? -1 : 0; +} + +int git_message_prettify( + git_buf *message_out, + const char *message, + int strip_comments, + char comment_char) +{ + GIT_BUF_WRAP_PRIVATE(message_out, git_message__prettify, message, strip_comments, comment_char); } diff --git a/src/midx.c b/src/midx.c index cd3c98cef..b8da98986 100644 --- a/src/midx.c +++ b/src/midx.c @@ -8,7 +8,7 @@ #include "midx.h" #include "array.h" -#include "buffer.h" +#include "buf.h" #include "filebuf.h" #include "futils.h" #include "hash.h" @@ -16,6 +16,7 @@ #include "pack.h" #include "path.h" #include "repository.h" +#include "str.h" #define MIDX_SIGNATURE 0x4d494458 /* "MIDX" */ #define MIDX_VERSION 1 @@ -313,7 +314,7 @@ int git_midx_open( idx = git__calloc(1, sizeof(git_midx_file)); GIT_ERROR_CHECK_ALLOC(idx); - error = git_buf_sets(&idx->filename, path); + error = git_str_sets(&idx->filename, path); if (error < 0) return error; @@ -477,7 +478,7 @@ void git_midx_free(git_midx_file *idx) if (!idx) return; - git_buf_dispose(&idx->filename); + git_str_dispose(&idx->filename); git_midx_close(idx); git__free(idx); } @@ -497,14 +498,14 @@ int git_midx_writer_new( git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer)); GIT_ERROR_CHECK_ALLOC(w); - if (git_buf_sets(&w->pack_dir, pack_dir) < 0) { + if (git_str_sets(&w->pack_dir, pack_dir) < 0) { git__free(w); return -1; } git_path_squash_slashes(&w->pack_dir); if (git_vector_init(&w->packs, 0, packfile__cmp) < 0) { - git_buf_dispose(&w->pack_dir); + git_str_dispose(&w->pack_dir); git__free(w); return -1; } @@ -524,7 +525,7 @@ void git_midx_writer_free(git_midx_writer *w) git_vector_foreach (&w->packs, i, p) git_mwindow_put_pack(p); git_vector_free(&w->packs); - git_buf_dispose(&w->pack_dir); + git_str_dispose(&w->pack_dir); git__free(w); } @@ -532,16 +533,16 @@ int git_midx_writer_add( git_midx_writer *w, const char *idx_path) { - git_buf idx_path_buf = GIT_BUF_INIT; + git_str idx_path_buf = GIT_STR_INIT; int error; struct git_pack_file *p; - error = git_path_prettify(&idx_path_buf, idx_path, git_buf_cstr(&w->pack_dir)); + error = git_path_prettify(&idx_path_buf, idx_path, git_str_cstr(&w->pack_dir)); if (error < 0) return error; - error = git_mwindow_get_pack(&p, git_buf_cstr(&idx_path_buf)); - git_buf_dispose(&idx_path_buf); + error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf)); + git_str_dispose(&idx_path_buf); if (error < 0) return error; @@ -613,8 +614,8 @@ static int write_chunk_header(int chunk_id, off64_t offset, midx_write_cb write_ static int midx_write_buf(const char *buf, size_t size, void *data) { - git_buf *b = (git_buf *)data; - return git_buf_put(b, buf, size); + git_str *b = (git_str *)data; + return git_str_put(b, buf, size); } struct midx_write_hash_context { @@ -648,10 +649,10 @@ static int midx_write( uint32_t object_large_offsets_count; uint32_t oid_fanout[256]; off64_t offset; - git_buf packfile_names = GIT_BUF_INIT, - oid_lookup = GIT_BUF_INIT, - object_offsets = GIT_BUF_INIT, - object_large_offsets = GIT_BUF_INIT; + git_str packfile_names = GIT_STR_INIT, + oid_lookup = GIT_STR_INIT, + object_offsets = GIT_STR_INIT, + object_large_offsets = GIT_STR_INIT; git_oid idx_checksum = {{0}}; git_midx_entry *entry; object_entry_array_t object_entries_array = GIT_ARRAY_INIT; @@ -676,34 +677,34 @@ static int midx_write( git_vector_sort(&w->packs); git_vector_foreach (&w->packs, i, p) { - git_buf relative_index = GIT_BUF_INIT; + git_str relative_index = GIT_STR_INIT; struct object_entry_cb_state state = {0}; size_t path_len; state.pack_index = (uint32_t)i; state.object_entries_array = &object_entries_array; - error = git_buf_sets(&relative_index, p->pack_name); + error = git_str_sets(&relative_index, p->pack_name); if (error < 0) goto cleanup; - error = git_path_make_relative(&relative_index, git_buf_cstr(&w->pack_dir)); + error = git_path_make_relative(&relative_index, git_str_cstr(&w->pack_dir)); if (error < 0) { - git_buf_dispose(&relative_index); + git_str_dispose(&relative_index); goto cleanup; } - path_len = git_buf_len(&relative_index); - if (path_len <= strlen(".pack") || git__suffixcmp(git_buf_cstr(&relative_index), ".pack") != 0) { - git_buf_dispose(&relative_index); + path_len = git_str_len(&relative_index); + if (path_len <= strlen(".pack") || git__suffixcmp(git_str_cstr(&relative_index), ".pack") != 0) { + git_str_dispose(&relative_index); git_error_set(GIT_ERROR_INVALID, "invalid packfile name: '%s'", p->pack_name); error = -1; goto cleanup; } path_len -= strlen(".pack"); - git_buf_put(&packfile_names, git_buf_cstr(&relative_index), path_len); - git_buf_puts(&packfile_names, ".idx"); - git_buf_putc(&packfile_names, '\0'); - git_buf_dispose(&relative_index); + git_str_put(&packfile_names, git_str_cstr(&relative_index), path_len); + git_str_puts(&packfile_names, ".idx"); + git_str_putc(&packfile_names, '\0'); + git_str_dispose(&relative_index); error = git_pack_foreach_entry_offset(p, object_entry__cb, &state); if (error < 0) @@ -723,8 +724,8 @@ static int midx_write( git_vector_uniq(&object_entries, NULL); /* Pad the packfile names so it is a multiple of four. */ - while (git_buf_len(&packfile_names) & 3) - git_buf_putc(&packfile_names, '\0'); + while (git_str_len(&packfile_names) & 3) + git_str_putc(&packfile_names, '\0'); /* Fill the OID Fanout table. */ oid_fanout_count = 0; @@ -737,7 +738,7 @@ static int midx_write( /* Fill the OID Lookup table. */ git_vector_foreach (&object_entries, i, entry) { - error = git_buf_put(&oid_lookup, (const char *)&entry->sha1, sizeof(entry->sha1)); + error = git_str_put(&oid_lookup, (const char *)&entry->sha1, sizeof(entry->sha1)); if (error < 0) goto cleanup; } @@ -748,7 +749,7 @@ static int midx_write( uint32_t word; word = htonl((uint32_t)entry->pack_index); - error = git_buf_put(&object_offsets, (const char *)&word, sizeof(word)); + error = git_str_put(&object_offsets, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; if (entry->offset >= 0x80000000l) { @@ -759,7 +760,7 @@ static int midx_write( word = htonl((uint32_t)entry->offset & 0x7fffffffu); } - error = git_buf_put(&object_offsets, (const char *)&word, sizeof(word)); + error = git_str_put(&object_offsets, (const char *)&word, sizeof(word)); if (error < 0) goto cleanup; } @@ -767,7 +768,7 @@ static int midx_write( /* Write the header. */ hdr.packfiles = htonl((uint32_t)git_vector_length(&w->packs)); hdr.chunks = 4; - if (git_buf_len(&object_large_offsets) > 0) + if (git_str_len(&object_large_offsets) > 0) hdr.chunks++; error = write_cb((const char *)&hdr, sizeof(hdr), cb_data); if (error < 0) @@ -778,7 +779,7 @@ static int midx_write( error = write_chunk_header(MIDX_PACKFILE_NAMES_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&packfile_names); + offset += git_str_len(&packfile_names); error = write_chunk_header(MIDX_OID_FANOUT_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; @@ -786,35 +787,35 @@ static int midx_write( error = write_chunk_header(MIDX_OID_LOOKUP_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&oid_lookup); + offset += git_str_len(&oid_lookup); error = write_chunk_header(MIDX_OBJECT_OFFSETS_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&object_offsets); - if (git_buf_len(&object_large_offsets) > 0) { + offset += git_str_len(&object_offsets); + if (git_str_len(&object_large_offsets) > 0) { error = write_chunk_header(MIDX_OBJECT_LARGE_OFFSETS_ID, offset, write_cb, cb_data); if (error < 0) goto cleanup; - offset += git_buf_len(&object_large_offsets); + offset += git_str_len(&object_large_offsets); } error = write_chunk_header(0, offset, write_cb, cb_data); if (error < 0) goto cleanup; /* Write all the chunks. */ - error = write_cb(git_buf_cstr(&packfile_names), git_buf_len(&packfile_names), cb_data); + error = write_cb(git_str_cstr(&packfile_names), git_str_len(&packfile_names), cb_data); if (error < 0) goto cleanup; error = write_cb((const char *)oid_fanout, sizeof(oid_fanout), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&oid_lookup), git_buf_len(&oid_lookup), cb_data); + error = write_cb(git_str_cstr(&oid_lookup), git_str_len(&oid_lookup), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&object_offsets), git_buf_len(&object_offsets), cb_data); + error = write_cb(git_str_cstr(&object_offsets), git_str_len(&object_offsets), cb_data); if (error < 0) goto cleanup; - error = write_cb(git_buf_cstr(&object_large_offsets), git_buf_len(&object_large_offsets), cb_data); + error = write_cb(git_str_cstr(&object_large_offsets), git_str_len(&object_large_offsets), cb_data); if (error < 0) goto cleanup; @@ -829,10 +830,10 @@ static int midx_write( cleanup: git_array_clear(object_entries_array); git_vector_free(&object_entries); - git_buf_dispose(&packfile_names); - git_buf_dispose(&oid_lookup); - git_buf_dispose(&object_offsets); - git_buf_dispose(&object_large_offsets); + git_str_dispose(&packfile_names); + git_str_dispose(&oid_lookup); + git_str_dispose(&object_offsets); + git_str_dispose(&object_large_offsets); git_hash_ctx_cleanup(&ctx); return error; } @@ -848,17 +849,17 @@ int git_midx_writer_commit( { int error; int filebuf_flags = GIT_FILEBUF_DO_NOT_BUFFER; - git_buf midx_path = GIT_BUF_INIT; + git_str midx_path = GIT_STR_INIT; git_filebuf output = GIT_FILEBUF_INIT; - error = git_buf_joinpath(&midx_path, git_buf_cstr(&w->pack_dir), "multi-pack-index"); + error = git_str_joinpath(&midx_path, git_str_cstr(&w->pack_dir), "multi-pack-index"); if (error < 0) return error; if (git_repository__fsync_gitdir) filebuf_flags |= GIT_FILEBUF_FSYNC; - error = git_filebuf_open(&output, git_buf_cstr(&midx_path), filebuf_flags, 0644); - git_buf_dispose(&midx_path); + error = git_filebuf_open(&output, git_str_cstr(&midx_path), filebuf_flags, 0644); + git_str_dispose(&midx_path); if (error < 0) return error; @@ -875,5 +876,13 @@ int git_midx_writer_dump( git_buf *midx, git_midx_writer *w) { - return midx_write(w, midx_write_buf, midx); + git_str str = GIT_STR_INIT; + int error; + + if ((error = git_buf_tostr(&str, midx)) < 0 || + (error = midx_write(w, midx_write_buf, &str)) == 0) + error = git_buf_fromstr(midx, &str); + + git_str_dispose(&str); + return error; } diff --git a/src/midx.h b/src/midx.h index 4ce17ce73..ef3d534bc 100644 --- a/src/midx.h +++ b/src/midx.h @@ -54,7 +54,7 @@ typedef struct git_midx_file { git_oid checksum; /* something like ".git/objects/pack/multi-pack-index". */ - git_buf filename; + git_str filename; } git_midx_file; /* @@ -77,7 +77,7 @@ struct git_midx_writer { * The path of the directory where the .pack/.idx files are stored. The * `multi-pack-index` file will be written to the same directory. */ - git_buf pack_dir; + git_str pack_dir; /* The list of `git_pack_file`s. */ git_vector packs; @@ -12,7 +12,7 @@ #include "git2/errors.h" #include "posix.h" -#include "buffer.h" +#include "str.h" #include "http_parser.h" #include "runtime.h" @@ -79,13 +79,13 @@ int git_net_url_parse(git_net_url *url, const char *given) { struct http_parser_url u = {0}; bool has_scheme, has_host, has_port, has_path, has_query, has_userinfo; - git_buf scheme = GIT_BUF_INIT, - host = GIT_BUF_INIT, - port = GIT_BUF_INIT, - path = GIT_BUF_INIT, - username = GIT_BUF_INIT, - password = GIT_BUF_INIT, - query = GIT_BUF_INIT; + git_str scheme = GIT_STR_INIT, + host = GIT_STR_INIT, + port = GIT_STR_INIT, + path = GIT_STR_INIT, + username = GIT_STR_INIT, + password = GIT_STR_INIT, + query = GIT_STR_INIT; int error = GIT_EINVALIDSPEC; if (http_parser_parse_url(given, strlen(given), false, &u)) { @@ -103,7 +103,7 @@ int git_net_url_parse(git_net_url *url, const char *given) if (has_scheme) { const char *url_scheme = given + u.field_data[UF_SCHEMA].off; size_t url_scheme_len = u.field_data[UF_SCHEMA].len; - git_buf_put(&scheme, url_scheme, url_scheme_len); + git_str_put(&scheme, url_scheme, url_scheme_len); git__strntolower(scheme.ptr, scheme.size); } else { git_error_set(GIT_ERROR_NET, "malformed URL '%s'", given); @@ -113,13 +113,13 @@ int git_net_url_parse(git_net_url *url, const char *given) if (has_host) { const char *url_host = given + u.field_data[UF_HOST].off; size_t url_host_len = u.field_data[UF_HOST].len; - git_buf_decode_percent(&host, url_host, url_host_len); + git_str_decode_percent(&host, url_host, url_host_len); } if (has_port) { const char *url_port = given + u.field_data[UF_PORT].off; size_t url_port_len = u.field_data[UF_PORT].len; - git_buf_put(&port, url_port, url_port_len); + git_str_put(&port, url_port, url_port_len); } else { const char *default_port = default_port_for_scheme(scheme.ptr); @@ -128,21 +128,21 @@ int git_net_url_parse(git_net_url *url, const char *given) goto done; } - git_buf_puts(&port, default_port); + git_str_puts(&port, default_port); } if (has_path) { const char *url_path = given + u.field_data[UF_PATH].off; size_t url_path_len = u.field_data[UF_PATH].len; - git_buf_put(&path, url_path, url_path_len); + git_str_put(&path, url_path, url_path_len); } else { - git_buf_puts(&path, "/"); + git_str_puts(&path, "/"); } if (has_query) { const char *url_query = given + u.field_data[UF_QUERY].off; size_t url_query_len = u.field_data[UF_QUERY].len; - git_buf_decode_percent(&query, url_query, url_query_len); + git_str_decode_percent(&query, url_query, url_query_len); } if (has_userinfo) { @@ -156,40 +156,40 @@ int git_net_url_parse(git_net_url *url, const char *given) const char *url_password = colon + 1; size_t url_password_len = url_userinfo_len - (url_username_len + 1); - git_buf_decode_percent(&username, url_username, url_username_len); - git_buf_decode_percent(&password, url_password, url_password_len); + git_str_decode_percent(&username, url_username, url_username_len); + git_str_decode_percent(&password, url_password, url_password_len); } else { - git_buf_decode_percent(&username, url_userinfo, url_userinfo_len); + git_str_decode_percent(&username, url_userinfo, url_userinfo_len); } } - if (git_buf_oom(&scheme) || - git_buf_oom(&host) || - git_buf_oom(&port) || - git_buf_oom(&path) || - git_buf_oom(&query) || - git_buf_oom(&username) || - git_buf_oom(&password)) + if (git_str_oom(&scheme) || + git_str_oom(&host) || + git_str_oom(&port) || + git_str_oom(&path) || + git_str_oom(&query) || + git_str_oom(&username) || + git_str_oom(&password)) return -1; - url->scheme = git_buf_detach(&scheme); - url->host = git_buf_detach(&host); - url->port = git_buf_detach(&port); - url->path = git_buf_detach(&path); - url->query = git_buf_detach(&query); - url->username = git_buf_detach(&username); - url->password = git_buf_detach(&password); + url->scheme = git_str_detach(&scheme); + url->host = git_str_detach(&host); + url->port = git_str_detach(&port); + url->path = git_str_detach(&path); + url->query = git_str_detach(&query); + url->username = git_str_detach(&username); + url->password = git_str_detach(&password); error = 0; done: - git_buf_dispose(&scheme); - git_buf_dispose(&host); - git_buf_dispose(&port); - git_buf_dispose(&path); - git_buf_dispose(&query); - git_buf_dispose(&username); - git_buf_dispose(&password); + git_str_dispose(&scheme); + git_str_dispose(&host); + git_str_dispose(&port); + git_str_dispose(&path); + git_str_dispose(&query); + git_str_dispose(&username); + git_str_dispose(&password); return error; } @@ -198,7 +198,7 @@ int git_net_url_joinpath( git_net_url *one, const char *two) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; const char *query; size_t one_len, two_len; @@ -226,14 +226,14 @@ int git_net_url_joinpath( two_len--; } - git_buf_put(&path, one->path, one_len); - git_buf_putc(&path, '/'); - git_buf_put(&path, two, two_len); + git_str_put(&path, one->path, one_len); + git_str_putc(&path, '/'); + git_str_put(&path, two, two_len); - if (git_buf_oom(&path)) + if (git_str_oom(&path)) return -1; - out->path = git_buf_detach(&path); + out->path = git_str_detach(&path); if (one->scheme) { out->scheme = git__strdup(one->scheme); @@ -399,53 +399,53 @@ void git_net_url_swap(git_net_url *a, git_net_url *b) memcpy(b, &tmp, sizeof(git_net_url)); } -int git_net_url_fmt(git_buf *buf, git_net_url *url) +int git_net_url_fmt(git_str *buf, git_net_url *url) { GIT_ASSERT_ARG(url); GIT_ASSERT_ARG(url->scheme); GIT_ASSERT_ARG(url->host); - git_buf_puts(buf, url->scheme); - git_buf_puts(buf, "://"); + git_str_puts(buf, url->scheme); + git_str_puts(buf, "://"); if (url->username) { - git_buf_puts(buf, url->username); + git_str_puts(buf, url->username); if (url->password) { - git_buf_puts(buf, ":"); - git_buf_puts(buf, url->password); + git_str_puts(buf, ":"); + git_str_puts(buf, url->password); } - git_buf_putc(buf, '@'); + git_str_putc(buf, '@'); } - git_buf_puts(buf, url->host); + git_str_puts(buf, url->host); if (url->port && !git_net_url_is_default_port(url)) { - git_buf_putc(buf, ':'); - git_buf_puts(buf, url->port); + git_str_putc(buf, ':'); + git_str_puts(buf, url->port); } - git_buf_puts(buf, url->path ? url->path : "/"); + git_str_puts(buf, url->path ? url->path : "/"); if (url->query) { - git_buf_putc(buf, '?'); - git_buf_puts(buf, url->query); + git_str_putc(buf, '?'); + git_str_puts(buf, url->query); } - return git_buf_oom(buf) ? -1 : 0; + return git_str_oom(buf) ? -1 : 0; } -int git_net_url_fmt_path(git_buf *buf, git_net_url *url) +int git_net_url_fmt_path(git_str *buf, git_net_url *url) { - git_buf_puts(buf, url->path ? url->path : "/"); + git_str_puts(buf, url->path ? url->path : "/"); if (url->query) { - git_buf_putc(buf, '?'); - git_buf_puts(buf, url->query); + git_str_putc(buf, '?'); + git_str_puts(buf, url->query); } - return git_buf_oom(buf) ? -1 : 0; + return git_str_oom(buf) ? -1 : 0; } static bool matches_pattern( @@ -52,10 +52,10 @@ extern int git_net_url_apply_redirect( extern void git_net_url_swap(git_net_url *a, git_net_url *b); /** Places the URL into the given buffer. */ -extern int git_net_url_fmt(git_buf *out, git_net_url *url); +extern int git_net_url_fmt(git_str *out, git_net_url *url); /** Place the path and query string into the given buffer. */ -extern int git_net_url_fmt_path(git_buf *buf, git_net_url *url); +extern int git_net_url_fmt_path(git_str *buf, git_net_url *url); /** Determines if the url matches given pattern or pattern list */ extern bool git_net_url_matches_pattern( diff --git a/src/netops.c b/src/netops.c index a1ee2927c..0a27365b8 100644 --- a/src/netops.c +++ b/src/netops.c @@ -11,7 +11,7 @@ #include "git2/errors.h" #include "posix.h" -#include "buffer.h" +#include "str.h" #include "http_parser.h" #include "runtime.h" diff --git a/src/notes.c b/src/notes.c index 95db334fb..d1a2b0f64 100644 --- a/src/notes.c +++ b/src/notes.c @@ -7,7 +7,7 @@ #include "notes.h" -#include "git2.h" +#include "buf.h" #include "refs.h" #include "config.h" #include "iterator.h" @@ -407,7 +407,7 @@ cleanup: return error; } -static int note_get_default_ref(git_buf *out, git_repository *repo) +static int note_get_default_ref(git_str *out, git_repository *repo) { git_config *cfg; int error; @@ -415,25 +415,25 @@ static int note_get_default_ref(git_buf *out, git_repository *repo) if ((error = git_repository_config__weakptr(&cfg, repo)) < 0) return error; - error = git_config_get_string_buf(out, cfg, "core.notesref"); + error = git_config__get_string_buf(out, cfg, "core.notesref"); if (error == GIT_ENOTFOUND) - error = git_buf_puts(out, GIT_NOTES_DEFAULT_REF); + error = git_str_puts(out, GIT_NOTES_DEFAULT_REF); return error; } -static int normalize_namespace(git_buf *out, git_repository *repo, const char *notes_ref) +static int normalize_namespace(git_str *out, git_repository *repo, const char *notes_ref) { if (notes_ref) - return git_buf_puts(out, notes_ref); + return git_str_puts(out, notes_ref); return note_get_default_ref(out, repo); } static int retrieve_note_commit( git_commit **commit_out, - git_buf *notes_ref_out, + git_str *notes_ref_out, git_repository *repo, const char *notes_ref) { @@ -478,7 +478,7 @@ int git_note_read(git_note **out, git_repository *repo, const char *notes_ref_in, const git_oid *oid) { int error; - git_buf notes_ref = GIT_BUF_INIT; + git_str notes_ref = GIT_STR_INIT; git_commit *commit = NULL; error = retrieve_note_commit(&commit, ¬es_ref, repo, notes_ref_in); @@ -489,7 +489,7 @@ int git_note_read(git_note **out, git_repository *repo, error = git_note_commit_read(out, repo, commit, oid); cleanup: - git_buf_dispose(¬es_ref); + git_str_dispose(¬es_ref); git_commit_free(commit); return error; } @@ -536,7 +536,7 @@ int git_note_create( int allow_note_overwrite) { int error; - git_buf notes_ref = GIT_BUF_INIT; + git_str notes_ref = GIT_STR_INIT; git_commit *existing_notes_commit = NULL; git_reference *ref = NULL; git_oid notes_blob_oid, notes_commit_oid; @@ -562,7 +562,7 @@ int git_note_create( git_oid_cpy(out, ¬es_blob_oid); cleanup: - git_buf_dispose(¬es_ref); + git_str_dispose(¬es_ref); git_commit_free(existing_notes_commit); git_reference_free(ref); return error; @@ -598,7 +598,7 @@ int git_note_remove(git_repository *repo, const char *notes_ref_in, const git_oid *oid) { int error; - git_buf notes_ref_target = GIT_BUF_INIT; + git_str notes_ref_target = GIT_STR_INIT; git_commit *existing_notes_commit = NULL; git_oid new_notes_commit; git_reference *notes_ref = NULL; @@ -618,7 +618,7 @@ int git_note_remove(git_repository *repo, const char *notes_ref_in, &new_notes_commit, 1, NULL); cleanup: - git_buf_dispose(¬es_ref_target); + git_str_dispose(¬es_ref_target); git_reference_free(notes_ref); git_commit_free(existing_notes_commit); return error; @@ -626,16 +626,7 @@ cleanup: int git_note_default_ref(git_buf *out, git_repository *repo) { - int error; - - GIT_ASSERT_ARG(out); - GIT_ASSERT_ARG(repo); - - if ((error = git_buf_sanitize(out)) < 0 || - (error = note_get_default_ref(out, repo)) < 0) - git_buf_dispose(out); - - return error; + GIT_BUF_WRAP_PRIVATE(out, note_get_default_ref, repo); } const git_signature *git_note_committer(const git_note *note) @@ -679,12 +670,12 @@ static int process_entry_path( { int error = 0; size_t i = 0, j = 0, len; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; - if ((error = git_buf_puts(&buf, entry_path)) < 0) + if ((error = git_str_puts(&buf, entry_path)) < 0) goto cleanup; - len = git_buf_len(&buf); + len = git_str_len(&buf); while (i < len) { if (buf.ptr[i] == '/') { @@ -715,7 +706,7 @@ static int process_entry_path( error = git_oid_fromstr(annotated_object_id, buf.ptr); cleanup: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -780,7 +771,7 @@ int git_note_iterator_new( { int error; git_commit *commit = NULL; - git_buf notes_ref = GIT_BUF_INIT; + git_str notes_ref = GIT_STR_INIT; error = retrieve_note_commit(&commit, ¬es_ref, repo, notes_ref_in); if (error < 0) @@ -789,7 +780,7 @@ int git_note_iterator_new( error = git_note_commit_iterator_new(it, commit); cleanup: - git_buf_dispose(¬es_ref); + git_str_dispose(¬es_ref); git_commit_free(commit); return error; diff --git a/src/object.c b/src/object.c index 42e1e46bc..fb861e9e1 100644 --- a/src/object.c +++ b/src/object.c @@ -11,6 +11,7 @@ #include "repository.h" +#include "buf.h" #include "commit.h" #include "hash.h" #include "tree.h" @@ -491,7 +492,7 @@ cleanup: return error; } -int git_object_short_id(git_buf *out, const git_object *obj) +static int git_object__short_id(git_str *out, const git_object *obj) { git_repository *repo; int len = GIT_ABBREV_DEFAULT, error; @@ -501,9 +502,6 @@ int git_object_short_id(git_buf *out, const git_object *obj) GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(obj); - if ((error = git_buf_sanitize(out)) < 0) - return error; - repo = git_object_owner(obj); if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0) @@ -526,7 +524,7 @@ int git_object_short_id(git_buf *out, const git_object *obj) len++; } - if (!error && !(error = git_buf_grow(out, len + 1))) { + if (!error && !(error = git_str_grow(out, len + 1))) { git_oid_tostr(out->ptr, len + 1, &id); out->size = len; } @@ -536,6 +534,11 @@ int git_object_short_id(git_buf *out, const git_object *obj) return error; } +int git_object_short_id(git_buf *out, const git_object *obj) +{ + GIT_BUF_WRAP_PRIVATE(out, git_object__short_id, obj); +} + bool git_object__is_valid( git_repository *repo, const git_oid *id, git_object_t expected_type) { diff --git a/src/object.h b/src/object.h index 4b6793612..66be57557 100644 --- a/src/object.h +++ b/src/object.h @@ -47,7 +47,7 @@ git_object_t git_object_stringn2type(const char *str, size_t len); int git_oid__parse(git_oid *oid, const char **buffer_out, const char *buffer_end, const char *header); -void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid); +void git_oid__writebuf(git_str *buf, const char *header, const git_oid *oid); bool git_object__is_valid( git_repository *repo, const git_oid *id, git_object_t expected_type); @@ -109,7 +109,7 @@ int git_odb__format_object_header( int git_odb__hashobj(git_oid *id, git_rawobj *obj) { - git_buf_vec vec[2]; + git_str_vec vec[2]; char header[64]; size_t hdrlen; int error; @@ -248,7 +248,7 @@ int git_odb__hashfd_filtered( git_oid *out, git_file fd, size_t size, git_object_t type, git_filter_list *fl) { int error; - git_buf raw = GIT_BUF_INIT; + git_str raw = GIT_STR_INIT; if (!fl) return git_odb__hashfd(out, fd, size, type); @@ -258,14 +258,14 @@ int git_odb__hashfd_filtered( */ if (!(error = git_futils_readbuffer_fd(&raw, fd, size))) { - git_buf post = GIT_BUF_INIT; + git_str post = GIT_STR_INIT; error = git_filter_list__convert_buf(&post, fl, &raw); if (!error) error = git_odb_hash(out, post.ptr, post.size, type); - git_buf_dispose(&post); + git_str_dispose(&post); } return error; @@ -636,8 +636,8 @@ int git_odb__add_default_backends( static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_depth) { - git_buf alternates_path = GIT_BUF_INIT; - git_buf alternates_buf = GIT_BUF_INIT; + git_str alternates_path = GIT_STR_INIT; + git_str alternates_buf = GIT_STR_INIT; char *buffer; const char *alternate; int result = 0; @@ -646,16 +646,16 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_ if (alternate_depth > GIT_ALTERNATES_MAX_DEPTH) return 0; - if (git_buf_joinpath(&alternates_path, objects_dir, GIT_ALTERNATES_FILE) < 0) + if (git_str_joinpath(&alternates_path, objects_dir, GIT_ALTERNATES_FILE) < 0) return -1; if (git_path_exists(alternates_path.ptr) == false) { - git_buf_dispose(&alternates_path); + git_str_dispose(&alternates_path); return 0; } if (git_futils_readbuffer(&alternates_buf, alternates_path.ptr) < 0) { - git_buf_dispose(&alternates_path); + git_str_dispose(&alternates_path); return -1; } @@ -672,17 +672,17 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_ * the current repository. */ if (*alternate == '.' && !alternate_depth) { - if ((result = git_buf_joinpath(&alternates_path, objects_dir, alternate)) < 0) + if ((result = git_str_joinpath(&alternates_path, objects_dir, alternate)) < 0) break; - alternate = git_buf_cstr(&alternates_path); + alternate = git_str_cstr(&alternates_path); } if ((result = git_odb__add_default_backends(odb, alternate, true, alternate_depth + 1)) < 0) break; } - git_buf_dispose(&alternates_path); - git_buf_dispose(&alternates_buf); + git_str_dispose(&alternates_path); + git_str_dispose(&alternates_buf); return result; } @@ -1337,15 +1337,15 @@ static int read_prefix_1(git_odb_object **out, git_odb *db, data = raw.data; if (found && git_oid__cmp(&full_oid, &found_full_oid)) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; - git_buf_printf(&buf, "multiple matches for prefix: %s", + git_str_printf(&buf, "multiple matches for prefix: %s", git_oid_tostr_s(&full_oid)); - git_buf_printf(&buf, " %s", + git_str_printf(&buf, " %s", git_oid_tostr_s(&found_full_oid)); error = git_odb__error_ambiguous(buf.ptr); - git_buf_dispose(&buf); + git_str_dispose(&buf); git_mutex_unlock(&db->lock); goto out; } diff --git a/src/odb_loose.c b/src/odb_loose.c index 1f8a0bb21..f0c3ac2c8 100644 --- a/src/odb_loose.c +++ b/src/odb_loose.c @@ -76,17 +76,17 @@ typedef struct { ***********************************************************/ static int object_file_name( - git_buf *name, const loose_backend *be, const git_oid *id) + git_str *name, const loose_backend *be, const git_oid *id) { size_t alloclen; /* expand length for object root + 40 hex sha1 chars + 2 * '/' + '\0' */ GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, be->objects_dirlen, GIT_OID_HEXSZ); GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 3); - if (git_buf_grow(name, alloclen) < 0) + if (git_str_grow(name, alloclen) < 0) return -1; - git_buf_set(name, be->objects_dir, be->objects_dirlen); + git_str_set(name, be->objects_dir, be->objects_dirlen); git_path_to_dir(name); /* loose object filename: aa/aaa... (41 bytes) */ @@ -97,7 +97,7 @@ static int object_file_name( return 0; } -static int object_mkdir(const git_buf *name, const loose_backend *be) +static int object_mkdir(const git_str *name, const loose_backend *be) { return git_futils_mkdir_relative( name->ptr + be->objects_dirlen, be->objects_dir, be->object_dir_mode, @@ -222,9 +222,9 @@ static int is_zlib_compressed_data(unsigned char *data, size_t data_len) * of loose object data into packs. This format is no longer used, but * we must still read it. */ -static int read_loose_packlike(git_rawobj *out, git_buf *obj) +static int read_loose_packlike(git_rawobj *out, git_str *obj) { - git_buf body = GIT_BUF_INIT; + git_str body = GIT_STR_INIT; const unsigned char *obj_data; obj_hdr hdr; size_t obj_len, head_len, alloc_size; @@ -253,7 +253,7 @@ static int read_loose_packlike(git_rawobj *out, git_buf *obj) * allocate a buffer and inflate the data into it */ if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, hdr.size, 1) || - git_buf_init(&body, alloc_size) < 0) { + git_str_init(&body, alloc_size) < 0) { error = -1; goto done; } @@ -263,14 +263,14 @@ static int read_loose_packlike(git_rawobj *out, git_buf *obj) out->len = hdr.size; out->type = hdr.type; - out->data = git_buf_detach(&body); + out->data = git_str_detach(&body); done: - git_buf_dispose(&body); + git_str_dispose(&body); return error; } -static int read_loose_standard(git_rawobj *out, git_buf *obj) +static int read_loose_standard(git_rawobj *out, git_str *obj) { git_zstream zstream = GIT_ZSTREAM_INIT; unsigned char head[MAX_HEADER_LEN], *body = NULL; @@ -279,7 +279,7 @@ static int read_loose_standard(git_rawobj *out, git_buf *obj) int error; if ((error = git_zstream_init(&zstream, GIT_ZSTREAM_INFLATE)) < 0 || - (error = git_zstream_set_input(&zstream, git_buf_cstr(obj), git_buf_len(obj))) < 0) + (error = git_zstream_set_input(&zstream, git_str_cstr(obj), git_str_len(obj))) < 0) goto done; decompressed = sizeof(head); @@ -339,15 +339,15 @@ done: return error; } -static int read_loose(git_rawobj *out, git_buf *loc) +static int read_loose(git_rawobj *out, git_str *loc) { int error; - git_buf obj = GIT_BUF_INIT; + git_str obj = GIT_STR_INIT; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(loc); - if (git_buf_oom(loc)) + if (git_str_oom(loc)) return -1; out->data = NULL; @@ -363,7 +363,7 @@ static int read_loose(git_rawobj *out, git_buf *loc) error = read_loose_standard(out, &obj); done: - git_buf_dispose(&obj); + git_str_dispose(&obj); return error; } @@ -406,7 +406,7 @@ done: return error; } -static int read_header_loose(git_rawobj *out, git_buf *loc) +static int read_header_loose(git_rawobj *out, git_str *loc) { unsigned char obj[1024]; ssize_t obj_len; @@ -415,7 +415,7 @@ static int read_header_loose(git_rawobj *out, git_buf *loc) GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(loc); - if (git_buf_oom(loc)) + if (git_str_oom(loc)) return -1; out->data = NULL; @@ -446,7 +446,7 @@ done: } static int locate_object( - git_buf *object_location, + git_str *object_location, loose_backend *backend, const git_oid *oid) { @@ -459,10 +459,10 @@ static int locate_object( } /* Explore an entry of a directory and see if it matches a short oid */ -static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) { +static int fn_locate_object_short_oid(void *state, git_str *pathbuf) { loose_locate_object_state *sstate = (loose_locate_object_state *)state; - if (git_buf_len(pathbuf) - sstate->dir_len != GIT_OID_HEXSZ - 2) { + if (git_str_len(pathbuf) - sstate->dir_len != GIT_OID_HEXSZ - 2) { /* Entry cannot be an object. Continue to next entry */ return 0; } @@ -491,7 +491,7 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) { /* Locate an object matching a given short oid */ static int locate_object_short_oid( - git_buf *object_location, + git_str *object_location, git_oid *res_oid, loose_backend *backend, const git_oid *short_oid, @@ -505,20 +505,20 @@ static int locate_object_short_oid( /* prealloc memory for OBJ_DIR/xx/xx..38x..xx */ GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, dir_len, GIT_OID_HEXSZ); GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 3); - if (git_buf_grow(object_location, alloc_len) < 0) + if (git_str_grow(object_location, alloc_len) < 0) return -1; - git_buf_set(object_location, objects_dir, dir_len); + git_str_set(object_location, objects_dir, dir_len); git_path_to_dir(object_location); /* save adjusted position at end of dir so it can be restored later */ - dir_len = git_buf_len(object_location); + dir_len = git_str_len(object_location); /* Convert raw oid to hex formatted oid */ git_oid_fmt((char *)state.short_oid, short_oid); /* Explore OBJ_DIR/xx/ where xx is the beginning of hex formatted short oid */ - if (git_buf_put(object_location, (char *)state.short_oid, 3) < 0) + if (git_str_put(object_location, (char *)state.short_oid, 3) < 0) return -1; object_location->ptr[object_location->size - 1] = '/'; @@ -527,7 +527,7 @@ static int locate_object_short_oid( return git_odb__error_notfound("no matching loose object for prefix", short_oid, len); - state.dir_len = git_buf_len(object_location); + state.dir_len = git_str_len(object_location); state.short_oid_len = len; state.found = 0; @@ -553,8 +553,8 @@ static int locate_object_short_oid( GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, dir_len, GIT_OID_HEXSZ); GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2); - git_buf_truncate(object_location, dir_len); - if (git_buf_grow(object_location, alloc_len) < 0) + git_str_truncate(object_location, dir_len); + if (git_str_grow(object_location, alloc_len) < 0) return -1; git_oid_pathfmt(object_location->ptr + dir_len, res_oid); @@ -583,7 +583,7 @@ static int locate_object_short_oid( static int loose_backend__read_header(size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid) { - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; git_rawobj raw; int error; @@ -601,14 +601,14 @@ static int loose_backend__read_header(size_t *len_p, git_object_t *type_p, git_o *type_p = raw.type; } - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return error; } static int loose_backend__read(void **buffer_p, size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid) { - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; git_rawobj raw; int error = 0; @@ -624,7 +624,7 @@ static int loose_backend__read(void **buffer_p, size_t *len_p, git_object_t *typ *type_p = raw.type; } - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return error; } @@ -648,7 +648,7 @@ static int loose_backend__read_prefix( if (!error) git_oid_cpy(out_oid, short_oid); } else { - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; git_rawobj raw; GIT_ASSERT_ARG(backend && short_oid); @@ -662,7 +662,7 @@ static int loose_backend__read_prefix( *type_p = raw.type; } - git_buf_dispose(&object_path); + git_str_dispose(&object_path); } return error; @@ -670,7 +670,7 @@ static int loose_backend__read_prefix( static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid) { - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(backend); @@ -678,7 +678,7 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid) error = locate_object(&object_path, (loose_backend *)backend, oid); - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return !error; } @@ -686,7 +686,7 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid) static int loose_backend__exists_prefix( git_oid *out, git_odb_backend *backend, const git_oid *short_id, size_t len) { - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(backend); @@ -697,7 +697,7 @@ static int loose_backend__exists_prefix( error = locate_object_short_oid( &object_path, out, (loose_backend *)backend, short_id, len); - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return error; } @@ -736,7 +736,7 @@ GIT_INLINE(int) filename_to_oid(git_oid *oid, const char *ptr) return 0; } -static int foreach_object_dir_cb(void *_state, git_buf *path) +static int foreach_object_dir_cb(void *_state, git_str *path) { git_oid oid; struct foreach_state *state = (struct foreach_state *) _state; @@ -748,12 +748,12 @@ static int foreach_object_dir_cb(void *_state, git_buf *path) state->cb(&oid, state->data), "git_odb_foreach"); } -static int foreach_cb(void *_state, git_buf *path) +static int foreach_cb(void *_state, git_str *path) { struct foreach_state *state = (struct foreach_state *) _state; /* non-dir is some stray file, ignore it */ - if (!git_path_isdir(git_buf_cstr(path))) + if (!git_path_isdir(git_str_cstr(path))) return 0; return git_path_direach(path, 0, foreach_object_dir_cb, state); @@ -763,7 +763,7 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb { char *objects_dir; int error; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; struct foreach_state state; loose_backend *backend = (loose_backend *) _backend; @@ -772,19 +772,19 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb objects_dir = backend->objects_dir; - git_buf_sets(&buf, objects_dir); + git_str_sets(&buf, objects_dir); git_path_to_dir(&buf); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; memset(&state, 0, sizeof(state)); state.cb = cb; state.data = data; - state.dir_len = git_buf_len(&buf); + state.dir_len = git_str_len(&buf); error = git_path_direach(&buf, 0, foreach_cb, &state); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -793,7 +793,7 @@ static int loose_backend__writestream_finalize(git_odb_stream *_stream, const gi { loose_writestream *stream = (loose_writestream *)_stream; loose_backend *backend = (loose_backend *)_stream->backend; - git_buf final_path = GIT_BUF_INIT; + git_str final_path = GIT_STR_INIT; int error = 0; if (object_file_name(&final_path, backend, oid) < 0 || @@ -803,7 +803,7 @@ static int loose_backend__writestream_finalize(git_odb_stream *_stream, const gi error = git_filebuf_commit_at( &stream->fbuf, final_path.ptr); - git_buf_dispose(&final_path); + git_str_dispose(&final_path); return error; } @@ -838,7 +838,7 @@ static int loose_backend__writestream(git_odb_stream **stream_out, git_odb_backe loose_backend *backend; loose_writestream *stream = NULL; char hdr[MAX_HEADER_LEN]; - git_buf tmp_path = GIT_BUF_INIT; + git_str tmp_path = GIT_STR_INIT; size_t hdrlen; int error; @@ -861,7 +861,7 @@ static int loose_backend__writestream(git_odb_stream **stream_out, git_odb_backe stream->stream.free = &loose_backend__writestream_free; stream->stream.mode = GIT_STREAM_WRONLY; - if (git_buf_joinpath(&tmp_path, backend->objects_dir, "tmp_object") < 0 || + if (git_str_joinpath(&tmp_path, backend->objects_dir, "tmp_object") < 0 || git_filebuf_open(&stream->fbuf, tmp_path.ptr, filebuf_flags(backend), backend->object_file_mode) < 0 || stream->stream.write((git_odb_stream *)stream, hdr, hdrlen) < 0) @@ -870,7 +870,7 @@ static int loose_backend__writestream(git_odb_stream **stream_out, git_odb_backe git__free(stream); stream = NULL; } - git_buf_dispose(&tmp_path); + git_str_dispose(&tmp_path); *stream_out = (git_odb_stream *)stream; return !stream ? -1 : 0; @@ -996,7 +996,7 @@ static int loose_backend__readstream( loose_backend *backend; loose_readstream *stream = NULL; git_hash_ctx *hash_ctx = NULL; - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; obj_hdr hdr; int error = 0; @@ -1059,14 +1059,14 @@ done: } } - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return error; } static int loose_backend__write(git_odb_backend *_backend, const git_oid *oid, const void *data, size_t len, git_object_t type) { int error = 0; - git_buf final_path = GIT_BUF_INIT; + git_str final_path = GIT_STR_INIT; char header[MAX_HEADER_LEN]; size_t header_len; git_filebuf fbuf = GIT_FILEBUF_INIT; @@ -1079,7 +1079,7 @@ static int loose_backend__write(git_odb_backend *_backend, const git_oid *oid, c header, sizeof(header), len, type)) < 0) goto cleanup; - if (git_buf_joinpath(&final_path, backend->objects_dir, "tmp_object") < 0 || + if (git_str_joinpath(&final_path, backend->objects_dir, "tmp_object") < 0 || git_filebuf_open(&fbuf, final_path.ptr, filebuf_flags(backend), backend->object_file_mode) < 0) { @@ -1098,7 +1098,7 @@ static int loose_backend__write(git_odb_backend *_backend, const git_oid *oid, c cleanup: if (error < 0) git_filebuf_cleanup(&fbuf); - git_buf_dispose(&final_path); + git_str_dispose(&final_path); return error; } @@ -1107,14 +1107,14 @@ static int loose_backend__freshen( const git_oid *oid) { loose_backend *backend = (loose_backend *)_backend; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; if (object_file_name(&path, backend, oid) < 0) return -1; error = git_futils_touch(path.ptr, NULL); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } diff --git a/src/odb_mempack.c b/src/odb_mempack.c index d08356a8d..6f27f45f8 100644 --- a/src/odb_mempack.c +++ b/src/odb_mempack.c @@ -7,18 +7,20 @@ #include "common.h" -#include "git2/object.h" -#include "git2/sys/odb_backend.h" -#include "git2/sys/mempack.h" +#include "buf.h" #include "futils.h" #include "hash.h" #include "odb.h" #include "array.h" #include "oidmap.h" +#include "pack-objects.h" #include "git2/odb_backend.h" +#include "git2/object.h" #include "git2/types.h" #include "git2/pack.h" +#include "git2/sys/odb_backend.h" +#include "git2/sys/mempack.h" struct memobject { git_oid oid; @@ -100,7 +102,10 @@ static int impl__read_header(size_t *len_p, git_object_t *type_p, git_odb_backen return 0; } -int git_mempack_dump(git_buf *pack, git_repository *repo, git_odb_backend *_backend) +static int git_mempack__dump( + git_str *pack, + git_repository *repo, + git_odb_backend *_backend) { struct memory_packer_db *db = (struct memory_packer_db *)_backend; git_packbuilder *packbuilder; @@ -120,13 +125,21 @@ int git_mempack_dump(git_buf *pack, git_repository *repo, git_odb_backend *_back goto cleanup; } - err = git_packbuilder_write_buf(pack, packbuilder); + err = git_packbuilder__write_buf(pack, packbuilder); cleanup: git_packbuilder_free(packbuilder); return err; } +int git_mempack_dump( + git_buf *pack, + git_repository *repo, + git_odb_backend *_backend) +{ + GIT_BUF_WRAP_PRIVATE(pack, git_mempack__dump, repo, _backend); +} + int git_mempack_reset(git_odb_backend *_backend) { struct memory_packer_db *db = (struct memory_packer_db *)_backend; diff --git a/src/odb_pack.c b/src/odb_pack.c index f4cb9a558..f2c47adbe 100644 --- a/src/odb_pack.c +++ b/src/odb_pack.c @@ -166,7 +166,7 @@ struct pack_writepack { static int packfile_sort__cb(const void *a_, const void *b_); -static int packfile_load__cb(void *_data, git_buf *path); +static int packfile_load__cb(void *_data, git_str *path); static int packfile_byname_search_cmp(const void *path, const void *pack_entry); @@ -195,10 +195,10 @@ static int pack_entry_find_prefix( static int packfile_byname_search_cmp(const void *path_, const void *p_) { - const git_buf *path = (const git_buf *)path_; + const git_str *path = (const git_str *)path_; const struct git_pack_file *p = (const struct git_pack_file *)p_; - return strncmp(p->pack_name, git_buf_cstr(path), git_buf_len(path)); + return strncmp(p->pack_name, git_str_cstr(path), git_str_len(path)); } static int packfile_sort__cb(const void *a_, const void *b_) @@ -231,20 +231,20 @@ static int packfile_sort__cb(const void *a_, const void *b_) } -static int packfile_load__cb(void *data, git_buf *path) +static int packfile_load__cb(void *data, git_str *path) { struct pack_backend *backend = data; struct git_pack_file *pack; - const char *path_str = git_buf_cstr(path); - git_buf index_prefix = GIT_BUF_INIT; - size_t cmp_len = git_buf_len(path); + const char *path_str = git_str_cstr(path); + git_str index_prefix = GIT_STR_INIT; + size_t cmp_len = git_str_len(path); int error; if (cmp_len <= strlen(".idx") || git__suffixcmp(path_str, ".idx") != 0) return 0; /* not an index */ cmp_len -= strlen(".idx"); - git_buf_attach_notowned(&index_prefix, path_str, cmp_len); + git_str_attach_notowned(&index_prefix, path_str, cmp_len); if (git_vector_search2(NULL, &backend->midx_packs, packfile_byname_search_cmp, &index_prefix) == 0) return 0; @@ -404,29 +404,29 @@ static int process_multi_pack_index_pack( int error; struct git_pack_file *pack; size_t found_position; - git_buf pack_path = GIT_BUF_INIT, index_prefix = GIT_BUF_INIT; + git_str pack_path = GIT_STR_INIT, index_prefix = GIT_STR_INIT; - error = git_buf_joinpath(&pack_path, backend->pack_folder, packfile_name); + error = git_str_joinpath(&pack_path, backend->pack_folder, packfile_name); if (error < 0) return error; /* This is ensured by midx_parse_packfile_name() */ - if (git_buf_len(&pack_path) <= strlen(".idx") || git__suffixcmp(git_buf_cstr(&pack_path), ".idx") != 0) + if (git_str_len(&pack_path) <= strlen(".idx") || git__suffixcmp(git_str_cstr(&pack_path), ".idx") != 0) return git_odb__error_notfound("midx file contained a non-index", NULL, 0); - git_buf_attach_notowned(&index_prefix, git_buf_cstr(&pack_path), git_buf_len(&pack_path) - strlen(".idx")); + git_str_attach_notowned(&index_prefix, git_str_cstr(&pack_path), git_str_len(&pack_path) - strlen(".idx")); if (git_vector_search2(&found_position, &backend->packs, packfile_byname_search_cmp, &index_prefix) == 0) { /* Pack was found in the packs list. Moving it to the midx_packs list. */ - git_buf_dispose(&pack_path); + git_str_dispose(&pack_path); git_vector_set(NULL, &backend->midx_packs, i, git_vector_get(&backend->packs, found_position)); git_vector_remove(&backend->packs, found_position); return 0; } /* Pack was not found. Allocate a new one. */ - error = git_mwindow_get_pack(&pack, git_buf_cstr(&pack_path)); - git_buf_dispose(&pack_path); + error = git_mwindow_get_pack(&pack, git_str_cstr(&pack_path)); + git_str_dispose(&pack_path); if (error < 0) return error; @@ -442,11 +442,11 @@ static int process_multi_pack_index_pack( static int refresh_multi_pack_index(struct pack_backend *backend) { int error; - git_buf midx_path = GIT_BUF_INIT; + git_str midx_path = GIT_STR_INIT; const char *packfile_name; size_t i; - error = git_buf_joinpath(&midx_path, backend->pack_folder, "multi-pack-index"); + error = git_str_joinpath(&midx_path, backend->pack_folder, "multi-pack-index"); if (error < 0) return error; @@ -457,19 +457,19 @@ static int refresh_multi_pack_index(struct pack_backend *backend) * refreshing the new multi-pack-index fails, or the file is deleted. */ if (backend->midx) { - if (!git_midx_needs_refresh(backend->midx, git_buf_cstr(&midx_path))) { - git_buf_dispose(&midx_path); + if (!git_midx_needs_refresh(backend->midx, git_str_cstr(&midx_path))) { + git_str_dispose(&midx_path); return 0; } error = remove_multi_pack_index(backend); if (error < 0) { - git_buf_dispose(&midx_path); + git_str_dispose(&midx_path); return error; } } - error = git_midx_open(&backend->midx, git_buf_cstr(&midx_path)); - git_buf_dispose(&midx_path); + error = git_midx_open(&backend->midx, git_str_cstr(&midx_path)); + git_str_dispose(&midx_path); if (error < 0) return error; @@ -505,7 +505,7 @@ static int pack_backend__refresh(git_odb_backend *backend_) { int error; struct stat st; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; struct pack_backend *backend = (struct pack_backend *)backend_; if (backend->pack_folder == NULL) @@ -523,10 +523,10 @@ static int pack_backend__refresh(git_odb_backend *backend_) } /* reload all packs */ - git_buf_sets(&path, backend->pack_folder); + git_str_sets(&path, backend->pack_folder); error = git_path_direach(&path, 0, packfile_load__cb, backend); - git_buf_dispose(&path); + git_str_dispose(&path); git_vector_sort(&backend->packs); return error; @@ -743,7 +743,7 @@ static int pack_backend__writepack(struct git_odb_writepack **out, } static int get_idx_path( - git_buf *idx_path, + git_str *idx_path, struct pack_backend *backend, struct git_pack_file *p) { @@ -753,11 +753,11 @@ static int get_idx_path( error = git_path_prettify(idx_path, p->pack_name, backend->pack_folder); if (error < 0) return error; - path_len = git_buf_len(idx_path); - if (path_len <= strlen(".pack") || git__suffixcmp(git_buf_cstr(idx_path), ".pack") != 0) + path_len = git_str_len(idx_path); + if (path_len <= strlen(".pack") || git__suffixcmp(git_str_cstr(idx_path), ".pack") != 0) return git_odb__error_notfound("packfile does not end in .pack", NULL, 0); path_len -= strlen(".pack"); - error = git_buf_splice(idx_path, path_len, strlen(".pack"), ".idx", strlen(".idx")); + error = git_str_splice(idx_path, path_len, strlen(".pack"), ".idx", strlen(".idx")); if (error < 0) return error; @@ -781,22 +781,22 @@ static int pack_backend__writemidx(git_odb_backend *_backend) return error; git_vector_foreach(&backend->midx_packs, i, p) { - git_buf idx_path = GIT_BUF_INIT; + git_str idx_path = GIT_STR_INIT; error = get_idx_path(&idx_path, backend, p); if (error < 0) goto cleanup; - error = git_midx_writer_add(w, git_buf_cstr(&idx_path)); - git_buf_dispose(&idx_path); + error = git_midx_writer_add(w, git_str_cstr(&idx_path)); + git_str_dispose(&idx_path); if (error < 0) goto cleanup; } git_vector_foreach(&backend->packs, i, p) { - git_buf idx_path = GIT_BUF_INIT; + git_str idx_path = GIT_STR_INIT; error = get_idx_path(&idx_path, backend, p); if (error < 0) goto cleanup; - error = git_midx_writer_add(w, git_buf_cstr(&idx_path)); - git_buf_dispose(&idx_path); + error = git_midx_writer_add(w, git_str_cstr(&idx_path)); + git_str_dispose(&idx_path); if (error < 0) goto cleanup; } @@ -896,15 +896,15 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) { int error = 0; struct pack_backend *backend = NULL; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; if (pack_backend__alloc(&backend, 8) < 0) return -1; - if (!(error = git_buf_joinpath(&path, objects_dir, "pack")) && - git_path_isdir(git_buf_cstr(&path))) + if (!(error = git_str_joinpath(&path, objects_dir, "pack")) && + git_path_isdir(git_str_cstr(&path))) { - backend->pack_folder = git_buf_detach(&path); + backend->pack_folder = git_str_detach(&path); error = pack_backend__refresh((git_odb_backend *)backend); } @@ -915,7 +915,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) *backend_out = (git_odb_backend *)backend; - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -162,14 +162,14 @@ int git_oid__parse( return 0; } -void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid) +void git_oid__writebuf(git_str *buf, const char *header, const git_oid *oid) { char hex_oid[GIT_OID_HEXSZ]; git_oid_fmt(hex_oid, oid); - git_buf_puts(buf, header); - git_buf_put(buf, hex_oid, GIT_OID_HEXSZ); - git_buf_putc(buf, '\n'); + git_str_puts(buf, header); + git_str_put(buf, hex_oid, GIT_OID_HEXSZ); + git_str_putc(buf, '\n'); } int git_oid_fromraw(git_oid *out, const unsigned char *raw) diff --git a/src/pack-objects.c b/src/pack-objects.c index d89a4e780..e5fc625a4 100644 --- a/src/pack-objects.c +++ b/src/pack-objects.c @@ -7,6 +7,7 @@ #include "pack-objects.h" +#include "buf.h" #include "zstream.h" #include "delta.h" #include "iterator.h" @@ -33,7 +34,7 @@ struct unpacked { struct tree_walk_context { git_packbuilder *pb; - git_buf buf; + git_str buf; }; struct pack_write_context { @@ -685,8 +686,8 @@ done: static int write_pack_buf(void *buf, size_t size, void *data) { - git_buf *b = (git_buf *)data; - return git_buf_put(b, buf, size); + git_str *b = (git_str *)data; + return git_str_put(b, buf, size); } static int type_size_sort(const void *_a, const void *_b) @@ -947,7 +948,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list, size_t *list_size, size_t window, size_t depth) { git_pobject *po; - git_buf zbuf = GIT_BUF_INIT; + git_str zbuf = GIT_STR_INIT; struct unpacked *array; size_t idx = 0, count = 0; size_t mem_usage = 0; @@ -1045,7 +1046,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list, memcpy(po->delta_data, zbuf.ptr, zbuf.size); po->z_delta_size = zbuf.size; - git_buf_clear(&zbuf); + git_str_clear(&zbuf); GIT_ASSERT(git_packbuilder__cache_lock(pb) == 0); pb->delta_cache_size -= po->delta_size; @@ -1093,7 +1094,7 @@ on_error: git__free(array[i].data); } git__free(array); - git_buf_dispose(&zbuf); + git_str_dispose(&zbuf); return error; } @@ -1360,18 +1361,18 @@ int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t siz return write_pack(pb, cb, payload); } -int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb) +int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb) { - int error; - - if ((error = git_buf_sanitize(buf)) < 0) - return error; - PREPARE_PACK; return write_pack(pb, &write_pack_buf, buf); } +int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb) +{ + GIT_BUF_WRAP_PRIVATE(buf, git_packbuilder__write_buf, pb); +} + static int write_cb(void *buf, size_t len, void *payload) { struct pack_write_context *ctx = payload; @@ -1386,7 +1387,7 @@ int git_packbuilder_write( void *progress_cb_payload) { int error = -1; - git_buf object_path = GIT_BUF_INIT; + git_str object_path = GIT_STR_INIT; git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; git_indexer *indexer = NULL; git_indexer_progress stats; @@ -1396,11 +1397,11 @@ int git_packbuilder_write( PREPARE_PACK; if (path == NULL) { - if ((error = git_repository_item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0) + if ((error = git_repository__item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0) goto cleanup; - if ((error = git_buf_joinpath(&object_path, git_buf_cstr(&object_path), "pack")) < 0) + if ((error = git_str_joinpath(&object_path, git_str_cstr(&object_path), "pack")) < 0) goto cleanup; - path = git_buf_cstr(&object_path); + path = git_str_cstr(&object_path); } opts.progress_cb = progress_cb; @@ -1425,7 +1426,7 @@ int git_packbuilder_write( cleanup: git_indexer_free(indexer); - git_buf_dispose(&object_path); + git_str_dispose(&object_path); return error; } @@ -1447,10 +1448,10 @@ static int cb_tree_walk( if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT) return 0; - if (!(error = git_buf_sets(&ctx->buf, root)) && - !(error = git_buf_puts(&ctx->buf, git_tree_entry_name(entry)))) + if (!(error = git_str_sets(&ctx->buf, root)) && + !(error = git_str_puts(&ctx->buf, git_tree_entry_name(entry)))) error = git_packbuilder_insert( - ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf)); + ctx->pb, git_tree_entry_id(entry), git_str_cstr(&ctx->buf)); return error; } @@ -1474,14 +1475,14 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid) { int error; git_tree *tree = NULL; - struct tree_walk_context context = { pb, GIT_BUF_INIT }; + struct tree_walk_context context = { pb, GIT_STR_INIT }; if (!(error = git_tree_lookup(&tree, pb->repo, oid)) && !(error = git_packbuilder_insert(pb, oid, NULL))) error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context); git_tree_free(tree); - git_buf_dispose(&context.buf); + git_str_dispose(&context.buf); return error; } diff --git a/src/pack-objects.h b/src/pack-objects.h index 04514daa6..db2038b0a 100644 --- a/src/pack-objects.h +++ b/src/pack-objects.h @@ -10,7 +10,7 @@ #include "common.h" -#include "buffer.h" +#include "str.h" #include "hash.h" #include "oidmap.h" #include "netops.h" @@ -96,6 +96,6 @@ struct git_packbuilder { bool done; }; -int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb); +int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb); #endif diff --git a/src/pack.c b/src/pack.c index aadf3f2be..e17d20f8c 100644 --- a/src/pack.c +++ b/src/pack.c @@ -308,7 +308,7 @@ static int pack_index_open_locked(struct git_pack_file *p) { int error = 0; size_t name_len; - git_buf idx_name = GIT_BUF_INIT; + git_str idx_name = GIT_STR_INIT; if (p->index_version > -1) goto cleanup; @@ -317,12 +317,12 @@ static int pack_index_open_locked(struct git_pack_file *p) name_len = strlen(p->pack_name); GIT_ASSERT(name_len > strlen(".pack")); - if ((error = git_buf_init(&idx_name, name_len)) < 0) + if ((error = git_str_init(&idx_name, name_len)) < 0) goto cleanup; - git_buf_put(&idx_name, p->pack_name, name_len - strlen(".pack")); - git_buf_puts(&idx_name, ".idx"); - if (git_buf_oom(&idx_name)) { + git_str_put(&idx_name, p->pack_name, name_len - strlen(".pack")); + git_str_puts(&idx_name, ".idx"); + if (git_str_oom(&idx_name)) { error = -1; goto cleanup; } @@ -331,7 +331,7 @@ static int pack_index_open_locked(struct git_pack_file *p) error = pack_index_check_locked(idx_name.ptr, p); cleanup: - git_buf_dispose(&idx_name); + git_str_dispose(&idx_name); return error; } @@ -1156,17 +1156,17 @@ cleanup: int git_packfile__name(char **out, const char *path) { size_t path_len; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; path_len = strlen(path); if (path_len < strlen(".idx")) return git_odb__error_notfound("invalid packfile path", NULL, 0); - if (git_buf_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0) + if (git_str_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0) return -1; - *out = git_buf_detach(&buf); + *out = git_str_detach(&buf); return 0; } diff --git a/src/patch.c b/src/patch.c index f02c928de..a30546f3c 100644 --- a/src/patch.c +++ b/src/patch.c @@ -76,15 +76,15 @@ size_t git_patch_size( out += patch->header_size; if (include_file_headers) { - git_buf file_header = GIT_BUF_INIT; + git_str file_header = GIT_STR_INIT; if (git_diff_delta__format_file_header( &file_header, patch->delta, NULL, NULL, 0, true) < 0) git_error_clear(); else - out += git_buf_len(&file_header); + out += git_str_len(&file_header); - git_buf_dispose(&file_header); + git_str_dispose(&file_header); } return out; diff --git a/src/patch.h b/src/patch.h index 156d1310e..1e1471ed6 100644 --- a/src/patch.h +++ b/src/patch.h @@ -63,6 +63,7 @@ typedef struct { #define GIT_PATCH_OPTIONS_INIT { 1 } +extern int git_patch__to_buf(git_str *out, git_patch *patch); extern void git_patch_free(git_patch *patch); #endif diff --git a/src/patch_generate.c b/src/patch_generate.c index 38cd714a9..6d115affe 100644 --- a/src/patch_generate.c +++ b/src/patch_generate.c @@ -261,7 +261,7 @@ static int create_binary( const char *b_data, size_t b_datalen) { - git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT; + git_str deflate = GIT_STR_INIT, delta = GIT_STR_INIT; size_t delta_data_len = 0; int error; @@ -302,18 +302,18 @@ static int create_binary( if (delta.size && delta.size < deflate.size) { *out_type = GIT_DIFF_BINARY_DELTA; *out_datalen = delta.size; - *out_data = git_buf_detach(&delta); + *out_data = git_str_detach(&delta); *out_inflatedlen = delta_data_len; } else { *out_type = GIT_DIFF_BINARY_LITERAL; *out_datalen = deflate.size; - *out_data = git_buf_detach(&deflate); + *out_data = git_str_detach(&deflate); *out_inflatedlen = b_datalen; } done: - git_buf_dispose(&deflate); - git_buf_dispose(&delta); + git_str_dispose(&deflate); + git_str_dispose(&delta); return error; } diff --git a/src/patch_parse.c b/src/patch_parse.c index 2cc5c5995..fce4bc9e4 100644 --- a/src/patch_parse.c +++ b/src/patch_parse.c @@ -65,19 +65,19 @@ static size_t header_path_len(git_patch_parse_ctx *ctx) return len; } -static int parse_header_path_buf(git_buf *path, git_patch_parse_ctx *ctx, size_t path_len) +static int parse_header_path_buf(git_str *path, git_patch_parse_ctx *ctx, size_t path_len) { int error; - if ((error = git_buf_put(path, ctx->parse_ctx.line, path_len)) < 0) + if ((error = git_str_put(path, ctx->parse_ctx.line, path_len)) < 0) return error; git_parse_advance_chars(&ctx->parse_ctx, path_len); - git_buf_rtrim(path); + git_str_rtrim(path); if (path->size > 0 && path->ptr[0] == '"' && - (error = git_buf_unquote(path)) < 0) + (error = git_str_unquote(path)) < 0) return error; git_path_squash_slashes(path); @@ -91,22 +91,22 @@ static int parse_header_path_buf(git_buf *path, git_patch_parse_ctx *ctx, size_t static int parse_header_path(char **out, git_patch_parse_ctx *ctx) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; if ((error = parse_header_path_buf(&path, ctx, header_path_len(ctx))) < 0) goto out; - *out = git_buf_detach(&path); + *out = git_str_detach(&path); out: - git_buf_dispose(&path); + git_str_dispose(&path); return error; } static int parse_header_git_oldpath( git_patch_parsed *patch, git_patch_parse_ctx *ctx) { - git_buf old_path = GIT_BUF_INIT; + git_str old_path = GIT_STR_INIT; int error; if (patch->old_path) { @@ -118,17 +118,17 @@ static int parse_header_git_oldpath( if ((error = parse_header_path_buf(&old_path, ctx, ctx->parse_ctx.line_len - 1)) < 0) goto out; - patch->old_path = git_buf_detach(&old_path); + patch->old_path = git_str_detach(&old_path); out: - git_buf_dispose(&old_path); + git_str_dispose(&old_path); return error; } static int parse_header_git_newpath( git_patch_parsed *patch, git_patch_parse_ctx *ctx) { - git_buf new_path = GIT_BUF_INIT; + git_str new_path = GIT_STR_INIT; int error; if (patch->new_path) { @@ -139,10 +139,10 @@ static int parse_header_git_newpath( if ((error = parse_header_path_buf(&new_path, ctx, ctx->parse_ctx.line_len - 1)) < 0) goto out; - patch->new_path = git_buf_detach(&new_path); + patch->new_path = git_str_detach(&new_path); out: - git_buf_dispose(&new_path); + git_str_dispose(&new_path); return error; } @@ -257,7 +257,7 @@ static int parse_header_rename( char **out, git_patch_parse_ctx *ctx) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; if (parse_header_path_buf(&path, ctx, header_path_len(ctx)) < 0) return -1; @@ -265,7 +265,7 @@ static int parse_header_rename( /* Note: the `rename from` and `rename to` lines include the literal * filename. They do *not* include the prefix. (Who needs consistency?) */ - *out = git_buf_detach(&path); + *out = git_str_detach(&path); return 0; } @@ -766,7 +766,7 @@ static int parse_patch_binary_side( git_patch_parse_ctx *ctx) { git_diff_binary_t type = GIT_DIFF_BINARY_NONE; - git_buf base85 = GIT_BUF_INIT, decoded = GIT_BUF_INIT; + git_str base85 = GIT_STR_INIT, decoded = GIT_STR_INIT; int64_t len; int error = 0; @@ -815,7 +815,7 @@ static int parse_patch_binary_side( goto done; } - if ((error = git_buf_decode_base85( + if ((error = git_str_decode_base85( &decoded, ctx->parse_ctx.line, encoded_len, decoded_len)) < 0) goto done; @@ -835,11 +835,11 @@ static int parse_patch_binary_side( binary->type = type; binary->inflatedlen = (size_t)len; binary->datalen = decoded.size; - binary->data = git_buf_detach(&decoded); + binary->data = git_str_detach(&decoded); done: - git_buf_dispose(&base85); - git_buf_dispose(&decoded); + git_str_dispose(&base85); + git_str_dispose(&decoded); return error; } diff --git a/src/path.c b/src/path.c index c444b31a7..d8d33a141 100644 --- a/src/path.c +++ b/src/path.c @@ -93,7 +93,7 @@ static bool looks_like_network_computer_name(const char *path, int pos) * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -int git_path_basename_r(git_buf *buffer, const char *path) +int git_path_basename_r(git_str *buffer, const char *path) { const char *endp, *startp; int len, result; @@ -128,7 +128,7 @@ int git_path_basename_r(git_buf *buffer, const char *path) Exit: result = len; - if (buffer != NULL && git_buf_set(buffer, startp, len) < 0) + if (buffer != NULL && git_str_set(buffer, startp, len) < 0) return -1; return result; @@ -166,7 +166,7 @@ static int win32_prefix_length(const char *path, int len) * Based on the Android implementation, BSD licensed. * Check http://android.git.kernel.org/ */ -int git_path_dirname_r(git_buf *buffer, const char *path) +int git_path_dirname_r(git_str *buffer, const char *path) { const char *endp; int is_prefix = 0, len; @@ -225,9 +225,9 @@ int git_path_dirname_r(git_buf *buffer, const char *path) Exit: if (buffer) { - if (git_buf_set(buffer, path, len) < 0) + if (git_str_set(buffer, path, len) < 0) return -1; - if (is_prefix && git_buf_putc(buffer, '/') < 0) + if (is_prefix && git_str_putc(buffer, '/') < 0) return -1; } @@ -237,36 +237,36 @@ Exit: char *git_path_dirname(const char *path) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; char *dirname; git_path_dirname_r(&buf, path); - dirname = git_buf_detach(&buf); - git_buf_dispose(&buf); /* avoid memleak if error occurs */ + dirname = git_str_detach(&buf); + git_str_dispose(&buf); /* avoid memleak if error occurs */ return dirname; } char *git_path_basename(const char *path) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; char *basename; git_path_basename_r(&buf, path); - basename = git_buf_detach(&buf); - git_buf_dispose(&buf); /* avoid memleak if error occurs */ + basename = git_str_detach(&buf); + git_str_dispose(&buf); /* avoid memleak if error occurs */ return basename; } -size_t git_path_basename_offset(git_buf *buffer) +size_t git_path_basename_offset(git_str *buffer) { ssize_t slash; if (!buffer || buffer->size <= 0) return 0; - slash = git_buf_rfind_next(buffer, '/'); + slash = git_str_rfind_next(buffer, '/'); if (slash >= 0 && buffer->ptr[slash] == '/') return (size_t)(slash + 1); @@ -304,7 +304,7 @@ int git_path_root(const char *path) return -1; /* Not a real error - signals that path is not rooted */ } -static void path_trim_slashes(git_buf *path) +static void path_trim_slashes(git_str *path) { int ceiling = git_path_root(path->ptr) + 1; @@ -321,7 +321,7 @@ static void path_trim_slashes(git_buf *path) } int git_path_join_unrooted( - git_buf *path_out, const char *path, const char *base, ssize_t *root_at) + git_str *path_out, const char *path, const char *base, ssize_t *root_at) { ssize_t root; @@ -331,12 +331,12 @@ int git_path_join_unrooted( root = (ssize_t)git_path_root(path); if (base != NULL && root < 0) { - if (git_buf_joinpath(path_out, base, path) < 0) + if (git_str_joinpath(path_out, base, path) < 0) return -1; root = (ssize_t)strlen(base); } else { - if (git_buf_sets(path_out, path) < 0) + if (git_str_sets(path_out, path) < 0) return -1; if (root < 0) @@ -351,7 +351,7 @@ int git_path_join_unrooted( return 0; } -void git_path_squash_slashes(git_buf *path) +void git_path_squash_slashes(git_str *path) { char *p, *q; @@ -370,7 +370,7 @@ void git_path_squash_slashes(git_buf *path) *p = '\0'; } -int git_path_prettify(git_buf *path_out, const char *path, const char *base) +int git_path_prettify(git_str *path_out, const char *path, const char *base) { char buf[GIT_PATH_MAX]; @@ -379,7 +379,7 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base) /* construct path if needed */ if (base != NULL && git_path_root(path) < 0) { - if (git_buf_joinpath(path_out, base, path) < 0) + if (git_str_joinpath(path_out, base, path) < 0) return -1; path = path_out->ptr; } @@ -389,28 +389,28 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base) int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_ENOTFOUND : -1; git_error_set(GIT_ERROR_OS, "failed to resolve path '%s'", path); - git_buf_clear(path_out); + git_str_clear(path_out); return error; } - return git_buf_sets(path_out, buf); + return git_str_sets(path_out, buf); } -int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base) +int git_path_prettify_dir(git_str *path_out, const char *path, const char *base) { int error = git_path_prettify(path_out, path, base); return (error < 0) ? error : git_path_to_dir(path_out); } -int git_path_to_dir(git_buf *path) +int git_path_to_dir(git_str *path) { if (path->asize > 0 && - git_buf_len(path) > 0 && - path->ptr[git_buf_len(path) - 1] != '/') - git_buf_putc(path, '/'); + git_str_len(path) > 0 && + path->ptr[git_str_len(path) - 1] != '/') + git_str_putc(path, '/'); - return git_buf_oom(path) ? -1 : 0; + return git_str_oom(path) ? -1 : 0; } void git_path_string_to_dir(char *path, size_t size) @@ -423,7 +423,7 @@ void git_path_string_to_dir(char *path, size_t size) } } -int git__percent_decode(git_buf *decoded_out, const char *input) +int git__percent_decode(git_str *decoded_out, const char *input) { int len, hi, lo, i; @@ -431,7 +431,7 @@ int git__percent_decode(git_buf *decoded_out, const char *input) GIT_ASSERT_ARG(input); len = (int)strlen(input); - git_buf_clear(decoded_out); + git_str_clear(decoded_out); for(i = 0; i < len; i++) { @@ -453,7 +453,7 @@ int git__percent_decode(git_buf *decoded_out, const char *input) i += 2; append: - if (git_buf_putc(decoded_out, c) < 0) + if (git_str_putc(decoded_out, c) < 0) return -1; } @@ -485,7 +485,7 @@ bool git_path_is_local_file_url(const char *file_url) return (local_file_url_prefixlen(file_url) > 0); } -int git_path_fromurl(git_buf *local_path_out, const char *file_url) +int git_path_fromurl(git_str *local_path_out, const char *file_url) { int offset; @@ -500,18 +500,18 @@ int git_path_fromurl(git_buf *local_path_out, const char *file_url) offset--; /* A *nix absolute path starts with a forward slash */ #endif - git_buf_clear(local_path_out); + git_str_clear(local_path_out); return git__percent_decode(local_path_out, file_url + offset); } int git_path_walk_up( - git_buf *path, + git_str *path, const char *ceiling, int (*cb)(void *data, const char *), void *data) { int error = 0; - git_buf iter; + git_str iter; ssize_t stop = 0, scan; char oldc = '\0'; @@ -522,9 +522,9 @@ int git_path_walk_up( if (git__prefixcmp(path->ptr, ceiling) == 0) stop = (ssize_t)strlen(ceiling); else - stop = git_buf_len(path); + stop = git_str_len(path); } - scan = git_buf_len(path); + scan = git_str_len(path); /* empty path: yield only once */ if (!scan) { @@ -535,7 +535,7 @@ int git_path_walk_up( } iter.ptr = path->ptr; - iter.size = git_buf_len(path); + iter.size = git_str_len(path); iter.asize = path->asize; while (scan >= stop) { @@ -547,7 +547,7 @@ int git_path_walk_up( break; } - scan = git_buf_rfind_next(&iter, '/'); + scan = git_str_rfind_next(&iter, '/'); if (scan >= 0) { scan++; oldc = iter.ptr[scan]; @@ -651,7 +651,7 @@ bool git_path_is_empty_dir(const char *path) #else -static int path_found_entry(void *payload, git_buf *path) +static int path_found_entry(void *payload, git_str *path) { GIT_UNUSED(payload); return !git_path_is_dot_or_dotdot(path->ptr); @@ -660,17 +660,17 @@ static int path_found_entry(void *payload, git_buf *path) bool git_path_is_empty_dir(const char *path) { int error; - git_buf dir = GIT_BUF_INIT; + git_str dir = GIT_STR_INIT; if (!git_path_isdir(path)) return false; - if ((error = git_buf_sets(&dir, path)) != 0) + if ((error = git_str_sets(&dir, path)) != 0) git_error_clear(); else error = git_path_direach(&dir, 0, path_found_entry, NULL); - git_buf_dispose(&dir); + git_str_dispose(&dir); return !error; } @@ -713,54 +713,54 @@ int git_path_lstat(const char *path, struct stat *st) } static bool _check_dir_contents( - git_buf *dir, + git_str *dir, const char *sub, bool (*predicate)(const char *)) { bool result; - size_t dir_size = git_buf_len(dir); + size_t dir_size = git_str_len(dir); size_t sub_size = strlen(sub); size_t alloc_size; /* leave base valid even if we could not make space for subdir */ if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, dir_size, sub_size) || GIT_ADD_SIZET_OVERFLOW(&alloc_size, alloc_size, 2) || - git_buf_try_grow(dir, alloc_size, false) < 0) + git_str_try_grow(dir, alloc_size, false) < 0) return false; /* save excursion */ - if (git_buf_joinpath(dir, dir->ptr, sub) < 0) + if (git_str_joinpath(dir, dir->ptr, sub) < 0) return false; result = predicate(dir->ptr); /* restore path */ - git_buf_truncate(dir, dir_size); + git_str_truncate(dir, dir_size); return result; } -bool git_path_contains(git_buf *dir, const char *item) +bool git_path_contains(git_str *dir, const char *item) { return _check_dir_contents(dir, item, &git_path_exists); } -bool git_path_contains_dir(git_buf *base, const char *subdir) +bool git_path_contains_dir(git_str *base, const char *subdir) { return _check_dir_contents(base, subdir, &git_path_isdir); } -bool git_path_contains_file(git_buf *base, const char *file) +bool git_path_contains_file(git_str *base, const char *file) { return _check_dir_contents(base, file, &git_path_isfile); } -int git_path_find_dir(git_buf *dir) +int git_path_find_dir(git_str *dir) { int error = 0; char buf[GIT_PATH_MAX]; if (p_realpath(dir->ptr, buf) != NULL) - error = git_buf_sets(dir, buf); + error = git_str_sets(dir, buf); /* call dirname if this is not a directory */ if (!error) /* && git_path_isdir(dir->ptr) == false) */ @@ -772,12 +772,12 @@ int git_path_find_dir(git_buf *dir) return error; } -int git_path_resolve_relative(git_buf *path, size_t ceiling) +int git_path_resolve_relative(git_str *path, size_t ceiling) { char *base, *to, *from, *next; size_t len; - GIT_ERROR_CHECK_ALLOC_BUF(path); + GIT_ERROR_CHECK_ALLOC_STR(path); if (ceiling > path->size) ceiling = path->size; @@ -851,9 +851,9 @@ int git_path_resolve_relative(git_buf *path, size_t ceiling) return 0; } -int git_path_apply_relative(git_buf *target, const char *relpath) +int git_path_apply_relative(git_str *target, const char *relpath) { - return git_buf_joinpath(target, git_buf_cstr(target), relpath) || + return git_str_joinpath(target, git_str_cstr(target), relpath) || git_path_resolve_relative(target, 0); } @@ -896,7 +896,7 @@ size_t git_path_common_dirlen(const char *one, const char *two) return dirsep ? (dirsep - one) + 1 : 0; } -int git_path_make_relative(git_buf *path, const char *parent) +int git_path_make_relative(git_str *path, const char *parent) { const char *p, *q, *p_dirsep, *q_dirsep; size_t plen = path->size, newlen, alloclen, depth = 1, i, offset; @@ -923,7 +923,7 @@ int git_path_make_relative(git_buf *path, const char *parent) else if (!*p && *q == '/') q++; else if (!*p && !*q) - return git_buf_clear(path), 0; + return git_str_clear(path), 0; else { p = p_dirsep + 1; q = q_dirsep + 1; @@ -932,7 +932,7 @@ int git_path_make_relative(git_buf *path, const char *parent) plen -= (p - path->ptr); if (!*q) - return git_buf_set(path, p, plen); + return git_str_set(path, p, plen); for (; (q = strchr(q, '/')) && *(q + 1); q++) depth++; @@ -944,7 +944,7 @@ int git_path_make_relative(git_buf *path, const char *parent) /* save the offset as we might realllocate the pointer */ offset = p - path->ptr; - if (git_buf_try_grow(path, alloclen, 1) < 0) + if (git_str_try_grow(path, alloclen, 1) < 0) return -1; p = path->ptr + offset; @@ -972,7 +972,7 @@ bool git_path_has_non_ascii(const char *path, size_t pathlen) int git_path_iconv_init_precompose(git_path_iconv_t *ic) { - git_buf_init(&ic->buf, 0); + git_str_init(&ic->buf, 0); ic->map = iconv_open(GIT_PATH_REPO_ENCODING, GIT_PATH_NATIVE_ENCODING); return 0; } @@ -982,7 +982,7 @@ void git_path_iconv_clear(git_path_iconv_t *ic) if (ic) { if (ic->map != (iconv_t)-1) iconv_close(ic->map); - git_buf_dispose(&ic->buf); + git_str_dispose(&ic->buf); } } @@ -996,11 +996,11 @@ int git_path_iconv(git_path_iconv_t *ic, const char **in, size_t *inlen) !git_path_has_non_ascii(*in, *inlen)) return 0; - git_buf_clear(&ic->buf); + git_str_clear(&ic->buf); while (1) { GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, wantlen, 1); - if (git_buf_grow(&ic->buf, alloclen) < 0) + if (git_str_grow(&ic->buf, alloclen) < 0) return -1; nfc = ic->buf.ptr + ic->buf.size; @@ -1054,7 +1054,7 @@ static const char *nfd_file = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D.XXXXXX"; */ bool git_path_does_fs_decompose_unicode(const char *root) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int fd; bool found_decomposed = false; char tmp[6]; @@ -1063,7 +1063,7 @@ bool git_path_does_fs_decompose_unicode(const char *root) * using the decomposed name. If the lookup fails, then we will mark * that we should precompose unicode for this repository. */ - if (git_buf_joinpath(&path, root, nfc_file) < 0 || + if (git_str_joinpath(&path, root, nfc_file) < 0 || (fd = p_mkstemp(path.ptr)) < 0) goto done; p_close(fd); @@ -1072,21 +1072,21 @@ bool git_path_does_fs_decompose_unicode(const char *root) memcpy(tmp, path.ptr + path.size - sizeof(tmp), sizeof(tmp)); /* try to look up as NFD path */ - if (git_buf_joinpath(&path, root, nfd_file) < 0) + if (git_str_joinpath(&path, root, nfd_file) < 0) goto done; memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp)); found_decomposed = git_path_exists(path.ptr); /* remove temporary file (using original precomposed path) */ - if (git_buf_joinpath(&path, root, nfc_file) < 0) + if (git_str_joinpath(&path, root, nfc_file) < 0) goto done; memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp)); (void)p_unlink(path.ptr); done: - git_buf_dispose(&path); + git_str_dispose(&path); return found_decomposed; } @@ -1107,9 +1107,9 @@ typedef struct dirent path_dirent_data; #endif int git_path_direach( - git_buf *path, + git_str *path, uint32_t flags, - int (*fn)(void *, git_buf *), + int (*fn)(void *, git_str *), void *arg) { int error = 0; @@ -1126,7 +1126,7 @@ int git_path_direach( if (git_path_to_dir(path) < 0) return -1; - wd_len = git_buf_len(path); + wd_len = git_str_len(path); if ((dir = opendir(path->ptr)) == NULL) { git_error_set(GIT_ERROR_OS, "failed to open directory '%s'", path->ptr); @@ -1153,13 +1153,13 @@ int git_path_direach( break; #endif - if ((error = git_buf_put(path, de_path, de_len)) < 0) + if ((error = git_str_put(path, de_path, de_len)) < 0) break; git_error_clear(); error = fn(arg, path); - git_buf_truncate(path, wd_len); /* restore path */ + git_str_truncate(path, wd_len); /* restore path */ /* Only set our own error if the callback did not set one already */ if (error != 0) { @@ -1205,7 +1205,7 @@ int git_path_diriter_init( memset(diriter, 0, sizeof(git_path_diriter)); diriter->handle = INVALID_HANDLE_VALUE; - if (git_buf_puts(&diriter->path_utf8, path) < 0) + if (git_str_puts(&diriter->path_utf8, path) < 0) return -1; path_trim_slashes(&diriter->path_utf8); @@ -1261,15 +1261,15 @@ static int diriter_update_paths(git_path_diriter *diriter) diriter->current.cFileName, filename_len * sizeof(wchar_t)); diriter->path[path_len-1] = L'\0'; - git_buf_truncate(&diriter->path_utf8, diriter->parent_utf8_len); + git_str_truncate(&diriter->path_utf8, diriter->parent_utf8_len); if (diriter->parent_utf8_len > 0 && diriter->path_utf8.ptr[diriter->parent_utf8_len-1] != '/') - git_buf_putc(&diriter->path_utf8, '/'); + git_str_putc(&diriter->path_utf8, '/'); - git_buf_put_w(&diriter->path_utf8, diriter->current.cFileName, filename_len); + git_str_put_w(&diriter->path_utf8, diriter->current.cFileName, filename_len); - if (git_buf_oom(&diriter->path_utf8)) + if (git_str_oom(&diriter->path_utf8)) return -1; return 0; @@ -1339,7 +1339,7 @@ void git_path_diriter_free(git_path_diriter *diriter) if (diriter == NULL) return; - git_buf_dispose(&diriter->path_utf8); + git_str_dispose(&diriter->path_utf8); if (diriter->handle != INVALID_HANDLE_VALUE) { FindClose(diriter->handle); @@ -1359,7 +1359,7 @@ int git_path_diriter_init( memset(diriter, 0, sizeof(git_path_diriter)); - if (git_buf_puts(&diriter->path, path) < 0) + if (git_str_puts(&diriter->path, path) < 0) return -1; path_trim_slashes(&diriter->path); @@ -1370,7 +1370,7 @@ int git_path_diriter_init( } if ((diriter->dir = opendir(diriter->path.ptr)) == NULL) { - git_buf_dispose(&diriter->path); + git_str_dispose(&diriter->path); git_error_set(GIT_ERROR_OS, "failed to open directory '%s'", path); return -1; @@ -1419,15 +1419,15 @@ int git_path_diriter_next(git_path_diriter *diriter) return error; #endif - git_buf_truncate(&diriter->path, diriter->parent_len); + git_str_truncate(&diriter->path, diriter->parent_len); if (diriter->parent_len > 0 && diriter->path.ptr[diriter->parent_len-1] != '/') - git_buf_putc(&diriter->path, '/'); + git_str_putc(&diriter->path, '/'); - git_buf_put(&diriter->path, filename, filename_len); + git_str_put(&diriter->path, filename, filename_len); - if (git_buf_oom(&diriter->path)) + if (git_str_oom(&diriter->path)) return -1; return error; @@ -1484,7 +1484,7 @@ void git_path_diriter_free(git_path_diriter *diriter) git_path_iconv_clear(&diriter->ic); #endif - git_buf_dispose(&diriter->path); + git_str_dispose(&diriter->path); } #endif @@ -1527,12 +1527,12 @@ int git_path_dirload( return error; } -int git_path_from_url_or_path(git_buf *local_path_out, const char *url_or_path) +int git_path_from_url_or_path(git_str *local_path_out, const char *url_or_path) { if (git_path_is_local_file_url(url_or_path)) return git_path_fromurl(local_path_out, url_or_path); else - return git_buf_sets(local_path_out, url_or_path); + return git_str_sets(local_path_out, url_or_path); } /* Reject paths like AUX or COM1, or those versions that end in a dot or @@ -1625,7 +1625,7 @@ static bool verify_dotgit_hfs(const char *path, size_t len) GIT_INLINE(bool) verify_dotgit_ntfs(git_repository *repo, const char *path, size_t len) { - git_buf *reserved = git_repository__reserved_names_win32; + git_str *reserved = git_repository__reserved_names_win32; size_t reserved_len = git_repository__reserved_names_win32_len; size_t start = 0, i; @@ -1633,7 +1633,7 @@ GIT_INLINE(bool) verify_dotgit_ntfs(git_repository *repo, const char *path, size git_repository__reserved_names(&reserved, &reserved_len, repo, true); for (i = 0; i < reserved_len; i++) { - git_buf *r = &reserved[i]; + git_str *r = &reserved[i]; if (len >= r->size && strncasecmp(path, r->ptr, r->size) == 0) { @@ -1943,17 +1943,17 @@ int git_path_validate_workdir_with_len( return 0; } -int git_path_validate_workdir_buf(git_repository *repo, git_buf *path) +int git_path_validate_workdir_buf(git_repository *repo, git_str *path) { return git_path_validate_workdir_with_len(repo, path->ptr, path->size); } -int git_path_normalize_slashes(git_buf *out, const char *path) +int git_path_normalize_slashes(git_str *out, const char *path) { int error; char *p; - if ((error = git_buf_puts(out, path)) < 0) + if ((error = git_str_puts(out, path)) < 0) return error; for (p = out->ptr; *p; p++) { @@ -2004,7 +2004,7 @@ extern int git_path_is_gitfile(const char *path, size_t pathlen, git_path_gitfil bool git_path_supports_symlinks(const char *dir) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; bool supported = false; struct stat st; int fd; @@ -2020,7 +2020,7 @@ bool git_path_supports_symlinks(const char *dir) done: if (path.size) (void)p_unlink(path.ptr); - git_buf_dispose(&path); + git_str_dispose(&path); return supported; } diff --git a/src/path.h b/src/path.h index de6ec8ff2..4074c3425 100644 --- a/src/path.h +++ b/src/path.h @@ -10,7 +10,7 @@ #include "common.h" #include "posix.h" -#include "buffer.h" +#include "str.h" #include "vector.h" #include "git2/sys/path.h" @@ -35,13 +35,13 @@ * The `git_path_dirname` implementation is thread safe. The returned * string must be manually free'd. * - * The `git_path_dirname_r` implementation writes the dirname to a `git_buf` + * The `git_path_dirname_r` implementation writes the dirname to a `git_str` * if the buffer pointer is not NULL. * It returns an error code < 0 if there is an allocation error, otherwise * the length of the dirname (which will be > 0). */ extern char *git_path_dirname(const char *path); -extern int git_path_dirname_r(git_buf *buffer, const char *path); +extern int git_path_dirname_r(git_str *buffer, const char *path); /* * This function returns the basename of the file, which is the last @@ -55,17 +55,17 @@ extern int git_path_dirname_r(git_buf *buffer, const char *path); * The `git_path_basename` implementation is thread safe. The returned * string must be manually free'd. * - * The `git_path_basename_r` implementation writes the basename to a `git_buf`. + * The `git_path_basename_r` implementation writes the basename to a `git_str`. * It returns an error code < 0 if there is an allocation error, otherwise * the length of the basename (which will be >= 0). */ extern char *git_path_basename(const char *path); -extern int git_path_basename_r(git_buf *buffer, const char *path); +extern int git_path_basename_r(git_str *buffer, const char *path); /* Return the offset of the start of the basename. Unlike the other * basename functions, this returns 0 if the path is empty. */ -extern size_t git_path_basename_offset(git_buf *buffer); +extern size_t git_path_basename_offset(git_str *buffer); /** * Find offset to root of path if path has one. @@ -80,7 +80,7 @@ extern int git_path_root(const char *path); /** * Ensure path has a trailing '/'. */ -extern int git_path_to_dir(git_buf *path); +extern int git_path_to_dir(git_str *path); /** * Ensure string has a trailing '/' if there is space for it. @@ -150,12 +150,12 @@ GIT_INLINE(int) git_path_at_end_of_segment(const char *p) return !*p || *p == '/'; } -extern int git__percent_decode(git_buf *decoded_out, const char *input); +extern int git__percent_decode(git_str *decoded_out, const char *input); /** * Extract path from file:// URL. */ -extern int git_path_fromurl(git_buf *local_path_out, const char *file_url); +extern int git_path_fromurl(git_str *local_path_out, const char *file_url); /** @@ -205,7 +205,7 @@ extern int git_path_lstat(const char *path, struct stat *st); * @param item Item that might be in the directory. * @return 0 if item exists in directory, <0 otherwise. */ -extern bool git_path_contains(git_buf *dir, const char *item); +extern bool git_path_contains(git_str *dir, const char *item); /** * Check if the given path contains the given subdirectory. @@ -214,7 +214,7 @@ extern bool git_path_contains(git_buf *dir, const char *item); * @param subdir Subdirectory name to look for in parent * @return true if subdirectory exists, false otherwise. */ -extern bool git_path_contains_dir(git_buf *parent, const char *subdir); +extern bool git_path_contains_dir(git_str *parent, const char *subdir); /** * Determine the common directory length between two paths, including @@ -237,7 +237,7 @@ extern size_t git_path_common_dirlen(const char *one, const char *two); * if there was not common root between the paths, * or <0. */ -extern int git_path_make_relative(git_buf *path, const char *parent); +extern int git_path_make_relative(git_str *path, const char *parent); /** * Check if the given path contains the given file. @@ -246,7 +246,7 @@ extern int git_path_make_relative(git_buf *path, const char *parent); * @param file File name to look for in parent * @return true if file exists, false otherwise. */ -extern bool git_path_contains_file(git_buf *dir, const char *file); +extern bool git_path_contains_file(git_str *dir, const char *file); /** * Prepend base to unrooted path or just copy path over. @@ -255,24 +255,24 @@ extern bool git_path_contains_file(git_buf *dir, const char *file); * is, either the end of the base directory prefix or the path root. */ extern int git_path_join_unrooted( - git_buf *path_out, const char *path, const char *base, ssize_t *root_at); + git_str *path_out, const char *path, const char *base, ssize_t *root_at); /** * Removes multiple occurrences of '/' in a row, squashing them into a * single '/'. */ -extern void git_path_squash_slashes(git_buf *path); +extern void git_path_squash_slashes(git_str *path); /** * Clean up path, prepending base if it is not already rooted. */ -extern int git_path_prettify(git_buf *path_out, const char *path, const char *base); +extern int git_path_prettify(git_str *path_out, const char *path, const char *base); /** * Clean up path, prepending base if it is not already rooted and * appending a slash. */ -extern int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base); +extern int git_path_prettify_dir(git_str *path_out, const char *path, const char *base); /** * Get a directory from a path. @@ -283,7 +283,7 @@ extern int git_path_prettify_dir(git_buf *path_out, const char *path, const char * appends the trailing '/'. If the path does not exist, it is * treated like a regular filename. */ -extern int git_path_find_dir(git_buf *dir); +extern int git_path_find_dir(git_str *dir); /** * Resolve relative references within a path. @@ -295,7 +295,7 @@ extern int git_path_find_dir(git_buf *dir); * Additionally, this will recognize an "c:/" drive prefix or a "xyz://" URL * prefix and not touch that part of the path. */ -extern int git_path_resolve_relative(git_buf *path, size_t ceiling); +extern int git_path_resolve_relative(git_str *path, size_t ceiling); /** * Apply a relative path to base path. @@ -306,7 +306,7 @@ extern int git_path_resolve_relative(git_buf *path, size_t ceiling); * slash, "." will be eaten with no change, and ".." will remove a * segment from the base path. */ -extern int git_path_apply_relative(git_buf *target, const char *relpath); +extern int git_path_apply_relative(git_str *target, const char *relpath); enum { GIT_PATH_DIR_IGNORE_CASE = (1u << 0), @@ -328,9 +328,9 @@ enum { * @return 0 on success or error code from OS error or from callback */ extern int git_path_direach( - git_buf *pathbuf, + git_str *pathbuf, uint32_t flags, - int (*callback)(void *payload, git_buf *path), + int (*callback)(void *payload, git_str *path), void *payload); /** @@ -360,7 +360,7 @@ extern int git_path_cmp( * @param payload Passed to fn as the first ath. */ extern int git_path_walk_up( - git_buf *pathbuf, + git_str *pathbuf, const char *ceiling, int (*callback)(void *payload, const char *path), void *payload); @@ -429,10 +429,10 @@ extern bool git_path_has_non_ascii(const char *path, size_t pathlen); typedef struct { iconv_t map; - git_buf buf; + git_str buf; } git_path_iconv_t; -#define GIT_PATH_ICONV_INIT { (iconv_t)-1, GIT_BUF_INIT } +#define GIT_PATH_ICONV_INIT { (iconv_t)-1, GIT_STR_INIT } /* Init iconv data for converting decomposed UTF-8 to precomposed */ extern int git_path_iconv_init_precompose(git_path_iconv_t *ic); @@ -461,7 +461,7 @@ struct git_path_diriter git_win32_path path; size_t parent_len; - git_buf path_utf8; + git_str path_utf8; size_t parent_utf8_len; HANDLE handle; @@ -472,13 +472,13 @@ struct git_path_diriter unsigned int needs_next; }; -#define GIT_PATH_DIRITER_INIT { {0}, 0, GIT_BUF_INIT, 0, INVALID_HANDLE_VALUE } +#define GIT_PATH_DIRITER_INIT { {0}, 0, GIT_STR_INIT, 0, INVALID_HANDLE_VALUE } #else struct git_path_diriter { - git_buf path; + git_str path; size_t parent_len; unsigned int flags; @@ -490,7 +490,7 @@ struct git_path_diriter #endif }; -#define GIT_PATH_DIRITER_INIT { GIT_BUF_INIT } +#define GIT_PATH_DIRITER_INIT { GIT_STR_INIT } #endif @@ -584,7 +584,7 @@ extern int git_path_dirload( /* Used for paths to repositories on the filesystem */ extern bool git_path_is_local_file_url(const char *file_url); -extern int git_path_from_url_or_path(git_buf *local_path_out, const char *url_or_path); +extern int git_path_from_url_or_path(git_str *local_path_out, const char *url_or_path); /* Flags to determine path validity in `git_path_isvalid` */ #define GIT_PATH_REJECT_TRAVERSAL (1 << 0) @@ -713,12 +713,12 @@ extern int git_path_validate_workdir_with_len( size_t path_len); extern int git_path_validate_workdir_buf( git_repository *repo, - git_buf *buf); + git_str *buf); /** * Convert any backslashes into slashes */ -int git_path_normalize_slashes(git_buf *out, const char *path); +int git_path_normalize_slashes(git_str *out, const char *path); bool git_path_supports_symlinks(const char *dir); diff --git a/src/pathspec.c b/src/pathspec.c index c6ad16571..3e44643c6 100644 --- a/src/pathspec.c +++ b/src/pathspec.c @@ -20,11 +20,11 @@ /* what is the common non-wildcard prefix for all items in the pathspec */ char *git_pathspec_prefix(const git_strarray *pathspec) { - git_buf prefix = GIT_BUF_INIT; + git_str prefix = GIT_STR_INIT; const char *scan; if (!pathspec || !pathspec->count || - git_buf_common_prefix(&prefix, pathspec->strings, pathspec->count) < 0) + git_str_common_prefix(&prefix, pathspec->strings, pathspec->count) < 0) return NULL; /* diff prefix will only be leading non-wildcards */ @@ -33,16 +33,16 @@ char *git_pathspec_prefix(const git_strarray *pathspec) (scan == prefix.ptr || (*(scan - 1) != '\\'))) break; } - git_buf_truncate(&prefix, scan - prefix.ptr); + git_str_truncate(&prefix, scan - prefix.ptr); if (prefix.size <= 0) { - git_buf_dispose(&prefix); + git_str_dispose(&prefix); return NULL; } - git_buf_unescape(&prefix); + git_str_unescape(&prefix); - return git_buf_detach(&prefix); + return git_str_detach(&prefix); } /* is there anything in the spec that needs to be filtered on */ diff --git a/src/pathspec.h b/src/pathspec.h index c4d1a83d3..bfdcd48a7 100644 --- a/src/pathspec.h +++ b/src/pathspec.h @@ -10,7 +10,7 @@ #include "common.h" #include "git2/pathspec.h" -#include "buffer.h" +#include "str.h" #include "vector.h" #include "pool.h" #include "array.h" diff --git a/src/push.c b/src/push.c index b724188f9..3bf7ba5d9 100644 --- a/src/push.c +++ b/src/push.c @@ -159,7 +159,7 @@ int git_push_add_refspec(git_push *push, const char *refspec) int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) { - git_buf remote_ref_name = GIT_BUF_INIT; + git_str remote_ref_name = GIT_STR_INIT; size_t i, j; git_refspec *fetch_spec; push_spec *push_spec = NULL; @@ -180,9 +180,9 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) continue; /* Clear the buffer which can be dirty from previous iteration */ - git_buf_clear(&remote_ref_name); + git_str_clear(&remote_ref_name); - if ((error = git_refspec_transform(&remote_ref_name, fetch_spec, status->ref)) < 0) + if ((error = git_refspec__transform(&remote_ref_name, fetch_spec, status->ref)) < 0) goto on_error; /* Find matching push ref spec */ @@ -197,7 +197,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) /* Update the remote ref */ if (git_oid_is_zero(&push_spec->loid)) { - error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name)); + error = git_reference_lookup(&remote_ref, push->remote->repo, git_str_cstr(&remote_ref_name)); if (error >= 0) { error = git_reference_delete(remote_ref); @@ -205,7 +205,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) } } else { error = git_reference_create(NULL, push->remote->repo, - git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, + git_str_cstr(&remote_ref_name), &push_spec->loid, 1, "update by push"); } @@ -218,7 +218,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) } if (fire_callback && callbacks && callbacks->update_tips) { - error = callbacks->update_tips(git_buf_cstr(&remote_ref_name), + error = callbacks->update_tips(git_str_cstr(&remote_ref_name), &push_spec->roid, &push_spec->loid, callbacks->payload); if (error < 0) @@ -229,7 +229,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks) error = 0; on_error: - git_buf_dispose(&remote_ref_name); + git_str_dispose(&remote_ref_name); return error; } diff --git a/src/reader.c b/src/reader.c index 48928940d..ba9775240 100644 --- a/src/reader.c +++ b/src/reader.c @@ -23,7 +23,7 @@ typedef struct { } tree_reader; static int tree_reader_read( - git_buf *out, + git_str *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, @@ -42,7 +42,7 @@ static int tree_reader_read( blobsize = git_blob_rawsize(blob); GIT_ERROR_CHECK_BLOBSIZE(blobsize); - if ((error = git_buf_set(out, git_blob_rawcontent(blob), (size_t)blobsize)) < 0) + if ((error = git_str_set(out, git_blob_rawcontent(blob), (size_t)blobsize)) < 0) goto done; if (out_id) @@ -83,14 +83,14 @@ typedef struct { } workdir_reader; static int workdir_reader_read( - git_buf *out, + git_str *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { workdir_reader *reader = (workdir_reader *)_reader; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; struct stat st; git_filemode_t filemode; git_filter_list *filters = NULL; @@ -120,7 +120,7 @@ static int workdir_reader_read( GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT)) < 0) goto done; - if ((error = git_filter_list_apply_to_file(out, + if ((error = git_filter_list__apply_to_file(out, filters, reader->repo, path.ptr)) < 0) goto done; @@ -146,7 +146,7 @@ static int workdir_reader_read( done: git_filter_list_free(filters); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -186,7 +186,7 @@ typedef struct { } index_reader; static int index_reader_read( - git_buf *out, + git_str *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, @@ -247,7 +247,7 @@ int git_reader_for_index( /* generic */ int git_reader_read( - git_buf *out, + git_str *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *reader, diff --git a/src/reader.h b/src/reader.h index 18a6a1103..b58dc93f6 100644 --- a/src/reader.h +++ b/src/reader.h @@ -25,7 +25,7 @@ typedef struct git_reader git_reader; * reader after disposing the underlying object that it reads. */ struct git_reader { - int (*read)(git_buf *out, git_oid *out_oid, git_filemode_t *mode, git_reader *reader, const char *filename); + int (*read)(git_str *out, git_oid *out_oid, git_filemode_t *mode, git_reader *reader, const char *filename); }; /** @@ -91,7 +91,7 @@ extern int git_reader_for_workdir( * @param filename The filename to read from the reader */ extern int git_reader_read( - git_buf *out, + git_str *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *reader, diff --git a/src/rebase.c b/src/rebase.c index 4f10c296b..302fc81fc 100644 --- a/src/rebase.c +++ b/src/rebase.c @@ -7,10 +7,11 @@ #include "common.h" -#include "buffer.h" +#include "str.h" #include "repository.h" #include "posix.h" #include "filebuf.h" +#include "commit.h" #include "merge.h" #include "array.h" #include "config.h" @@ -90,22 +91,22 @@ static int rebase_state_type( char **path_out, git_repository *repo) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_rebase_t type = GIT_REBASE_NONE; - if (git_buf_joinpath(&path, repo->gitdir, REBASE_APPLY_DIR) < 0) + if (git_str_joinpath(&path, repo->gitdir, REBASE_APPLY_DIR) < 0) return -1; - if (git_path_isdir(git_buf_cstr(&path))) { + if (git_path_isdir(git_str_cstr(&path))) { type = GIT_REBASE_APPLY; goto done; } - git_buf_clear(&path); - if (git_buf_joinpath(&path, repo->gitdir, REBASE_MERGE_DIR) < 0) + git_str_clear(&path); + if (git_str_joinpath(&path, repo->gitdir, REBASE_MERGE_DIR) < 0) return -1; - if (git_path_isdir(git_buf_cstr(&path))) { + if (git_path_isdir(git_str_cstr(&path))) { type = GIT_REBASE_MERGE; goto done; } @@ -114,36 +115,36 @@ done: *type_out = type; if (type != GIT_REBASE_NONE && path_out) - *path_out = git_buf_detach(&path); + *path_out = git_str_detach(&path); - git_buf_dispose(&path); + git_str_dispose(&path); return 0; } GIT_INLINE(int) rebase_readfile( - git_buf *out, - git_buf *state_path, + git_str *out, + git_str *state_path, const char *filename) { size_t state_path_len = state_path->size; int error; - git_buf_clear(out); + git_str_clear(out); - if ((error = git_buf_joinpath(state_path, state_path->ptr, filename)) < 0 || + if ((error = git_str_joinpath(state_path, state_path->ptr, filename)) < 0 || (error = git_futils_readbuffer(out, state_path->ptr)) < 0) goto done; - git_buf_rtrim(out); + git_str_rtrim(out); done: - git_buf_truncate(state_path, state_path_len); + git_str_truncate(state_path, state_path_len); return error; } GIT_INLINE(int) rebase_readint( - size_t *out, git_buf *asc_out, git_buf *state_path, const char *filename) + size_t *out, git_str *asc_out, git_str *state_path, const char *filename) { int32_t num; const char *eol; @@ -163,7 +164,7 @@ GIT_INLINE(int) rebase_readint( } GIT_INLINE(int) rebase_readoid( - git_oid *out, git_buf *str_out, git_buf *state_path, const char *filename) + git_oid *out, git_str *str_out, git_str *state_path, const char *filename) { int error; @@ -201,13 +202,13 @@ static git_rebase_operation *rebase_operation_alloc( static int rebase_open_merge(git_rebase *rebase) { - git_buf state_path = GIT_BUF_INIT, buf = GIT_BUF_INIT, cmt = GIT_BUF_INIT; + git_str state_path = GIT_STR_INIT, buf = GIT_STR_INIT, cmt = GIT_STR_INIT; git_oid id; git_rebase_operation *operation; size_t i, msgnum = 0, end; int error; - if ((error = git_buf_puts(&state_path, rebase->state_path)) < 0) + if ((error = git_str_puts(&state_path, rebase->state_path)) < 0) goto done; /* Read 'msgnum' if it exists (otherwise, let msgnum = 0) */ @@ -234,9 +235,9 @@ static int rebase_open_merge(git_rebase *rebase) GIT_ERROR_CHECK_ARRAY(rebase->operations); for (i = 0; i < end; i++) { - git_buf_clear(&cmt); + git_str_clear(&cmt); - if ((error = git_buf_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 || + if ((error = git_str_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 || (error = rebase_readoid(&id, &buf, &state_path, cmt.ptr)) < 0) goto done; @@ -248,12 +249,12 @@ static int rebase_open_merge(git_rebase *rebase) if ((error = rebase_readfile(&buf, &state_path, ONTO_NAME_FILE)) < 0) goto done; - rebase->onto_name = git_buf_detach(&buf); + rebase->onto_name = git_str_detach(&buf); done: - git_buf_dispose(&cmt); - git_buf_dispose(&state_path); - git_buf_dispose(&buf); + git_str_dispose(&cmt); + git_str_dispose(&state_path); + git_str_dispose(&buf); return error; } @@ -296,8 +297,8 @@ int git_rebase_open( const git_rebase_options *given_opts) { git_rebase *rebase; - git_buf path = GIT_BUF_INIT, orig_head_name = GIT_BUF_INIT, - orig_head_id = GIT_BUF_INIT, onto_id = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, orig_head_name = GIT_STR_INIT, + orig_head_id = GIT_STR_INIT, onto_id = GIT_STR_INIT; size_t state_path_len; int error; @@ -320,54 +321,54 @@ int git_rebase_open( goto done; } - if ((error = git_buf_puts(&path, rebase->state_path)) < 0) + if ((error = git_str_puts(&path, rebase->state_path)) < 0) goto done; - state_path_len = git_buf_len(&path); + state_path_len = git_str_len(&path); - if ((error = git_buf_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 || + if ((error = git_str_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 || (error = git_futils_readbuffer(&orig_head_name, path.ptr)) < 0) goto done; - git_buf_rtrim(&orig_head_name); + git_str_rtrim(&orig_head_name); if (strcmp(ORIG_DETACHED_HEAD, orig_head_name.ptr) == 0) rebase->head_detached = 1; - git_buf_truncate(&path, state_path_len); + git_str_truncate(&path, state_path_len); - if ((error = git_buf_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0) + if ((error = git_str_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0) goto done; if (!git_path_isfile(path.ptr)) { /* Previous versions of git.git used 'head' here; support that. */ - git_buf_truncate(&path, state_path_len); + git_str_truncate(&path, state_path_len); - if ((error = git_buf_joinpath(&path, path.ptr, HEAD_FILE)) < 0) + if ((error = git_str_joinpath(&path, path.ptr, HEAD_FILE)) < 0) goto done; } if ((error = git_futils_readbuffer(&orig_head_id, path.ptr)) < 0) goto done; - git_buf_rtrim(&orig_head_id); + git_str_rtrim(&orig_head_id); if ((error = git_oid_fromstr(&rebase->orig_head_id, orig_head_id.ptr)) < 0) goto done; - git_buf_truncate(&path, state_path_len); + git_str_truncate(&path, state_path_len); - if ((error = git_buf_joinpath(&path, path.ptr, ONTO_FILE)) < 0 || + if ((error = git_str_joinpath(&path, path.ptr, ONTO_FILE)) < 0 || (error = git_futils_readbuffer(&onto_id, path.ptr)) < 0) goto done; - git_buf_rtrim(&onto_id); + git_str_rtrim(&onto_id); if ((error = git_oid_fromstr(&rebase->onto_id, onto_id.ptr)) < 0) goto done; if (!rebase->head_detached) - rebase->orig_head_name = git_buf_detach(&orig_head_name); + rebase->orig_head_name = git_str_detach(&orig_head_name); switch (rebase->type) { case GIT_REBASE_INTERACTIVE: @@ -391,10 +392,10 @@ done: else git_rebase_free(rebase); - git_buf_dispose(&path); - git_buf_dispose(&orig_head_name); - git_buf_dispose(&orig_head_id); - git_buf_dispose(&onto_id); + git_str_dispose(&path); + git_str_dispose(&orig_head_name); + git_str_dispose(&orig_head_id); + git_str_dispose(&onto_id); return error; } @@ -410,20 +411,20 @@ static int rebase_cleanup(git_rebase *rebase) static int rebase_setupfile(git_rebase *rebase, const char *filename, int flags, const char *fmt, ...) { - git_buf path = GIT_BUF_INIT, - contents = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, + contents = GIT_STR_INIT; va_list ap; int error; va_start(ap, fmt); - git_buf_vprintf(&contents, fmt, ap); + git_str_vprintf(&contents, fmt, ap); va_end(ap); - if ((error = git_buf_joinpath(&path, rebase->state_path, filename)) == 0) + if ((error = git_str_joinpath(&path, rebase->state_path, filename)) == 0) error = git_futils_writebuffer(&contents, path.ptr, flags, REBASE_FILE_MODE); - git_buf_dispose(&path); - git_buf_dispose(&contents); + git_str_dispose(&path); + git_str_dispose(&contents); return error; } @@ -440,7 +441,7 @@ static const char *rebase_onto_name(const git_annotated_commit *onto) static int rebase_setupfiles_merge(git_rebase *rebase) { - git_buf commit_filename = GIT_BUF_INIT; + git_str commit_filename = GIT_STR_INIT; char id_str[GIT_OID_HEXSZ]; git_rebase_operation *operation; size_t i; @@ -453,8 +454,8 @@ static int rebase_setupfiles_merge(git_rebase *rebase) for (i = 0; i < git_array_size(rebase->operations); i++) { operation = git_array_get(rebase->operations, i); - git_buf_clear(&commit_filename); - git_buf_printf(&commit_filename, CMT_FILE_FMT, i+1); + git_str_clear(&commit_filename); + git_str_printf(&commit_filename, CMT_FILE_FMT, i+1); git_oid_fmt(id_str, &operation->id); @@ -464,7 +465,7 @@ static int rebase_setupfiles_merge(git_rebase *rebase) } done: - git_buf_dispose(&commit_filename); + git_str_dispose(&commit_filename); return error; } @@ -626,16 +627,16 @@ static int rebase_init_merge( { git_reference *head_ref = NULL; git_commit *onto_commit = NULL; - git_buf reflog = GIT_BUF_INIT; - git_buf state_path = GIT_BUF_INIT; + git_str reflog = GIT_STR_INIT; + git_str state_path = GIT_STR_INIT; int error; GIT_UNUSED(upstream); - if ((error = git_buf_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0) + if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0) goto done; - rebase->state_path = git_buf_detach(&state_path); + rebase->state_path = git_str_detach(&state_path); GIT_ERROR_CHECK_ALLOC(rebase->state_path); if (branch->ref_name && strcmp(branch->ref_name, "HEAD")) { @@ -654,7 +655,7 @@ static int rebase_init_merge( git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto)); if ((error = rebase_setupfiles(rebase)) < 0 || - (error = git_buf_printf(&reflog, + (error = git_str_printf(&reflog, "rebase: checkout %s", rebase_onto_name(onto))) < 0 || (error = git_commit_lookup( &onto_commit, repo, git_annotated_commit_id(onto))) < 0 || @@ -667,8 +668,8 @@ static int rebase_init_merge( done: git_reference_free(head_ref); git_commit_free(onto_commit); - git_buf_dispose(&reflog); - git_buf_dispose(&state_path); + git_str_dispose(&reflog); + git_str_dispose(&state_path); return error; } @@ -795,7 +796,7 @@ static int rebase_next_merge( git_rebase_operation **out, git_rebase *rebase) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_commit *current_commit = NULL, *parent_commit = NULL; git_tree *current_tree = NULL, *head_tree = NULL, *parent_tree = NULL; git_index *index = NULL; @@ -848,7 +849,7 @@ done: git_tree_free(parent_tree); git_commit_free(parent_commit); git_commit_free(current_commit); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -955,14 +956,14 @@ static int create_signed( size_t parent_count, const git_commit **parents) { - git_buf commit_content = GIT_BUF_INIT, - commit_signature = GIT_BUF_INIT, - signature_field = GIT_BUF_INIT; + git_str commit_content = GIT_STR_INIT; + git_buf commit_signature = { NULL, 0, 0 }, + signature_field = { NULL, 0, 0 }; int error; git_error_clear(); - if ((error = git_commit_create_buffer(&commit_content, + if ((error = git_commit__create_buffer(&commit_content, rebase->repo, author, committer, message_encoding, message, tree, parent_count, parents)) < 0) goto done; @@ -986,7 +987,7 @@ static int create_signed( done: git_buf_dispose(&commit_signature); git_buf_dispose(&signature_field); - git_buf_dispose(&commit_content); + git_str_dispose(&commit_content); return error; } #endif @@ -1216,13 +1217,13 @@ done: return error; } -static int notes_ref_lookup(git_buf *out, git_rebase *rebase) +static int notes_ref_lookup(git_str *out, git_rebase *rebase) { git_config *config = NULL; int do_rewrite, error; if (rebase->options.rewrite_notes_ref) { - git_buf_attach_notowned(out, + git_str_attach_notowned(out, rebase->options.rewrite_notes_ref, strlen(rebase->options.rewrite_notes_ref)); return 0; @@ -1239,7 +1240,7 @@ static int notes_ref_lookup(git_buf *out, git_rebase *rebase) } error = do_rewrite ? - git_config_get_string_buf(out, config, "notes.rewriteref") : + git_config__get_string_buf(out, config, "notes.rewriteref") : GIT_ENOTFOUND; done: @@ -1294,7 +1295,7 @@ static int rebase_copy_notes( git_rebase *rebase, const git_signature *committer) { - git_buf path = GIT_BUF_INIT, rewritten = GIT_BUF_INIT, notes_ref = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, rewritten = GIT_STR_INIT, notes_ref = GIT_STR_INIT; char *pair_list, *fromstr, *tostr, *end; git_oid from, to; unsigned int linenum = 1; @@ -1309,7 +1310,7 @@ static int rebase_copy_notes( goto done; } - if ((error = git_buf_joinpath(&path, rebase->state_path, REWRITTEN_FILE)) < 0 || + if ((error = git_str_joinpath(&path, rebase->state_path, REWRITTEN_FILE)) < 0 || (error = git_futils_readbuffer(&rewritten, path.ptr)) < 0) goto done; @@ -1349,9 +1350,9 @@ on_error: error = -1; done: - git_buf_dispose(&rewritten); - git_buf_dispose(&path); - git_buf_dispose(¬es_ref); + git_str_dispose(&rewritten); + git_str_dispose(&path); + git_str_dispose(¬es_ref); return error; } @@ -1360,16 +1361,16 @@ static int return_to_orig_head(git_rebase *rebase) { git_reference *terminal_ref = NULL, *branch_ref = NULL, *head_ref = NULL; git_commit *terminal_commit = NULL; - git_buf branch_msg = GIT_BUF_INIT, head_msg = GIT_BUF_INIT; + git_str branch_msg = GIT_STR_INIT, head_msg = GIT_STR_INIT; char onto[GIT_OID_HEXSZ]; int error = 0; git_oid_fmt(onto, &rebase->onto_id); - if ((error = git_buf_printf(&branch_msg, + if ((error = git_str_printf(&branch_msg, "rebase finished: %s onto %.*s", rebase->orig_head_name, GIT_OID_HEXSZ, onto)) == 0 && - (error = git_buf_printf(&head_msg, + (error = git_str_printf(&head_msg, "rebase finished: returning to %s", rebase->orig_head_name)) == 0 && (error = git_repository_head(&terminal_ref, rebase->repo)) == 0 && @@ -1383,8 +1384,8 @@ static int return_to_orig_head(git_rebase *rebase) rebase->repo, GIT_HEAD_FILE, rebase->orig_head_name, 1, head_msg.ptr); - git_buf_dispose(&head_msg); - git_buf_dispose(&branch_msg); + git_str_dispose(&head_msg); + git_str_dispose(&branch_msg); git_commit_free(terminal_commit); git_reference_free(head_ref); git_reference_free(branch_ref); diff --git a/src/refdb_fs.c b/src/refdb_fs.c index 24cb22fb0..37eb85ecc 100644 --- a/src/refdb_fs.c +++ b/src/refdb_fs.c @@ -69,11 +69,11 @@ typedef struct refdb_fs_backend { static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name); GIT_INLINE(int) loose_path( - git_buf *out, + git_str *out, const char *base, const char *refname) { - if (git_buf_joinpath(out, base, refname) < 0) + if (git_str_joinpath(out, base, refname) < 0) return -1; return git_path_validate_filesystem_with_suffix(out->ptr, out->size, @@ -81,7 +81,7 @@ GIT_INLINE(int) loose_path( } GIT_INLINE(int) reflog_path( - git_buf *out, + git_str *out, git_repository *repo, const char *refname) { @@ -91,7 +91,7 @@ GIT_INLINE(int) reflog_path( base = (strcmp(refname, GIT_HEAD_FILE) == 0) ? repo->gitdir : repo->commondir; - if ((error = git_buf_joinpath(out, base, GIT_REFLOG_DIR)) < 0) + if ((error = git_str_joinpath(out, base, GIT_REFLOG_DIR)) < 0) return error; return loose_path(out, out->ptr, refname); @@ -106,7 +106,7 @@ static int packref_cmp(const void *a_, const void *b_) static int packed_reload(refdb_fs_backend *backend) { int error; - git_buf packedrefs = GIT_BUF_INIT; + git_str packedrefs = GIT_STR_INIT; char *scan, *eof, *eol; if (!backend->gitpath) @@ -212,7 +212,7 @@ static int packed_reload(refdb_fs_backend *backend) } git_sortedcache_wunlock(backend->refcache); - git_buf_dispose(&packedrefs); + git_str_dispose(&packedrefs); return 0; @@ -221,17 +221,17 @@ parse_failed: GIT_UNUSED(git_sortedcache_clear(backend->refcache, false)); git_sortedcache_wunlock(backend->refcache); - git_buf_dispose(&packedrefs); + git_str_dispose(&packedrefs); return -1; } static int loose_parse_oid( - git_oid *oid, const char *filename, git_buf *file_content) + git_oid *oid, const char *filename, git_str *file_content) { - const char *str = git_buf_cstr(file_content); + const char *str = git_str_cstr(file_content); - if (git_buf_len(file_content) < GIT_OID_HEXSZ) + if (git_str_len(file_content) < GIT_OID_HEXSZ) goto corrupted; /* we need to get 40 OID characters from the file */ @@ -248,13 +248,13 @@ corrupted: return -1; } -static int loose_readbuffer(git_buf *buf, const char *base, const char *path) +static int loose_readbuffer(git_str *buf, const char *base, const char *path) { int error; if ((error = loose_path(buf, base, path)) < 0 || (error = git_futils_readbuffer(buf, buf->ptr)) < 0) - git_buf_dispose(buf); + git_str_dispose(buf); return error; } @@ -262,7 +262,7 @@ static int loose_readbuffer(git_buf *buf, const char *base, const char *path) static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name) { int error = 0; - git_buf ref_file = GIT_BUF_INIT; + git_str ref_file = GIT_STR_INIT; struct packref *ref = NULL; git_oid oid; @@ -275,7 +275,7 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name) } /* skip symbolic refs */ - if (!git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF)) + if (!git__prefixcmp(git_str_cstr(&ref_file), GIT_SYMREF)) goto done; /* parse OID from file */ @@ -295,11 +295,11 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name) git_sortedcache_wunlock(backend->refcache); done: - git_buf_dispose(&ref_file); + git_str_dispose(&ref_file); return error; } -static int _dirent_loose_load(void *payload, git_buf *full_path) +static int _dirent_loose_load(void *payload, git_str *full_path) { refdb_fs_backend *backend = payload; const char *file_path; @@ -333,9 +333,9 @@ static int _dirent_loose_load(void *payload, git_buf *full_path) static int packed_loadloose(refdb_fs_backend *backend) { int error; - git_buf refs_path = GIT_BUF_INIT; + git_str refs_path = GIT_STR_INIT; - if (git_buf_joinpath(&refs_path, backend->gitpath, GIT_REFS_DIR) < 0) + if (git_str_joinpath(&refs_path, backend->gitpath, GIT_REFS_DIR) < 0) return -1; /* @@ -346,7 +346,7 @@ static int packed_loadloose(refdb_fs_backend *backend) error = git_path_direach( &refs_path, backend->direach_flags, _dirent_loose_load, backend); - git_buf_dispose(&refs_path); + git_str_dispose(&refs_path); return error; } @@ -357,7 +357,7 @@ static int refdb_fs_backend__exists( const char *ref_name) { refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent); - git_buf ref_path = GIT_BUF_INIT; + git_str ref_path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(backend); @@ -381,18 +381,18 @@ static int refdb_fs_backend__exists( } out: - git_buf_dispose(&ref_path); + git_str_dispose(&ref_path); return error; } -static const char *loose_parse_symbolic(git_buf *file_content) +static const char *loose_parse_symbolic(git_str *file_content) { const unsigned int header_len = (unsigned int)strlen(GIT_SYMREF); const char *refname_start; refname_start = (const char *)file_content->ptr; - if (git_buf_len(file_content) < header_len + 1) { + if (git_str_len(file_content) < header_len + 1) { git_error_set(GIT_ERROR_REFERENCE, "corrupted loose reference file"); return NULL; } @@ -424,7 +424,7 @@ static int loose_lookup( refdb_fs_backend *backend, const char *ref_name) { - git_buf ref_file = GIT_BUF_INIT; + git_str ref_file = GIT_STR_INIT; int error = 0; const char *ref_dir; @@ -438,10 +438,10 @@ static int loose_lookup( if ((error = loose_readbuffer(&ref_file, ref_dir, ref_name)) < 0) /* cannot read loose ref file - gah */; - else if (git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF) == 0) { + else if (git__prefixcmp(git_str_cstr(&ref_file), GIT_SYMREF) == 0) { const char *target; - git_buf_rtrim(&ref_file); + git_str_rtrim(&ref_file); if (!(target = loose_parse_symbolic(&ref_file))) error = -1; @@ -455,7 +455,7 @@ static int loose_lookup( *out = git_reference__alloc(ref_name, &oid, NULL); } - git_buf_dispose(&ref_file); + git_str_dispose(&ref_file); return error; } @@ -542,7 +542,7 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter) static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) { int error = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_iterator *fsit = NULL; git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT; const git_index_entry *entry = NULL; @@ -578,26 +578,26 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) } } - if ((error = git_buf_puts(&path, backend->commonpath)) < 0 || - (error = git_buf_put(&path, ref_prefix, ref_prefix_len)) < 0) { - git_buf_dispose(&path); + if ((error = git_str_puts(&path, backend->commonpath)) < 0 || + (error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) { + git_str_dispose(&path); return error; } if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) { - git_buf_dispose(&path); + git_str_dispose(&path); return (iter->glob && error == GIT_ENOTFOUND)? 0 : error; } - error = git_buf_sets(&path, ref_prefix); + error = git_str_sets(&path, ref_prefix); while (!error && !git_iterator_advance(&entry, fsit)) { const char *ref_name; char *ref_dup; - git_buf_truncate(&path, ref_prefix_len); - git_buf_puts(&path, entry->path); - ref_name = git_buf_cstr(&path); + git_str_truncate(&path, ref_prefix_len); + git_str_puts(&path, entry->path); + ref_name = git_str_cstr(&path); if (git__suffixcmp(ref_name, ".lock") == 0 || (iter->glob && wildmatch(iter->glob, ref_name, 0) != 0)) @@ -611,7 +611,7 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter) } git_iterator_free(fsit); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -810,7 +810,7 @@ static int reference_path_available( static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *name) { int error, filebuf_flags; - git_buf ref_path = GIT_BUF_INIT; + git_str ref_path = GIT_STR_INIT; const char *basedir; GIT_ASSERT_ARG(file); @@ -845,7 +845,7 @@ static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char * if (error == GIT_EDIRECTORY) git_error_set(GIT_ERROR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name); - git_buf_dispose(&ref_path); + git_str_dispose(&ref_path); return error; } @@ -1013,7 +1013,7 @@ static int packed_remove_loose(refdb_fs_backend *backend) { size_t i; git_filebuf lock = GIT_FILEBUF_INIT; - git_buf ref_content = GIT_BUF_INIT; + git_str ref_content = GIT_STR_INIT; int error = 0; /* backend->refcache is already locked when this is called */ @@ -1034,7 +1034,7 @@ static int packed_remove_loose(refdb_fs_backend *backend) continue; if (error < 0) { - git_buf_dispose(&ref_content); + git_str_dispose(&ref_content); git_error_set(GIT_ERROR_REFERENCE, "failed to lock loose reference '%s'", ref->name); return error; } @@ -1065,7 +1065,7 @@ static int packed_remove_loose(refdb_fs_backend *backend) p_unlink(lock.path_original); } - git_buf_dispose(&ref_content); + git_str_dispose(&ref_content); git_filebuf_cleanup(&lock); return 0; } @@ -1333,32 +1333,32 @@ static int refdb_fs_backend__prune_refs( const char *ref_name, const char *prefix) { - git_buf relative_path = GIT_BUF_INIT; - git_buf base_path = GIT_BUF_INIT; + git_str relative_path = GIT_STR_INIT; + git_str base_path = GIT_STR_INIT; size_t commonlen; int error; GIT_ASSERT_ARG(backend); GIT_ASSERT_ARG(ref_name); - if ((error = git_buf_sets(&relative_path, ref_name)) < 0) + if ((error = git_str_sets(&relative_path, ref_name)) < 0) goto cleanup; git_path_squash_slashes(&relative_path); - if ((commonlen = git_path_common_dirlen("refs/heads/", git_buf_cstr(&relative_path))) == strlen("refs/heads/") || - (commonlen = git_path_common_dirlen("refs/tags/", git_buf_cstr(&relative_path))) == strlen("refs/tags/") || - (commonlen = git_path_common_dirlen("refs/remotes/", git_buf_cstr(&relative_path))) == strlen("refs/remotes/")) { + if ((commonlen = git_path_common_dirlen("refs/heads/", git_str_cstr(&relative_path))) == strlen("refs/heads/") || + (commonlen = git_path_common_dirlen("refs/tags/", git_str_cstr(&relative_path))) == strlen("refs/tags/") || + (commonlen = git_path_common_dirlen("refs/remotes/", git_str_cstr(&relative_path))) == strlen("refs/remotes/")) { - git_buf_truncate(&relative_path, commonlen); + git_str_truncate(&relative_path, commonlen); if (prefix) - error = git_buf_join3(&base_path, '/', + error = git_str_join3(&base_path, '/', backend->commonpath, prefix, - git_buf_cstr(&relative_path)); + git_str_cstr(&relative_path)); else - error = git_buf_joinpath(&base_path, + error = git_str_joinpath(&base_path, backend->commonpath, - git_buf_cstr(&relative_path)); + git_str_cstr(&relative_path)); if (!error) error = git_path_validate_filesystem(base_path.ptr, base_path.size); @@ -1367,7 +1367,7 @@ static int refdb_fs_backend__prune_refs( goto cleanup; error = git_futils_rmdir_r(ref_name + commonlen, - git_buf_cstr(&base_path), + git_str_cstr(&base_path), GIT_RMDIR_EMPTY_PARENTS | GIT_RMDIR_SKIP_ROOT); if (error == GIT_ENOTFOUND) @@ -1375,8 +1375,8 @@ static int refdb_fs_backend__prune_refs( } cleanup: - git_buf_dispose(&relative_path); - git_buf_dispose(&base_path); + git_str_dispose(&relative_path); + git_str_dispose(&base_path); return error; } @@ -1405,7 +1405,7 @@ static int refdb_fs_backend__delete( static int loose_delete(refdb_fs_backend *backend, const char *ref_name) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error = 0; if ((error = loose_path(&path, backend->commonpath, ref_name)) < 0) @@ -1417,7 +1417,7 @@ static int loose_delete(refdb_fs_backend *backend, const char *ref_name) else if (error != 0) error = -1; - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -1574,17 +1574,17 @@ static void refdb_fs_backend__free(git_refdb_backend *_backend) static char *setup_namespace(git_repository *repo, const char *in) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; char *parts, *start, *end, *out = NULL; if (!in) goto done; - git_buf_puts(&path, in); + git_str_puts(&path, in); /* if the repo is not namespaced, nothing else to do */ if (repo->namespace == NULL) { - out = git_buf_detach(&path); + out = git_str_detach(&path); goto done; } @@ -1599,23 +1599,23 @@ static char *setup_namespace(git_repository *repo, const char *in) * refs under refs/namespaces/foo/refs/namespaces/bar/ */ while ((start = git__strsep(&end, "/")) != NULL) - git_buf_printf(&path, "refs/namespaces/%s/", start); + git_str_printf(&path, "refs/namespaces/%s/", start); - git_buf_printf(&path, "refs/namespaces/%s/refs", end); + git_str_printf(&path, "refs/namespaces/%s/refs", end); git__free(parts); /* Make sure that the folder with the namespace exists */ - if (git_futils_mkdir_relative(git_buf_cstr(&path), in, 0777, + if (git_futils_mkdir_relative(git_str_cstr(&path), in, 0777, GIT_MKDIR_PATH, NULL) < 0) goto done; /* Return root of the namespaced gitpath, i.e. without the trailing 'refs' */ - git_buf_rtruncate_at_char(&path, '/'); - git_buf_putc(&path, '/'); - out = git_buf_detach(&path); + git_str_rtruncate_at_char(&path, '/'); + git_str_putc(&path, '/'); + out = git_str_detach(&path); done: - git_buf_dispose(&path); + git_str_dispose(&path); return out; } @@ -1716,7 +1716,7 @@ static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char * { refdb_fs_backend *backend; git_repository *repo; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(_backend && name); @@ -1727,8 +1727,8 @@ static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char * if ((error = reflog_path(&path, repo, name)) < 0) return error; - error = create_new_reflog_file(git_buf_cstr(&path)); - git_buf_dispose(&path); + error = create_new_reflog_file(git_str_cstr(&path)); + git_str_dispose(&path); return error; } @@ -1736,15 +1736,15 @@ static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char * static int has_reflog(git_repository *repo, const char *name) { int ret = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; if (reflog_path(&path, repo, name) < 0) goto cleanup; - ret = git_path_isfile(git_buf_cstr(&path)); + ret = git_path_isfile(git_str_cstr(&path)); cleanup: - git_buf_dispose(&path); + git_str_dispose(&path); return ret; } @@ -1763,8 +1763,8 @@ static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *nam static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name) { int error = -1; - git_buf log_path = GIT_BUF_INIT; - git_buf log_file = GIT_BUF_INIT; + git_str log_path = GIT_STR_INIT; + git_str log_file = GIT_STR_INIT; git_reflog *log = NULL; git_repository *repo; refdb_fs_backend *backend; @@ -1782,16 +1782,16 @@ static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, if (reflog_path(&log_path, repo, name) < 0) goto cleanup; - error = git_futils_readbuffer(&log_file, git_buf_cstr(&log_path)); + error = git_futils_readbuffer(&log_file, git_str_cstr(&log_path)); if (error < 0 && error != GIT_ENOTFOUND) goto cleanup; if ((error == GIT_ENOTFOUND) && - ((error = create_new_reflog_file(git_buf_cstr(&log_path))) < 0)) + ((error = create_new_reflog_file(git_str_cstr(&log_path))) < 0)) goto cleanup; if ((error = reflog_parse(log, - git_buf_cstr(&log_file), git_buf_len(&log_file))) < 0) + git_str_cstr(&log_file), git_str_len(&log_file))) < 0) goto cleanup; *out = log; @@ -1801,14 +1801,14 @@ cleanup: git_reflog_free(log); success: - git_buf_dispose(&log_file); - git_buf_dispose(&log_path); + git_str_dispose(&log_file); + git_str_dispose(&log_path); return error; } static int serialize_reflog_entry( - git_buf *buf, + git_str *buf, const git_oid *oid_old, const git_oid *oid_new, const git_signature *committer, @@ -1820,38 +1820,38 @@ static int serialize_reflog_entry( git_oid_tostr(raw_old, GIT_OID_HEXSZ+1, oid_old); git_oid_tostr(raw_new, GIT_OID_HEXSZ+1, oid_new); - git_buf_clear(buf); + git_str_clear(buf); - git_buf_puts(buf, raw_old); - git_buf_putc(buf, ' '); - git_buf_puts(buf, raw_new); + git_str_puts(buf, raw_old); + git_str_putc(buf, ' '); + git_str_puts(buf, raw_new); git_signature__writebuf(buf, " ", committer); /* drop trailing LF */ - git_buf_rtrim(buf); + git_str_rtrim(buf); if (msg) { size_t i; - git_buf_putc(buf, '\t'); - git_buf_puts(buf, msg); + git_str_putc(buf, '\t'); + git_str_puts(buf, msg); for (i = 0; i < buf->size - 2; i++) if (buf->ptr[i] == '\n') buf->ptr[i] = ' '; - git_buf_rtrim(buf); + git_str_rtrim(buf); } - git_buf_putc(buf, '\n'); + git_str_putc(buf, '\n'); - return git_buf_oom(buf); + return git_str_oom(buf); } static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char *refname) { git_repository *repo; - git_buf log_path = GIT_BUF_INIT; + git_str log_path = GIT_STR_INIT; int error; repo = backend->repo; @@ -1864,17 +1864,17 @@ static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char if (reflog_path(&log_path, repo, refname) < 0) return -1; - if (!git_path_isfile(git_buf_cstr(&log_path))) { + if (!git_path_isfile(git_str_cstr(&log_path))) { git_error_set(GIT_ERROR_INVALID, "log file for reference '%s' doesn't exist", refname); error = -1; goto cleanup; } - error = git_filebuf_open(file, git_buf_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE); + error = git_filebuf_open(file, git_str_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE); cleanup: - git_buf_dispose(&log_path); + git_str_dispose(&log_path); return error; } @@ -1885,7 +1885,7 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo unsigned int i; git_reflog_entry *entry; refdb_fs_backend *backend; - git_buf log = GIT_BUF_INIT; + git_str log = GIT_STR_INIT; git_filebuf fbuf = GIT_FILEBUF_INIT; GIT_ASSERT_ARG(_backend); @@ -1911,7 +1911,7 @@ cleanup: git_filebuf_cleanup(&fbuf); success: - git_buf_dispose(&log); + git_str_dispose(&log); return error; } @@ -1921,7 +1921,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co { int error, is_symbolic, open_flags; git_oid old_id = {{0}}, new_id = {{0}}; - git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT, path = GIT_STR_INIT; git_repository *repo = backend->repo; is_symbolic = ref->type == GIT_REFERENCE_SYMBOLIC; @@ -1965,7 +1965,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co if ((error = reflog_path(&path, repo, ref->name)) < 0) goto cleanup; - if (((error = git_futils_mkpath2file(git_buf_cstr(&path), 0777)) < 0) && + if (((error = git_futils_mkpath2file(git_str_cstr(&path), 0777)) < 0) && (error != GIT_EEXISTS)) { goto cleanup; } @@ -1973,11 +1973,11 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co /* If the new branch matches part of the namespace of a previously deleted branch, * there maybe an obsolete/unused directory (or directory hierarchy) in the way. */ - if (git_path_isdir(git_buf_cstr(&path))) { - if ((error = git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_SKIP_NONEMPTY)) < 0) { + if (git_path_isdir(git_str_cstr(&path))) { + if ((error = git_futils_rmdir_r(git_str_cstr(&path), NULL, GIT_RMDIR_SKIP_NONEMPTY)) < 0) { if (error == GIT_ENOTFOUND) error = 0; - } else if (git_path_isdir(git_buf_cstr(&path))) { + } else if (git_path_isdir(git_str_cstr(&path))) { git_error_set(GIT_ERROR_REFERENCE, "cannot create reflog at '%s', there are reflogs beneath that folder", ref->name); error = GIT_EDIRECTORY; @@ -1992,11 +1992,11 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co if (backend->fsync) open_flags |= O_FSYNC; - error = git_futils_writebuffer(&buf, git_buf_cstr(&path), open_flags, GIT_REFLOG_FILE_MODE); + error = git_futils_writebuffer(&buf, git_str_cstr(&path), open_flags, GIT_REFLOG_FILE_MODE); cleanup: - git_buf_dispose(&buf); - git_buf_dispose(&path); + git_str_dispose(&buf); + git_str_dispose(&path); return error; } @@ -2004,10 +2004,10 @@ cleanup: static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name) { int error = 0, fd; - git_buf old_path = GIT_BUF_INIT; - git_buf new_path = GIT_BUF_INIT; - git_buf temp_path = GIT_BUF_INIT; - git_buf normalized = GIT_BUF_INIT; + git_str old_path = GIT_STR_INIT; + git_str new_path = GIT_STR_INIT; + git_str temp_path = GIT_STR_INIT; + git_str normalized = GIT_STR_INIT; git_repository *repo; refdb_fs_backend *backend; @@ -2022,16 +2022,16 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_ &normalized, new_name, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL)) < 0) return error; - if (git_buf_joinpath(&temp_path, repo->gitdir, GIT_REFLOG_DIR) < 0) + if (git_str_joinpath(&temp_path, repo->gitdir, GIT_REFLOG_DIR) < 0) return -1; - if ((error = loose_path(&old_path, git_buf_cstr(&temp_path), old_name)) < 0) + if ((error = loose_path(&old_path, git_str_cstr(&temp_path), old_name)) < 0) return error; - if ((error = loose_path(&new_path, git_buf_cstr(&temp_path), git_buf_cstr(&normalized))) < 0) + if ((error = loose_path(&new_path, git_str_cstr(&temp_path), git_str_cstr(&normalized))) < 0) return error; - if (!git_path_exists(git_buf_cstr(&old_path))) { + if (!git_path_exists(git_str_cstr(&old_path))) { error = GIT_ENOTFOUND; goto cleanup; } @@ -2043,43 +2043,43 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_ * - a/b -> a/b/c * - a/b/c/d -> a/b/c */ - if ((error = loose_path(&temp_path, git_buf_cstr(&temp_path), "temp_reflog")) < 0) + if ((error = loose_path(&temp_path, git_str_cstr(&temp_path), "temp_reflog")) < 0) return error; - if ((fd = git_futils_mktmp(&temp_path, git_buf_cstr(&temp_path), GIT_REFLOG_FILE_MODE)) < 0) { + if ((fd = git_futils_mktmp(&temp_path, git_str_cstr(&temp_path), GIT_REFLOG_FILE_MODE)) < 0) { error = -1; goto cleanup; } p_close(fd); - if (p_rename(git_buf_cstr(&old_path), git_buf_cstr(&temp_path)) < 0) { + if (p_rename(git_str_cstr(&old_path), git_str_cstr(&temp_path)) < 0) { git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name); error = -1; goto cleanup; } - if (git_path_isdir(git_buf_cstr(&new_path)) && - (git_futils_rmdir_r(git_buf_cstr(&new_path), NULL, GIT_RMDIR_SKIP_NONEMPTY) < 0)) { + if (git_path_isdir(git_str_cstr(&new_path)) && + (git_futils_rmdir_r(git_str_cstr(&new_path), NULL, GIT_RMDIR_SKIP_NONEMPTY) < 0)) { error = -1; goto cleanup; } - if (git_futils_mkpath2file(git_buf_cstr(&new_path), GIT_REFLOG_DIR_MODE) < 0) { + if (git_futils_mkpath2file(git_str_cstr(&new_path), GIT_REFLOG_DIR_MODE) < 0) { error = -1; goto cleanup; } - if (p_rename(git_buf_cstr(&temp_path), git_buf_cstr(&new_path)) < 0) { + if (p_rename(git_str_cstr(&temp_path), git_str_cstr(&new_path)) < 0) { git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name); error = -1; } cleanup: - git_buf_dispose(&temp_path); - git_buf_dispose(&old_path); - git_buf_dispose(&new_path); - git_buf_dispose(&normalized); + git_str_dispose(&temp_path); + git_str_dispose(&old_path); + git_str_dispose(&new_path); + git_str_dispose(&normalized); return error; } @@ -2087,7 +2087,7 @@ cleanup: static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name) { refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent); - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(_backend); @@ -2105,7 +2105,7 @@ static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name error = refdb_fs_backend__prune_refs(backend, name, GIT_REFLOG_DIR); out: - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -2115,7 +2115,7 @@ int git_refdb_backend_fs( git_repository *repository) { int t = 0; - git_buf gitpath = GIT_BUF_INIT; + git_str gitpath = GIT_STR_INIT; refdb_fs_backend *backend; backend = git__calloc(1, sizeof(refdb_fs_backend)); @@ -2140,13 +2140,13 @@ int git_refdb_backend_fs( goto fail; } - if (git_buf_joinpath(&gitpath, backend->commonpath, GIT_PACKEDREFS_FILE) < 0 || + if (git_str_joinpath(&gitpath, backend->commonpath, GIT_PACKEDREFS_FILE) < 0 || git_sortedcache_new( &backend->refcache, offsetof(struct packref, name), - NULL, NULL, packref_cmp, git_buf_cstr(&gitpath)) < 0) + NULL, NULL, packref_cmp, git_str_cstr(&gitpath)) < 0) goto fail; - git_buf_dispose(&gitpath); + git_str_dispose(&gitpath); if (!git_repository__configmap_lookup(&t, backend->repo, GIT_CONFIGMAP_IGNORECASE) && t) { backend->iterator_flags |= GIT_ITERATOR_IGNORE_CASE; @@ -2182,7 +2182,7 @@ int git_refdb_backend_fs( return 0; fail: - git_buf_dispose(&gitpath); + git_str_dispose(&gitpath); git__free(backend->gitpath); git__free(backend->commonpath); git__free(backend); diff --git a/src/refs.c b/src/refs.c index 8acfa84a5..0ac455d24 100644 --- a/src/refs.c +++ b/src/refs.c @@ -247,7 +247,7 @@ int git_reference_dwim(git_reference **out, git_repository *repo, const char *re int error = 0, i, valid; bool fallbackmode = true, foundvalid = false; git_reference *ref; - git_buf refnamebuf = GIT_BUF_INIT, name = GIT_BUF_INIT; + git_str refnamebuf = GIT_STR_INIT, name = GIT_STR_INIT; static const char *formatters[] = { "%s", @@ -260,18 +260,18 @@ int git_reference_dwim(git_reference **out, git_repository *repo, const char *re }; if (*refname) - git_buf_puts(&name, refname); + git_str_puts(&name, refname); else { - git_buf_puts(&name, GIT_HEAD_FILE); + git_str_puts(&name, GIT_HEAD_FILE); fallbackmode = false; } for (i = 0; formatters[i] && (fallbackmode || i == 0); i++) { - git_buf_clear(&refnamebuf); + git_str_clear(&refnamebuf); - if ((error = git_buf_printf(&refnamebuf, formatters[i], git_buf_cstr(&name))) < 0 || - (error = git_reference_name_is_valid(&valid, git_buf_cstr(&refnamebuf))) < 0) + if ((error = git_str_printf(&refnamebuf, formatters[i], git_str_cstr(&name))) < 0 || + (error = git_reference_name_is_valid(&valid, git_str_cstr(&refnamebuf))) < 0) goto cleanup; if (!valid) { @@ -280,7 +280,7 @@ int git_reference_dwim(git_reference **out, git_repository *repo, const char *re } foundvalid = true; - error = git_reference_lookup_resolved(&ref, repo, git_buf_cstr(&refnamebuf), -1); + error = git_reference_lookup_resolved(&ref, repo, git_str_cstr(&refnamebuf), -1); if (!error) { *out = ref; @@ -296,14 +296,14 @@ cleanup: if (error && !foundvalid) { /* never found a valid reference name */ git_error_set(GIT_ERROR_REFERENCE, - "could not use '%s' as valid reference name", git_buf_cstr(&name)); + "could not use '%s' as valid reference name", git_str_cstr(&name)); } if (error == GIT_ENOTFOUND) git_error_set(GIT_ERROR_REFERENCE, "no reference found for shorthand '%s'", refname); - git_buf_dispose(&name); - git_buf_dispose(&refnamebuf); + git_str_dispose(&name); + git_str_dispose(&refnamebuf); return error; } @@ -891,7 +891,7 @@ static bool is_all_caps_and_underscore(const char *name, size_t len) /* Inspired from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/refs.c#L36-100 */ int git_reference__normalize_name( - git_buf *buf, + git_str *buf, const char *name, unsigned int flags) { @@ -914,7 +914,7 @@ int git_reference__normalize_name( goto cleanup; if (normalize) - git_buf_clear(buf); + git_str_clear(buf); #ifdef GIT_USE_ICONV if ((flags & GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE) != 0) { @@ -927,9 +927,9 @@ int git_reference__normalize_name( #endif if (!validate) { - git_buf_sets(buf, current); + git_str_sets(buf, current); - error = git_buf_oom(buf) ? -1 : 0; + error = git_str_oom(buf) ? -1 : 0; goto cleanup; } @@ -949,13 +949,13 @@ int git_reference__normalize_name( process_flags &= ~GIT_REFERENCE_FORMAT_REFSPEC_PATTERN; if (normalize) { - size_t cur_len = git_buf_len(buf); + size_t cur_len = git_str_len(buf); - git_buf_joinpath(buf, git_buf_cstr(buf), current); - git_buf_truncate(buf, + git_str_joinpath(buf, git_str_cstr(buf), current); + git_str_truncate(buf, cur_len + segment_len + (segments_count ? 1 : 0)); - if (git_buf_oom(buf)) { + if (git_str_oom(buf)) { error = -1; goto cleanup; } @@ -1008,7 +1008,7 @@ cleanup: "the given reference name '%s' is not valid", name); if (error && normalize) - git_buf_dispose(buf); + git_str_dispose(buf); #ifdef GIT_USE_ICONV git_path_iconv_clear(&ic); @@ -1023,13 +1023,13 @@ int git_reference_normalize_name( const char *name, unsigned int flags) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; if ((error = git_reference__normalize_name(&buf, name, flags)) < 0) goto cleanup; - if (git_buf_len(&buf) > buffer_size - 1) { + if (git_str_len(&buf) > buffer_size - 1) { git_error_set( GIT_ERROR_REFERENCE, "the provided buffer is too short to hold the normalization of '%s'", name); @@ -1037,13 +1037,13 @@ int git_reference_normalize_name( goto cleanup; } - if ((error = git_buf_copy_cstr(buffer_out, buffer_size, &buf)) < 0) + if ((error = git_str_copy_cstr(buffer_out, buffer_size, &buf)) < 0) goto cleanup; error = 0; cleanup: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -1143,12 +1143,12 @@ int git_reference__update_for_commit( { git_reference *ref_new = NULL; git_commit *commit = NULL; - git_buf reflog_msg = GIT_BUF_INIT; + git_str reflog_msg = GIT_STR_INIT; const git_signature *who; int error; if ((error = git_commit_lookup(&commit, repo, id)) < 0 || - (error = git_buf_printf(&reflog_msg, "%s%s: %s", + (error = git_str_printf(&reflog_msg, "%s%s: %s", operation ? operation : "commit", commit_type(commit), git_commit_summary(commit))) < 0) @@ -1161,15 +1161,15 @@ int git_reference__update_for_commit( return error; error = reference__create(&ref_new, repo, ref->name, id, NULL, 1, who, - git_buf_cstr(&reflog_msg), &ref->target.oid, NULL); + git_str_cstr(&reflog_msg), &ref->target.oid, NULL); } else error = git_reference__update_terminal( - repo, ref_name, id, who, git_buf_cstr(&reflog_msg)); + repo, ref_name, id, who, git_str_cstr(&reflog_msg)); done: git_reference_free(ref_new); - git_buf_dispose(&reflog_msg); + git_str_dispose(&reflog_msg); git_commit_free(commit); return error; } diff --git a/src/refs.h b/src/refs.h index 376a512f8..cb888bf8f 100644 --- a/src/refs.h +++ b/src/refs.h @@ -13,7 +13,7 @@ #include "git2/refs.h" #include "git2/refdb.h" #include "strmap.h" -#include "buffer.h" +#include "str.h" #include "oid.h" extern bool git_reference__enable_symbolic_ref_target_validation; @@ -83,7 +83,7 @@ struct git_reference { */ git_reference *git_reference__realloc(git_reference **ptr_to_ref, const char *name); -int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags); +int git_reference__normalize_name(git_str *buf, const char *name, unsigned int flags); int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *sig, const char *log_message); int git_reference__name_is_valid(int *valid, const char *name, unsigned int flags); int git_reference__is_branch(const char *ref_name); diff --git a/src/refspec.c b/src/refspec.c index c72721a43..f0a0c2bfb 100644 --- a/src/refspec.c +++ b/src/refspec.c @@ -7,8 +7,7 @@ #include "refspec.h" -#include "git2/errors.h" - +#include "buf.h" #include "refs.h" #include "util.h" #include "vector.h" @@ -243,16 +242,12 @@ int git_refspec_dst_matches(const git_refspec *refspec, const char *refname) } static int refspec_transform( - git_buf *out, const char *from, const char *to, const char *name) + git_str *out, const char *from, const char *to, const char *name) { const char *from_star, *to_star; size_t replacement_len, star_offset; - int error; - - if ((error = git_buf_sanitize(out)) < 0) - return error; - git_buf_clear(out); + git_str_clear(out); /* * There are two parts to each side of a refspec, the bit @@ -269,72 +264,72 @@ static int refspec_transform( star_offset = from_star - from; /* the first half is copied over */ - git_buf_put(out, to, to_star - to); + git_str_put(out, to, to_star - to); /* * Copy over the name, but exclude the trailing part in "from" starting * after the glob */ replacement_len = strlen(name + star_offset) - strlen(from_star + 1); - git_buf_put(out, name + star_offset, replacement_len); + git_str_put(out, name + star_offset, replacement_len); - return git_buf_puts(out, to_star + 1); + return git_str_puts(out, to_star + 1); } int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *name) { - int error; + GIT_BUF_WRAP_PRIVATE(out, git_refspec__transform, spec, name); +} +int git_refspec__transform(git_str *out, const git_refspec *spec, const char *name) +{ GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(spec); GIT_ASSERT_ARG(name); - if ((error = git_buf_sanitize(out)) < 0) - return error; - if (!git_refspec_src_matches(spec, name)) { git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the source", name); return -1; } if (!spec->pattern) - return git_buf_puts(out, spec->dst ? spec->dst : ""); + return git_str_puts(out, spec->dst ? spec->dst : ""); return refspec_transform(out, spec->src, spec->dst, name); } int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *name) { - int error; + GIT_BUF_WRAP_PRIVATE(out, git_refspec__rtransform, spec, name); +} +int git_refspec__rtransform(git_str *out, const git_refspec *spec, const char *name) +{ GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(spec); GIT_ASSERT_ARG(name); - if ((error = git_buf_sanitize(out)) < 0) - return error; - if (!git_refspec_dst_matches(spec, name)) { git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the destination", name); return -1; } if (!spec->pattern) - return git_buf_puts(out, spec->src); + return git_str_puts(out, spec->src); return refspec_transform(out, spec->dst, spec->src, name); } -int git_refspec__serialize(git_buf *out, const git_refspec *refspec) +int git_refspec__serialize(git_str *out, const git_refspec *refspec) { if (refspec->force) - git_buf_putc(out, '+'); + git_str_putc(out, '+'); - git_buf_printf(out, "%s:%s", + git_str_printf(out, "%s:%s", refspec->src != NULL ? refspec->src : "", refspec->dst != NULL ? refspec->dst : ""); - return git_buf_oom(out) == false; + return git_str_oom(out) == false; } int git_refspec_is_wildcard(const git_refspec *spec) @@ -354,7 +349,7 @@ git_direction git_refspec_direction(const git_refspec *spec) int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; size_t j, pos; git_remote_head key; git_refspec *cur; @@ -382,14 +377,14 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs) /* shorthand on the lhs */ if (git__prefixcmp(spec->src, GIT_REFS_DIR)) { for (j = 0; formatters[j]; j++) { - git_buf_clear(&buf); - git_buf_printf(&buf, formatters[j], spec->src); - GIT_ERROR_CHECK_ALLOC_BUF(&buf); + git_str_clear(&buf); + git_str_printf(&buf, formatters[j], spec->src); + GIT_ERROR_CHECK_ALLOC_STR(&buf); - key.name = (char *) git_buf_cstr(&buf); + key.name = (char *) git_str_cstr(&buf); if (!git_vector_search(&pos, refs, &key)) { /* we found something to match the shorthand, set src to that */ - cur->src = git_buf_detach(&buf); + cur->src = git_str_detach(&buf); } } } @@ -403,18 +398,18 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs) if (spec->dst && git__prefixcmp(spec->dst, GIT_REFS_DIR)) { /* if it starts with "remotes" then we just prepend "refs/" */ if (!git__prefixcmp(spec->dst, "remotes/")) { - git_buf_puts(&buf, GIT_REFS_DIR); + git_str_puts(&buf, GIT_REFS_DIR); } else { - git_buf_puts(&buf, GIT_REFS_HEADS_DIR); + git_str_puts(&buf, GIT_REFS_HEADS_DIR); } - git_buf_puts(&buf, spec->dst); - GIT_ERROR_CHECK_ALLOC_BUF(&buf); + git_str_puts(&buf, spec->dst); + GIT_ERROR_CHECK_ALLOC_STR(&buf); - cur->dst = git_buf_detach(&buf); + cur->dst = git_str_detach(&buf); } - git_buf_dispose(&buf); + git_str_dispose(&buf); if (cur->dst == NULL && spec->dst != NULL) { cur->dst = git__strdup(spec->dst); diff --git a/src/refspec.h b/src/refspec.h index 2b4111f04..bf4f7fcfb 100644 --- a/src/refspec.h +++ b/src/refspec.h @@ -10,7 +10,7 @@ #include "common.h" #include "git2/refspec.h" -#include "buffer.h" +#include "str.h" #include "vector.h" struct git_refspec { @@ -25,6 +25,9 @@ struct git_refspec { #define GIT_REFSPEC_TAGS "refs/tags/*:refs/tags/*" +int git_refspec__transform(git_str *out, const git_refspec *spec, const char *name); +int git_refspec__rtransform(git_str *out, const git_refspec *spec, const char *name); + int git_refspec__parse( struct git_refspec *refspec, const char *str, @@ -32,7 +35,7 @@ int git_refspec__parse( void git_refspec__dispose(git_refspec *refspec); -int git_refspec__serialize(git_buf *out, const git_refspec *refspec); +int git_refspec__serialize(git_str *out, const git_refspec *refspec); /** * Determines if a refspec is a wildcard refspec. diff --git a/src/remote.c b/src/remote.c index 56d7e42db..bde4ce779 100644 --- a/src/remote.c +++ b/src/remote.c @@ -7,11 +7,8 @@ #include "remote.h" -#include "git2/config.h" -#include "git2/types.h" -#include "git2/oid.h" -#include "git2/net.h" - +#include "buf.h" +#include "branch.h" #include "config.h" #include "repository.h" #include "fetch.h" @@ -20,6 +17,11 @@ #include "fetchhead.h" #include "push.h" +#include "git2/config.h" +#include "git2/types.h" +#include "git2/oid.h" +#include "git2/net.h" + #define CONFIG_URL_FMT "remote.%s.url" #define CONFIG_PUSHURL_FMT "remote.%s.pushurl" #define CONFIG_FETCH_FMT "remote.%s.fetch" @@ -60,14 +62,14 @@ static int add_refspec(git_remote *remote, const char *string, bool is_fetch) static int download_tags_value(git_remote *remote, git_config *cfg) { git_config_entry *ce; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; - if (git_buf_printf(&buf, "remote.%s.tagopt", remote->name) < 0) + if (git_str_printf(&buf, "remote.%s.tagopt", remote->name) < 0) return -1; - error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false); - git_buf_dispose(&buf); + error = git_config__lookup_entry(&ce, cfg, git_str_cstr(&buf), false); + git_str_dispose(&buf); if (!error && ce && ce->value) { if (!strcmp(ce->value, "--no-tags")) @@ -99,7 +101,7 @@ static int ensure_remote_name_is_valid(const char *name) static int write_add_refspec(git_repository *repo, const char *name, const char *refspec, bool fetch) { git_config *cfg; - git_buf var = GIT_BUF_INIT; + git_str var = GIT_STR_INIT; git_refspec spec; const char *fmt; int error; @@ -117,7 +119,7 @@ static int write_add_refspec(git_repository *repo, const char *name, const char git_refspec__dispose(&spec); - if ((error = git_buf_printf(&var, fmt, name)) < 0) + if ((error = git_str_printf(&var, fmt, name)) < 0) return error; /* @@ -130,11 +132,11 @@ static int write_add_refspec(git_repository *repo, const char *name, const char } cleanup: - git_buf_dispose(&var); + git_str_dispose(&var); return 0; } -static int canonicalize_url(git_buf *out, const char *in) +static int canonicalize_url(git_str *out, const char *in) { if (in == NULL || strlen(in) == 0) { git_error_set(GIT_ERROR_INVALID, "cannot set empty URL"); @@ -149,18 +151,18 @@ static int canonicalize_url(git_buf *out, const char *in) (git__isalpha(in[2]) || git__isdigit(in[2]))) { const char *c; for (c = in; *c; c++) - git_buf_putc(out, *c == '\\' ? '/' : *c); + git_str_putc(out, *c == '\\' ? '/' : *c); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } #endif - return git_buf_puts(out, in); + return git_str_puts(out, in); } -static int default_fetchspec_for_name(git_buf *buf, const char *name) +static int default_fetchspec_for_name(git_str *buf, const char *name) { - if (git_buf_printf(buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0) + if (git_str_printf(buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0) return -1; return 0; @@ -204,9 +206,9 @@ int git_remote_create_with_opts(git_remote **out, const char *url, const git_rem { git_remote *remote = NULL; git_config *config_ro = NULL, *config_rw; - git_buf canonical_url = GIT_BUF_INIT; - git_buf var = GIT_BUF_INIT; - git_buf specbuf = GIT_BUF_INIT; + git_str canonical_url = GIT_STR_INIT; + git_str var = GIT_STR_INIT; + git_str specbuf = GIT_STR_INIT; const git_remote_create_options dummy_opts = GIT_REMOTE_CREATE_OPTIONS_INIT; int error = -1; @@ -254,7 +256,7 @@ int git_remote_create_with_opts(git_remote **out, const char *url, const git_rem GIT_ERROR_CHECK_ALLOC(remote->name); if (opts->repository && - ((error = git_buf_printf(&var, CONFIG_URL_FMT, opts->name)) < 0 || + ((error = git_str_printf(&var, CONFIG_URL_FMT, opts->name)) < 0 || (error = git_repository_config__weakptr(&config_rw, opts->repository)) < 0 || (error = git_config_set_string(config_rw, var.ptr, canonical_url.ptr)) < 0)) goto on_error; @@ -269,7 +271,7 @@ int git_remote_create_with_opts(git_remote **out, const char *url, const git_rem if ((error = default_fetchspec_for_name(&specbuf, opts->name)) < 0) goto on_error; - fetch = git_buf_cstr(&specbuf); + fetch = git_str_cstr(&specbuf); } if ((error = add_refspec(remote, fetch, true)) < 0) @@ -293,7 +295,7 @@ int git_remote_create_with_opts(git_remote **out, const char *url, const git_rem remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO; - git_buf_dispose(&var); + git_str_dispose(&var); *out = remote; error = 0; @@ -303,15 +305,15 @@ on_error: git_remote_free(remote); git_config_free(config_ro); - git_buf_dispose(&specbuf); - git_buf_dispose(&canonical_url); - git_buf_dispose(&var); + git_str_dispose(&specbuf); + git_str_dispose(&canonical_url); + git_str_dispose(&var); return error; } int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT; @@ -322,14 +324,14 @@ int git_remote_create(git_remote **out, git_repository *repo, const char *name, if (canonicalize_url(&buf, url) < 0) return GIT_ERROR; - git_buf_clear(&buf); + git_str_clear(&buf); opts.repository = repo; opts.name = name; error = git_remote_create_with_opts(out, url, &opts); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -425,13 +427,13 @@ static int refspec_cb(const git_config_entry *entry, void *payload) } static int get_optional_config( - bool *found, git_config *config, git_buf *buf, + bool *found, git_config *config, git_str *buf, git_config_foreach_cb cb, void *payload) { int error = 0; - const char *key = git_buf_cstr(buf); + const char *key = git_str_cstr(buf); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) return -1; if (cb != NULL) @@ -453,7 +455,7 @@ static int get_optional_config( int git_remote_lookup(git_remote **out, git_repository *repo, const char *name) { git_remote *remote = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; const char *val; int error = 0; git_config *config; @@ -484,7 +486,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name) goto cleanup; } - if ((error = git_buf_printf(&buf, "remote.%s.url", name)) < 0) + if ((error = git_str_printf(&buf, "remote.%s.url", name)) < 0) goto cleanup; if ((error = get_optional_config(&found, config, &buf, NULL, (void *)&val)) < 0) @@ -501,8 +503,8 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name) } val = NULL; - git_buf_clear(&buf); - git_buf_printf(&buf, "remote.%s.pushurl", name); + git_str_clear(&buf); + git_str_printf(&buf, "remote.%s.pushurl", name); if ((error = get_optional_config(&found, config, &buf, NULL, (void *)&val)) < 0) goto cleanup; @@ -523,15 +525,15 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name) data.remote = remote; data.fetch = true; - git_buf_clear(&buf); - git_buf_printf(&buf, "remote.%s.fetch", name); + git_str_clear(&buf); + git_str_printf(&buf, "remote.%s.fetch", name); if ((error = get_optional_config(NULL, config, &buf, refspec_cb, &data)) < 0) goto cleanup; data.fetch = false; - git_buf_clear(&buf); - git_buf_printf(&buf, "remote.%s.push", name); + git_str_clear(&buf); + git_str_printf(&buf, "remote.%s.push", name); if ((error = get_optional_config(NULL, config, &buf, refspec_cb, &data)) < 0) goto cleanup; @@ -550,7 +552,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name) cleanup: git_config_free(config); - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error < 0) git_remote_free(remote); @@ -560,12 +562,12 @@ cleanup: static int lookup_remote_prune_config(git_remote *remote, git_config *config, const char *name) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error = 0; - git_buf_printf(&buf, "remote.%s.prune", name); + git_str_printf(&buf, "remote.%s.prune", name); - if ((error = git_config_get_bool(&remote->prune_refs, config, git_buf_cstr(&buf))) < 0) { + if ((error = git_config_get_bool(&remote->prune_refs, config, git_str_cstr(&buf))) < 0) { if (error == GIT_ENOTFOUND) { git_error_clear(); @@ -578,7 +580,7 @@ static int lookup_remote_prune_config(git_remote *remote, git_config *config, co } } - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -619,7 +621,7 @@ int git_remote_set_instance_url(git_remote *remote, const char *url) static int set_url(git_repository *repo, const char *remote, const char *pattern, const char *url) { git_config *cfg; - git_buf buf = GIT_BUF_INIT, canonical_url = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT, canonical_url = GIT_STR_INIT; int error; GIT_ASSERT_ARG(repo); @@ -631,7 +633,7 @@ static int set_url(git_repository *repo, const char *remote, const char *pattern if ((error = git_repository_config__weakptr(&cfg, repo)) < 0) return error; - if ((error = git_buf_printf(&buf, pattern, remote)) < 0) + if ((error = git_str_printf(&buf, pattern, remote)) < 0) return error; if (url) { @@ -644,8 +646,8 @@ static int set_url(git_repository *repo, const char *remote, const char *pattern } cleanup: - git_buf_dispose(&canonical_url); - git_buf_dispose(&buf); + git_str_dispose(&canonical_url); + git_str_dispose(&buf); return error; } @@ -683,7 +685,7 @@ int git_remote_set_pushurl(git_repository *repo, const char *remote, const char } static int resolve_url( - git_buf *resolved_url, + git_str *resolved_url, const char *url, int direction, const git_remote_callbacks *callbacks) @@ -692,27 +694,28 @@ static int resolve_url( GIT_UNUSED(direction); GIT_UNUSED(callbacks); #else - int status, error; + git_buf buf = GIT_BUF_INIT; + int error; if (callbacks && callbacks->resolve_url) { - git_buf_clear(resolved_url); - status = callbacks->resolve_url(resolved_url, url, direction, callbacks->payload); - if (status != GIT_PASSTHROUGH) { - git_error_set_after_callback_function(status, "git_resolve_url_cb"); + error = callbacks->resolve_url(&buf, url, direction, callbacks->payload); - if ((error = git_buf_sanitize(resolved_url)) < 0) - return error; + if (error != GIT_PASSTHROUGH) { + git_error_set_after_callback_function(error, "git_resolve_url_cb"); - return status; + git_str_set(resolved_url, buf.ptr, buf.size); + git_buf_dispose(&buf); + + return error; } } #endif - return git_buf_sets(resolved_url, url); + return git_str_sets(resolved_url, url); } int git_remote__urlfordirection( - git_buf *url_out, + git_str *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks) @@ -767,7 +770,7 @@ static int set_transport_custom_headers(git_transport *t, const git_strarray *cu int git_remote__connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_remote_connection_opts *conn) { git_transport *t; - git_buf url = GIT_BUF_INIT; + git_str url = GIT_STR_INIT; int flags = GIT_TRANSPORTFLAGS_NONE; int error; void *payload = NULL; @@ -811,7 +814,7 @@ int git_remote__connect(git_remote *remote, git_direction direction, const git_r remote->transport = t; - git_buf_dispose(&url); + git_str_dispose(&url); return 0; @@ -819,7 +822,7 @@ on_error: if (t) t->free(t); - git_buf_dispose(&url); + git_str_dispose(&url); if (t == remote->transport) remote->transport = NULL; @@ -885,7 +888,7 @@ static void url_config_trim(git_net_url *url) static int http_proxy_config(char **out, git_remote *remote, git_net_url *url) { git_config *cfg = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_net_url lookup_url = GIT_NET_URL_INIT; int error; @@ -902,19 +905,19 @@ static int http_proxy_config(char **out, git_remote *remote, git_net_url *url) /* remote.<name>.proxy config setting */ if (remote->name && remote->name[0]) { - git_buf_clear(&buf); + git_str_clear(&buf); - if ((error = git_buf_printf(&buf, "remote.%s.proxy", remote->name)) < 0 || + if ((error = git_str_printf(&buf, "remote.%s.proxy", remote->name)) < 0 || (error = lookup_config(out, cfg, buf.ptr)) != GIT_ENOTFOUND) goto done; } while (true) { - git_buf_clear(&buf); + git_str_clear(&buf); - if ((error = git_buf_puts(&buf, "http.")) < 0 || + if ((error = git_str_puts(&buf, "http.")) < 0 || (error = git_net_url_fmt(&buf, &lookup_url)) < 0 || - (error = git_buf_puts(&buf, ".proxy")) < 0 || + (error = git_str_puts(&buf, ".proxy")) < 0 || (error = lookup_config(out, cfg, buf.ptr)) != GIT_ENOTFOUND) goto done; @@ -924,20 +927,20 @@ static int http_proxy_config(char **out, git_remote *remote, git_net_url *url) url_config_trim(&lookup_url); } - git_buf_clear(&buf); + git_str_clear(&buf); error = lookup_config(out, cfg, "http.proxy"); done: git_config_free(cfg); - git_buf_dispose(&buf); + git_str_dispose(&buf); git_net_url_dispose(&lookup_url); return error; } static int http_proxy_env(char **out, git_remote *remote, git_net_url *url) { - git_buf proxy_env = GIT_BUF_INIT, no_proxy_env = GIT_BUF_INIT; + git_str proxy_env = GIT_STR_INIT, no_proxy_env = GIT_STR_INIT; bool use_ssl = (strcmp(url->scheme, "https") == 0); int error; @@ -963,13 +966,13 @@ static int http_proxy_env(char **out, git_remote *remote, git_net_url *url) goto done; if (!git_net_url_matches_pattern_list(url, no_proxy_env.ptr)) - *out = git_buf_detach(&proxy_env); + *out = git_str_detach(&proxy_env); else error = GIT_ENOTFOUND; done: - git_buf_dispose(&proxy_env); - git_buf_dispose(&no_proxy_env); + git_str_dispose(&proxy_env); + git_str_dispose(&no_proxy_env); return error; } @@ -1135,7 +1138,7 @@ int git_remote_fetch( int error, update_fetchhead = 1; git_remote_autotag_option_t tagopt = remote->download_tags; bool prune = false; - git_buf reflog_msg_buf = GIT_BUF_INIT; + git_str reflog_msg_buf = GIT_STR_INIT; const git_remote_callbacks *cbs = NULL; git_remote_connection_opts conn = GIT_REMOTE_CONNECTION_OPTIONS_INIT; @@ -1164,15 +1167,15 @@ int git_remote_fetch( /* Default reflog message */ if (reflog_message) - git_buf_sets(&reflog_msg_buf, reflog_message); + git_str_sets(&reflog_msg_buf, reflog_message); else { - git_buf_printf(&reflog_msg_buf, "fetch %s", + git_str_printf(&reflog_msg_buf, "fetch %s", remote->name ? remote->name : remote->url); } /* Create "remote/foo" branches for all remote branches */ - error = git_remote_update_tips(remote, cbs, update_fetchhead, tagopt, git_buf_cstr(&reflog_msg_buf)); - git_buf_dispose(&reflog_msg_buf); + error = git_remote_update_tips(remote, cbs, update_fetchhead, tagopt, git_str_cstr(&reflog_msg_buf)); + git_str_dispose(&reflog_msg_buf); if (error < 0) return error; @@ -1211,22 +1214,22 @@ static int remote_head_for_fetchspec_src(git_remote_head **out, git_vector *upda return 0; } -static int ref_to_update(int *update, git_buf *remote_name, git_remote *remote, git_refspec *spec, const char *ref_name) +static int ref_to_update(int *update, git_str *remote_name, git_remote *remote, git_refspec *spec, const char *ref_name) { int error = 0; git_repository *repo; - git_buf upstream_remote = GIT_BUF_INIT; - git_buf upstream_name = GIT_BUF_INIT; + git_str upstream_remote = GIT_STR_INIT; + git_str upstream_name = GIT_STR_INIT; repo = git_remote_owner(remote); if ((!git_reference__is_branch(ref_name)) || !git_remote_name(remote) || - (error = git_branch_upstream_remote(&upstream_remote, repo, ref_name) < 0) || - git__strcmp(git_remote_name(remote), git_buf_cstr(&upstream_remote)) || - (error = git_branch_upstream_name(&upstream_name, repo, ref_name)) < 0 || - !git_refspec_dst_matches(spec, git_buf_cstr(&upstream_name)) || - (error = git_refspec_rtransform(remote_name, spec, upstream_name.ptr)) < 0) { + (error = git_branch__upstream_remote(&upstream_remote, repo, ref_name) < 0) || + git__strcmp(git_remote_name(remote), git_str_cstr(&upstream_remote)) || + (error = git_branch__upstream_name(&upstream_name, repo, ref_name)) < 0 || + !git_refspec_dst_matches(spec, git_str_cstr(&upstream_name)) || + (error = git_refspec__rtransform(remote_name, spec, upstream_name.ptr)) < 0) { /* Not an error if there is no upstream */ if (error == GIT_ENOTFOUND) { git_error_clear(); @@ -1238,15 +1241,15 @@ static int ref_to_update(int *update, git_buf *remote_name, git_remote *remote, *update = 1; } - git_buf_dispose(&upstream_remote); - git_buf_dispose(&upstream_name); + git_str_dispose(&upstream_remote); + git_str_dispose(&upstream_name); return error; } static int remote_head_for_ref(git_remote_head **out, git_remote *remote, git_refspec *spec, git_vector *update_heads, git_reference *ref) { git_reference *resolved_ref = NULL; - git_buf remote_name = GIT_BUF_INIT; + git_str remote_name = GIT_STR_INIT; git_config *config = NULL; const char *ref_name; int error = 0, update; @@ -1281,10 +1284,10 @@ static int remote_head_for_ref(git_remote_head **out, git_remote *remote, git_re goto cleanup; if (update) - error = remote_head_for_fetchspec_src(out, update_heads, git_buf_cstr(&remote_name)); + error = remote_head_for_fetchspec_src(out, update_heads, git_str_cstr(&remote_name)); cleanup: - git_buf_dispose(&remote_name); + git_str_dispose(&remote_name); git_reference_free(resolved_ref); git_config_free(config); return error; @@ -1422,7 +1425,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks) */ git_vector_foreach(&candidates, i, refname) { git_vector_foreach(&remote->active_refspecs, j, spec) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; size_t pos; char *src_name; git_remote_head key = {0}; @@ -1430,12 +1433,12 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks) if (!git_refspec_dst_matches(spec, refname)) continue; - if ((error = git_refspec_rtransform(&buf, spec, refname)) < 0) + if ((error = git_refspec__rtransform(&buf, spec, refname)) < 0) goto cleanup; - key.name = (char *) git_buf_cstr(&buf); + key.name = (char *) git_str_cstr(&buf); error = git_vector_bsearch(&pos, &remote_refs, &key); - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error < 0 && error != GIT_ENOTFOUND) goto cleanup; @@ -1508,7 +1511,7 @@ static int update_tips_for_spec( { int error = 0, autotag, valid; unsigned int i = 0; - git_buf refname = GIT_BUF_INIT; + git_str refname = GIT_STR_INIT; git_oid old; git_odb *odb; git_remote_head *head; @@ -1531,7 +1534,7 @@ static int update_tips_for_spec( for (; i < refs->length; ++i) { head = git_vector_get(refs, i); autotag = 0; - git_buf_clear(&refname); + git_str_clear(&refname); /* Ignore malformed ref names (which also saves us from tag^{} */ if (git_reference_name_is_valid(&valid, head->name) < 0) @@ -1547,8 +1550,8 @@ static int update_tips_for_spec( if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_AUTO) autotag = 1; - git_buf_clear(&refname); - if (git_buf_puts(&refname, head->name) < 0) + git_str_clear(&refname); + if (git_str_puts(&refname, head->name) < 0) goto on_error; } } @@ -1556,7 +1559,7 @@ static int update_tips_for_spec( /* If we didn't want to auto-follow the tag, check if the refspec matches */ if (!autotag && git_refspec_src_matches(spec, head->name)) { if (spec->dst) { - if (git_refspec_transform(&refname, spec, head->name) < 0) + if (git_refspec__transform(&refname, spec, head->name) < 0) goto on_error; } else { /* @@ -1571,7 +1574,7 @@ static int update_tips_for_spec( } /* If we still don't have a refname, we don't want it */ - if (git_buf_len(&refname) == 0) { + if (git_str_len(&refname) == 0) { continue; } @@ -1625,13 +1628,13 @@ static int update_tips_for_spec( git_vector_free(&update_heads); git_refspec__dispose(&tagspec); - git_buf_dispose(&refname); + git_str_dispose(&refname); return 0; on_error: git_vector_free(&update_heads); git_refspec__dispose(&tagspec); - git_buf_dispose(&refname); + git_str_dispose(&refname); return -1; } @@ -1704,7 +1707,7 @@ static int opportunistic_updates(const git_remote *remote, const git_remote_call git_refspec *spec; git_remote_head *head; git_reference *ref; - git_buf refname = GIT_BUF_INIT; + git_str refname = GIT_STR_INIT; int error = 0; i = j = k = 0; @@ -1719,8 +1722,8 @@ static int opportunistic_updates(const git_remote *remote, const git_remote_call * FETCH_HEAD */ - git_buf_clear(&refname); - if ((error = git_refspec_transform(&refname, spec, head->name)) < 0) + git_str_clear(&refname); + if ((error = git_refspec__transform(&refname, spec, head->name)) < 0) goto cleanup; error = git_reference_name_to_id(&old, remote->repo, refname.ptr); @@ -1749,20 +1752,20 @@ static int opportunistic_updates(const git_remote *remote, const git_remote_call error = 0; cleanup: - git_buf_dispose(&refname); + git_str_dispose(&refname); return error; } static int truncate_fetch_head(const char *gitdir) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; - if ((error = git_buf_joinpath(&path, gitdir, GIT_FETCH_HEAD_FILE)) < 0) + if ((error = git_str_joinpath(&path, gitdir, GIT_FETCH_HEAD_FILE)) < 0) return error; error = git_futils_truncate(path.ptr, GIT_REFS_FILE_MODE); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -1943,7 +1946,7 @@ git_remote_autotag_option_t git_remote_autotag(const git_remote *remote) int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_autotag_option_t value) { - git_buf var = GIT_BUF_INIT; + git_str var = GIT_STR_INIT; git_config *config; int error; @@ -1955,7 +1958,7 @@ int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_ if ((error = git_repository_config__weakptr(&config, repo)) < 0) return error; - if ((error = git_buf_printf(&var, CONFIG_TAGOPT_FMT, remote))) + if ((error = git_str_printf(&var, CONFIG_TAGOPT_FMT, remote))) return error; switch (value) { @@ -1975,7 +1978,7 @@ int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_ error = -1; } - git_buf_dispose(&var); + git_str_dispose(&var); return error; } @@ -1989,25 +1992,25 @@ static int rename_remote_config_section( const char *old_name, const char *new_name) { - git_buf old_section_name = GIT_BUF_INIT, - new_section_name = GIT_BUF_INIT; + git_str old_section_name = GIT_STR_INIT, + new_section_name = GIT_STR_INIT; int error = -1; - if (git_buf_printf(&old_section_name, "remote.%s", old_name) < 0) + if (git_str_printf(&old_section_name, "remote.%s", old_name) < 0) goto cleanup; if (new_name && - (git_buf_printf(&new_section_name, "remote.%s", new_name) < 0)) + (git_str_printf(&new_section_name, "remote.%s", new_name) < 0)) goto cleanup; error = git_config_rename_section( repo, - git_buf_cstr(&old_section_name), - new_name ? git_buf_cstr(&new_section_name) : NULL); + git_str_cstr(&old_section_name), + new_name ? git_str_cstr(&new_section_name) : NULL); cleanup: - git_buf_dispose(&old_section_name); - git_buf_dispose(&new_section_name); + git_str_dispose(&old_section_name); + git_str_dispose(&new_section_name); return error; } @@ -2056,27 +2059,27 @@ static int rename_one_remote_reference( { int error; git_reference *ref = NULL, *dummy = NULL; - git_buf namespace = GIT_BUF_INIT, old_namespace = GIT_BUF_INIT; - git_buf new_name = GIT_BUF_INIT; - git_buf log_message = GIT_BUF_INIT; + git_str namespace = GIT_STR_INIT, old_namespace = GIT_STR_INIT; + git_str new_name = GIT_STR_INIT; + git_str log_message = GIT_STR_INIT; size_t pfx_len; const char *target; - if ((error = git_buf_printf(&namespace, GIT_REFS_REMOTES_DIR "%s/", new_remote_name)) < 0) + if ((error = git_str_printf(&namespace, GIT_REFS_REMOTES_DIR "%s/", new_remote_name)) < 0) return error; pfx_len = strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name) + 1; - git_buf_puts(&new_name, namespace.ptr); - if ((error = git_buf_puts(&new_name, git_reference_name(reference_in) + pfx_len)) < 0) + git_str_puts(&new_name, namespace.ptr); + if ((error = git_str_puts(&new_name, git_reference_name(reference_in) + pfx_len)) < 0) goto cleanup; - if ((error = git_buf_printf(&log_message, + if ((error = git_str_printf(&log_message, "renamed remote %s to %s", old_remote_name, new_remote_name)) < 0) goto cleanup; - if ((error = git_reference_rename(&ref, reference_in, git_buf_cstr(&new_name), 1, - git_buf_cstr(&log_message))) < 0) + if ((error = git_reference_rename(&ref, reference_in, git_str_cstr(&new_name), 1, + git_str_cstr(&log_message))) < 0) goto cleanup; if (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC) @@ -2084,29 +2087,29 @@ static int rename_one_remote_reference( /* Handle refs like origin/HEAD -> origin/master */ target = git_reference_symbolic_target(ref); - if ((error = git_buf_printf(&old_namespace, GIT_REFS_REMOTES_DIR "%s/", old_remote_name)) < 0) + if ((error = git_str_printf(&old_namespace, GIT_REFS_REMOTES_DIR "%s/", old_remote_name)) < 0) goto cleanup; if (git__prefixcmp(target, old_namespace.ptr)) goto cleanup; - git_buf_clear(&new_name); - git_buf_puts(&new_name, namespace.ptr); - if ((error = git_buf_puts(&new_name, target + pfx_len)) < 0) + git_str_clear(&new_name); + git_str_puts(&new_name, namespace.ptr); + if ((error = git_str_puts(&new_name, target + pfx_len)) < 0) goto cleanup; - error = git_reference_symbolic_set_target(&dummy, ref, git_buf_cstr(&new_name), - git_buf_cstr(&log_message)); + error = git_reference_symbolic_set_target(&dummy, ref, git_str_cstr(&new_name), + git_str_cstr(&log_message)); git_reference_free(dummy); cleanup: git_reference_free(reference_in); git_reference_free(ref); - git_buf_dispose(&namespace); - git_buf_dispose(&old_namespace); - git_buf_dispose(&new_name); - git_buf_dispose(&log_message); + git_str_dispose(&namespace); + git_str_dispose(&old_namespace); + git_str_dispose(&new_name); + git_str_dispose(&log_message); return error; } @@ -2116,15 +2119,15 @@ static int rename_remote_references( const char *new_name) { int error; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_reference *ref; git_reference_iterator *iter; - if ((error = git_buf_printf(&buf, GIT_REFS_REMOTES_DIR "%s/*", old_name)) < 0) + if ((error = git_str_printf(&buf, GIT_REFS_REMOTES_DIR "%s/*", old_name)) < 0) return error; - error = git_reference_iterator_glob_new(&iter, repo, git_buf_cstr(&buf)); - git_buf_dispose(&buf); + error = git_reference_iterator_glob_new(&iter, repo, git_str_cstr(&buf)); + git_str_dispose(&buf); if (error < 0) return error; @@ -2142,7 +2145,7 @@ static int rename_remote_references( static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const char *new_name) { git_config *config; - git_buf base = GIT_BUF_INIT, var = GIT_BUF_INIT, val = GIT_BUF_INIT; + git_str base = GIT_STR_INIT, var = GIT_STR_INIT, val = GIT_STR_INIT; const git_refspec *spec; size_t i; int error = 0; @@ -2161,7 +2164,7 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const continue; /* Does the dst part of the refspec follow the expected format? */ - if (strcmp(git_buf_cstr(&base), spec->string)) { + if (strcmp(git_str_cstr(&base), spec->string)) { char *dup; dup = git__strdup(spec->string); @@ -2175,24 +2178,24 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const /* If we do want to move it to the new section */ - git_buf_clear(&val); - git_buf_clear(&var); + git_str_clear(&val); + git_str_clear(&var); if (default_fetchspec_for_name(&val, new_name) < 0 || - git_buf_printf(&var, "remote.%s.fetch", new_name) < 0) + git_str_printf(&var, "remote.%s.fetch", new_name) < 0) { error = -1; break; } if ((error = git_config_set_string( - config, git_buf_cstr(&var), git_buf_cstr(&val))) < 0) + config, git_str_cstr(&var), git_str_cstr(&val))) < 0) break; } - git_buf_dispose(&base); - git_buf_dispose(&var); - git_buf_dispose(&val); + git_str_dispose(&base); + git_str_dispose(&var); + git_str_dispose(&val); if (error < 0) { char *str; @@ -2247,7 +2250,7 @@ cleanup: int git_remote_name_is_valid(int *valid, const char *remote_name) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_refspec refspec = {0}; int error; @@ -2258,10 +2261,10 @@ int git_remote_name_is_valid(int *valid, const char *remote_name) if (!remote_name || *remote_name == '\0') return 0; - if ((error = git_buf_printf(&buf, "refs/heads/test:refs/remotes/%s/test", remote_name)) < 0) + if ((error = git_str_printf(&buf, "refs/heads/test:refs/remotes/%s/test", remote_name)) < 0) goto done; - error = git_refspec__parse(&refspec, git_buf_cstr(&buf), true); + error = git_refspec__parse(&refspec, git_str_cstr(&buf), true); if (!error) *valid = 1; @@ -2269,7 +2272,7 @@ int git_remote_name_is_valid(int *valid, const char *remote_name) error = 0; done: - git_buf_dispose(&buf); + git_str_dispose(&buf); git_refspec__dispose(&refspec); return error; @@ -2401,7 +2404,7 @@ static int remove_branch_config_related_entries( git_config *config; git_config_entry *entry; git_config_iterator *iter; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; if ((error = git_repository_config__weakptr(&config, repo)) < 0) return error; @@ -2422,21 +2425,21 @@ static int remove_branch_config_related_entries( break; } - git_buf_clear(&buf); - if ((error = git_buf_printf(&buf, "branch.%.*s.merge", (int)branch_len, branch)) < 0) + git_str_clear(&buf); + if ((error = git_str_printf(&buf, "branch.%.*s.merge", (int)branch_len, branch)) < 0) break; - if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) { + if ((error = git_config_delete_entry(config, git_str_cstr(&buf))) < 0) { if (error != GIT_ENOTFOUND) break; git_error_clear(); } - git_buf_clear(&buf); - if ((error = git_buf_printf(&buf, "branch.%.*s.remote", (int)branch_len, branch)) < 0) + git_str_clear(&buf); + if ((error = git_str_printf(&buf, "branch.%.*s.remote", (int)branch_len, branch)) < 0) break; - if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) { + if ((error = git_config_delete_entry(config, git_str_cstr(&buf))) < 0) { if (error != GIT_ENOTFOUND) break; git_error_clear(); @@ -2446,7 +2449,7 @@ static int remove_branch_config_related_entries( if (error == GIT_ITEROVER) error = 0; - git_buf_dispose(&buf); + git_str_dispose(&buf); git_config_iterator_free(iter); return error; } @@ -2541,11 +2544,16 @@ int git_remote_delete(git_repository *repo, const char *name) int git_remote_default_branch(git_buf *out, git_remote *remote) { + GIT_BUF_WRAP_PRIVATE(out, git_remote__default_branch, remote); +} + +int git_remote__default_branch(git_str *out, git_remote *remote) +{ const git_remote_head **heads; const git_remote_head *guess = NULL; const git_oid *head_id; size_t heads_len, i; - git_buf local_default = GIT_BUF_INIT; + git_str local_default = GIT_STR_INIT; int error; GIT_ASSERT_ARG(out); @@ -2558,12 +2566,9 @@ int git_remote_default_branch(git_buf *out, git_remote *remote) goto done; } - if ((error = git_buf_sanitize(out)) < 0) - return error; - /* the first one must be HEAD so if that has the symref info, we're done */ if (heads[0]->symref_target) { - error = git_buf_puts(out, heads[0]->symref_target); + error = git_str_puts(out, heads[0]->symref_target); goto done; } @@ -2601,10 +2606,10 @@ int git_remote_default_branch(git_buf *out, git_remote *remote) goto done; } - error = git_buf_puts(out, guess->name); + error = git_str_puts(out, guess->name); done: - git_buf_dispose(&local_default); + git_str_dispose(&local_default); return error; } @@ -2720,7 +2725,7 @@ char *apply_insteadof(git_config *config, const char *url, int direction) char *replacement = NULL; const char *regexp; - git_buf result = GIT_BUF_INIT; + git_str result = GIT_STR_INIT; git_config_entry *entry; git_config_iterator *iter; @@ -2768,7 +2773,7 @@ char *apply_insteadof(git_config *config, const char *url, int direction) if (match_length == 0) return git__strdup(url); - git_buf_printf(&result, "%s%s", replacement, url + match_length); + git_str_printf(&result, "%s%s", replacement, url + match_length); git__free(replacement); diff --git a/src/remote.h b/src/remote.h index ce92db76a..77eefdf40 100644 --- a/src/remote.h +++ b/src/remote.h @@ -46,10 +46,12 @@ typedef struct git_remote_connection_opts { int git_remote__connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_remote_connection_opts *conn); -int git_remote__urlfordirection(git_buf *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks); +int git_remote__urlfordirection(git_str *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks); int git_remote__http_proxy(char **out, git_remote *remote, git_net_url *url); git_refspec *git_remote__matching_refspec(git_remote *remote, const char *refname); git_refspec *git_remote__matching_dst_refspec(git_remote *remote, const char *refname); +int git_remote__default_branch(git_str *out, git_remote *remote); + #endif diff --git a/src/repository.c b/src/repository.c index 9b3e9c9e3..29684e463 100644 --- a/src/repository.c +++ b/src/repository.c @@ -12,6 +12,7 @@ #include "git2/object.h" #include "git2/sys/repository.h" +#include "buf.h" #include "common.h" #include "commit.h" #include "tag.h" @@ -75,13 +76,13 @@ static int check_extensions(git_config *config, int version); #define GIT_REPO_VERSION 0 #define GIT_REPO_MAX_VERSION 1 -git_buf git_repository__reserved_names_win32[] = { +git_str git_repository__reserved_names_win32[] = { { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) }, { GIT_DIR_SHORTNAME, 0, CONST_STRLEN(GIT_DIR_SHORTNAME) } }; size_t git_repository__reserved_names_win32_len = 2; -git_buf git_repository__reserved_names_posix[] = { +git_str git_repository__reserved_names_posix[] = { { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) }, }; size_t git_repository__reserved_names_posix_len = 1; @@ -171,7 +172,7 @@ void git_repository_free(git_repository *repo) repo->diff_drivers = NULL; for (i = 0; i < repo->reserved_names.size; i++) - git_buf_dispose(git_array_get(repo->reserved_names, i)); + git_str_dispose(git_array_get(repo->reserved_names, i)); git_array_clear(repo->reserved_names); git__free(repo->gitlink); @@ -187,9 +188,9 @@ void git_repository_free(git_repository *repo) } /* Check if we have a separate commondir (e.g. we have a worktree) */ -static int lookup_commondir(bool *separate, git_buf *commondir, git_buf *repository_path) +static int lookup_commondir(bool *separate, git_str *commondir, git_str *repository_path) { - git_buf common_link = GIT_BUF_INIT; + git_str common_link = GIT_STR_INIT; int error; /* @@ -197,7 +198,7 @@ static int lookup_commondir(bool *separate, git_buf *commondir, git_buf *reposit * common path, but it needs a trailing slash. */ if (!git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) { - if ((error = git_buf_set(commondir, repository_path->ptr, repository_path->size)) == 0) + if ((error = git_str_set(commondir, repository_path->ptr, repository_path->size)) == 0) error = git_path_to_dir(commondir); *separate = false; @@ -206,19 +207,19 @@ static int lookup_commondir(bool *separate, git_buf *commondir, git_buf *reposit *separate = true; - if ((error = git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 || + if ((error = git_str_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 || (error = git_futils_readbuffer(&common_link, common_link.ptr)) < 0) goto done; - git_buf_rtrim(&common_link); + git_str_rtrim(&common_link); if (git_path_is_relative(common_link.ptr)) { - if ((error = git_buf_joinpath(commondir, repository_path->ptr, common_link.ptr)) < 0) + if ((error = git_str_joinpath(commondir, repository_path->ptr, common_link.ptr)) < 0) goto done; } else { - git_buf_swap(commondir, &common_link); + git_str_swap(commondir, &common_link); } - git_buf_dispose(&common_link); + git_str_dispose(&common_link); /* Make sure the commondir path always has a trailing slash */ error = git_path_prettify_dir(commondir, commondir->ptr, NULL); @@ -227,7 +228,7 @@ done: return error; } -GIT_INLINE(int) validate_repo_path(git_buf *path) +GIT_INLINE(int) validate_repo_path(git_str *path) { /* * The longest static path in a repository (or commondir) is the @@ -248,7 +249,7 @@ GIT_INLINE(int) validate_repo_path(git_buf *path) * * Open a repository object from its path */ -static int is_valid_repository_path(bool *out, git_buf *repository_path, git_buf *common_path) +static int is_valid_repository_path(bool *out, git_str *repository_path, git_str *common_path) { bool separate_commondir = false; int error; @@ -333,12 +334,12 @@ static int load_config_data(git_repository *repo, const git_config *config) return 0; } -static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path) +static int load_workdir(git_repository *repo, git_config *config, git_str *parent_path) { int error; git_config_entry *ce; - git_buf worktree = GIT_BUF_INIT; - git_buf path = GIT_BUF_INIT; + git_str worktree = GIT_STR_INIT; + git_str path = GIT_STR_INIT; if (repo->is_bare) return 0; @@ -354,7 +355,7 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren goto cleanup; } - git_buf_attach(&worktree, gitlink, 0); + git_str_attach(&worktree, gitlink, 0); if ((git_path_dirname_r(&worktree, worktree.ptr)) < 0 || git_path_to_dir(&worktree) < 0) { @@ -362,17 +363,17 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren goto cleanup; } - repo->workdir = git_buf_detach(&worktree); + repo->workdir = git_str_detach(&worktree); } else if (ce && ce->value) { if ((error = git_path_prettify_dir( &worktree, ce->value, repo->gitdir)) < 0) goto cleanup; - repo->workdir = git_buf_detach(&worktree); + repo->workdir = git_str_detach(&worktree); } else if (parent_path && git_path_isdir(parent_path->ptr)) - repo->workdir = git_buf_detach(parent_path); + repo->workdir = git_str_detach(parent_path); else { if (git_path_dirname_r(&worktree, repo->gitdir) < 0 || git_path_to_dir(&worktree) < 0) { @@ -380,12 +381,12 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren goto cleanup; } - repo->workdir = git_buf_detach(&worktree); + repo->workdir = git_str_detach(&worktree); } GIT_ERROR_CHECK_ALLOC(repo->workdir); cleanup: - git_buf_dispose(&path); + git_str_dispose(&path); git_config_entry_free(ce); return error; } @@ -394,7 +395,7 @@ cleanup: * This function returns furthest offset into path where a ceiling dir * is found, so we can stop processing the path at that point. * - * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on + * Note: converting this to use git_strs instead of GIT_PATH_MAX buffers on * the stack could remove directories name limits, but at the cost of doing * repeated malloc/frees inside the loop below, so let's not do it now. */ @@ -447,10 +448,10 @@ static size_t find_ceiling_dir_offset( * it points to. Before calling, set `path_out` to the base directory that * should be used if the contents of `file_path` are a relative path. */ -static int read_gitfile(git_buf *path_out, const char *file_path) +static int read_gitfile(git_str *path_out, const char *file_path) { int error = 0; - git_buf file = GIT_BUF_INIT; + git_str file = GIT_STR_INIT; size_t prefix_len = strlen(GIT_FILE_CONTENT_PREFIX); GIT_ASSERT_ARG(path_out); @@ -459,41 +460,41 @@ static int read_gitfile(git_buf *path_out, const char *file_path) if (git_futils_readbuffer(&file, file_path) < 0) return -1; - git_buf_rtrim(&file); + git_str_rtrim(&file); /* apparently on Windows, some people use backslashes in paths */ git_path_mkposix(file.ptr); - if (git_buf_len(&file) <= prefix_len || - memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0) + if (git_str_len(&file) <= prefix_len || + memcmp(git_str_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0) { git_error_set(GIT_ERROR_REPOSITORY, "the `.git` file at '%s' is malformed", file_path); error = -1; } else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) { - const char *gitlink = git_buf_cstr(&file) + prefix_len; + const char *gitlink = git_str_cstr(&file) + prefix_len; while (*gitlink && git__isspace(*gitlink)) gitlink++; error = git_path_prettify_dir( - path_out, gitlink, git_buf_cstr(path_out)); + path_out, gitlink, git_str_cstr(path_out)); } - git_buf_dispose(&file); + git_str_dispose(&file); return error; } static int find_repo( - git_buf *gitdir_path, - git_buf *workdir_path, - git_buf *gitlink_path, - git_buf *commondir_path, + git_str *gitdir_path, + git_str *workdir_path, + git_str *gitlink_path, + git_str *commondir_path, const char *start_path, uint32_t flags, const char *ceiling_dirs) { - git_buf path = GIT_BUF_INIT; - git_buf repo_link = GIT_BUF_INIT; - git_buf common_link = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; + git_str repo_link = GIT_STR_INIT; + git_str common_link = GIT_STR_INIT; struct stat st; dev_t initial_device = 0; int min_iterations; @@ -501,7 +502,7 @@ static int find_repo( size_t ceiling_offset = 0; int error; - git_buf_clear(gitdir_path); + git_str_clear(gitdir_path); error = git_path_prettify(&path, start_path, NULL); if (error < 0) @@ -525,7 +526,7 @@ static int find_repo( for (;;) { if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) { if (!in_dot_git) { - if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0) + if ((error = git_str_joinpath(&path, path.ptr, DOT_GIT)) < 0) goto out; } in_dot_git = !in_dot_git; @@ -545,14 +546,14 @@ static int find_repo( if (is_valid) { if ((error = git_path_to_dir(&path)) < 0 || - (error = git_buf_set(gitdir_path, path.ptr, path.size)) < 0) + (error = git_str_set(gitdir_path, path.ptr, path.size)) < 0) goto out; if (gitlink_path) - if ((error = git_buf_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0) + if ((error = git_str_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0) goto out; if (commondir_path) - git_buf_swap(&common_link, commondir_path); + git_str_swap(&common_link, commondir_path); break; } @@ -562,13 +563,13 @@ static int find_repo( goto out; if (is_valid) { - git_buf_swap(gitdir_path, &repo_link); + git_str_swap(gitdir_path, &repo_link); if (gitlink_path) - if ((error = git_buf_put(gitlink_path, path.ptr, path.size)) < 0) + if ((error = git_str_put(gitlink_path, path.ptr, path.size)) < 0) goto out; if (commondir_path) - git_buf_swap(&common_link, commondir_path); + git_str_swap(&common_link, commondir_path); } break; } @@ -592,8 +593,8 @@ static int find_repo( } if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) { - if (!git_buf_len(gitdir_path)) - git_buf_clear(workdir_path); + if (!git_str_len(gitdir_path)) + git_str_clear(workdir_path); else if ((error = git_path_dirname_r(workdir_path, path.ptr)) < 0 || (error = git_path_to_dir(workdir_path)) < 0) goto out; @@ -601,16 +602,16 @@ static int find_repo( /* If we didn't find the repository, and we don't have any other error * to report, report that. */ - if (!git_buf_len(gitdir_path)) { + if (!git_str_len(gitdir_path)) { git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path); error = GIT_ENOTFOUND; goto out; } out: - git_buf_dispose(&path); - git_buf_dispose(&repo_link); - git_buf_dispose(&common_link); + git_str_dispose(&path); + git_str_dispose(&repo_link); + git_str_dispose(&common_link); return error; } @@ -618,7 +619,7 @@ int git_repository_open_bare( git_repository **repo_ptr, const char *bare_path) { - git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, common_path = GIT_STR_INIT; git_repository *repo = NULL; bool is_valid; int error; @@ -628,8 +629,8 @@ int git_repository_open_bare( return error; if (!is_valid) { - git_buf_dispose(&path); - git_buf_dispose(&common_path); + git_str_dispose(&path); + git_str_dispose(&common_path); git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path); return GIT_ENOTFOUND; } @@ -637,9 +638,9 @@ int git_repository_open_bare( repo = repository_alloc(); GIT_ERROR_CHECK_ALLOC(repo); - repo->gitdir = git_buf_detach(&path); + repo->gitdir = git_str_detach(&path); GIT_ERROR_CHECK_ALLOC(repo->gitdir); - repo->commondir = git_buf_detach(&common_path); + repo->commondir = git_str_detach(&common_path); GIT_ERROR_CHECK_ALLOC(repo->commondir); /* of course we're bare! */ @@ -658,15 +659,15 @@ static int _git_repository_open_ext_from_env( git_repository *repo = NULL; git_index *index = NULL; git_odb *odb = NULL; - git_buf dir_buf = GIT_BUF_INIT; - git_buf ceiling_dirs_buf = GIT_BUF_INIT; - git_buf across_fs_buf = GIT_BUF_INIT; - git_buf index_file_buf = GIT_BUF_INIT; - git_buf namespace_buf = GIT_BUF_INIT; - git_buf object_dir_buf = GIT_BUF_INIT; - git_buf alts_buf = GIT_BUF_INIT; - git_buf work_tree_buf = GIT_BUF_INIT; - git_buf common_dir_buf = GIT_BUF_INIT; + git_str dir_buf = GIT_STR_INIT; + git_str ceiling_dirs_buf = GIT_STR_INIT; + git_str across_fs_buf = GIT_STR_INIT; + git_str index_file_buf = GIT_STR_INIT; + git_str namespace_buf = GIT_STR_INIT; + git_str object_dir_buf = GIT_STR_INIT; + git_str alts_buf = GIT_STR_INIT; + git_str work_tree_buf = GIT_STR_INIT; + git_str common_dir_buf = GIT_STR_INIT; const char *ceiling_dirs = NULL; unsigned flags = 0; int error; @@ -679,7 +680,7 @@ static int _git_repository_open_ext_from_env( } else if (error < 0) goto error; else { - start_path = git_buf_cstr(&dir_buf); + start_path = git_str_cstr(&dir_buf); flags |= GIT_REPOSITORY_OPEN_NO_SEARCH; flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT; } @@ -691,7 +692,7 @@ static int _git_repository_open_ext_from_env( else if (error < 0) goto error; else - ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf); + ceiling_dirs = git_str_cstr(&ceiling_dirs_buf); error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM"); if (error == GIT_ENOTFOUND) @@ -700,7 +701,7 @@ static int _git_repository_open_ext_from_env( goto error; else { int across_fs = 0; - error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf)); + error = git_config_parse_bool(&across_fs, git_str_cstr(&across_fs_buf)); if (error < 0) goto error; if (across_fs) @@ -713,7 +714,7 @@ static int _git_repository_open_ext_from_env( else if (error < 0) goto error; else { - error = git_index_open(&index, git_buf_cstr(&index_file_buf)); + error = git_index_open(&index, git_str_cstr(&index_file_buf)); if (error < 0) goto error; } @@ -730,7 +731,7 @@ static int _git_repository_open_ext_from_env( else if (error < 0) goto error; else { - error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf)); + error = git_odb_open(&odb, git_str_cstr(&object_dir_buf)); if (error < 0) goto error; } @@ -779,7 +780,7 @@ static int _git_repository_open_ext_from_env( goto error; } - end = git_buf_cstr(&alts_buf) + git_buf_len(&alts_buf); + end = git_str_cstr(&alts_buf) + git_str_len(&alts_buf); for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) { for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++) ; @@ -791,8 +792,8 @@ static int _git_repository_open_ext_from_env( } } - if (git_buf_len(&namespace_buf)) { - error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf)); + if (git_str_len(&namespace_buf)) { + error = git_repository_set_namespace(repo, git_str_cstr(&namespace_buf)); if (error < 0) goto error; } @@ -808,21 +809,21 @@ error: success: git_odb_free(odb); git_index_free(index); - git_buf_dispose(&common_dir_buf); - git_buf_dispose(&work_tree_buf); - git_buf_dispose(&alts_buf); - git_buf_dispose(&object_dir_buf); - git_buf_dispose(&namespace_buf); - git_buf_dispose(&index_file_buf); - git_buf_dispose(&across_fs_buf); - git_buf_dispose(&ceiling_dirs_buf); - git_buf_dispose(&dir_buf); + git_str_dispose(&common_dir_buf); + git_str_dispose(&work_tree_buf); + git_str_dispose(&alts_buf); + git_str_dispose(&object_dir_buf); + git_str_dispose(&namespace_buf); + git_str_dispose(&index_file_buf); + git_str_dispose(&across_fs_buf); + git_str_dispose(&ceiling_dirs_buf); + git_str_dispose(&dir_buf); return error; } static int repo_is_worktree(unsigned *out, const git_repository *repo) { - git_buf gitdir_link = GIT_BUF_INIT; + git_str gitdir_link = GIT_STR_INIT; int error; /* Worktrees cannot have the same commondir and gitdir */ @@ -832,14 +833,14 @@ static int repo_is_worktree(unsigned *out, const git_repository *repo) return 0; } - if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0) + if ((error = git_str_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0) return -1; /* A 'gitdir' file inside a git directory is currently * only used when the repository is a working tree. */ *out = !!git_path_exists(gitdir_link.ptr); - git_buf_dispose(&gitdir_link); + git_str_dispose(&gitdir_link); return error; } @@ -851,8 +852,8 @@ int git_repository_open_ext( { int error; unsigned is_worktree; - git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT, - gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT; + git_str gitdir = GIT_STR_INIT, workdir = GIT_STR_INIT, + gitlink = GIT_STR_INIT, commondir = GIT_STR_INIT; git_repository *repo = NULL; git_config *config = NULL; int version = 0; @@ -872,15 +873,15 @@ int git_repository_open_ext( repo = repository_alloc(); GIT_ERROR_CHECK_ALLOC(repo); - repo->gitdir = git_buf_detach(&gitdir); + repo->gitdir = git_str_detach(&gitdir); GIT_ERROR_CHECK_ALLOC(repo->gitdir); if (gitlink.size) { - repo->gitlink = git_buf_detach(&gitlink); + repo->gitlink = git_str_detach(&gitlink); GIT_ERROR_CHECK_ALLOC(repo->gitlink); } if (commondir.size) { - repo->commondir = git_buf_detach(&commondir); + repo->commondir = git_str_detach(&commondir); GIT_ERROR_CHECK_ALLOC(repo->commondir); } @@ -914,10 +915,10 @@ int git_repository_open_ext( } cleanup: - git_buf_dispose(&gitdir); - git_buf_dispose(&workdir); - git_buf_dispose(&gitlink); - git_buf_dispose(&commondir); + git_str_dispose(&gitdir); + git_str_dispose(&workdir); + git_str_dispose(&gitlink); + git_str_dispose(&commondir); git_config_free(config); if (error < 0) @@ -936,7 +937,7 @@ int git_repository_open(git_repository **repo_out, const char *path) int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *wt) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_repository *repo = NULL; size_t len; int err; @@ -952,7 +953,7 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w goto out; } - if ((err = git_buf_set(&path, wt->gitlink_path, len - 4)) < 0) + if ((err = git_str_set(&path, wt->gitlink_path, len - 4)) < 0) goto out; if ((err = git_repository_open(&repo, path.ptr)) < 0) @@ -961,7 +962,7 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w *repo_out = repo; out: - git_buf_dispose(&path); + git_str_dispose(&path); return err; } @@ -986,14 +987,10 @@ int git_repository_discover( const char *ceiling_dirs) { uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0; - int error; GIT_ASSERT_ARG(start_path); - if ((error = git_buf_sanitize(out)) < 0) - return error; - - return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs); + GIT_BUF_WRAP_PRIVATE(out, find_repo, NULL, NULL, NULL, start_path, flags, ceiling_dirs); } static int load_config( @@ -1005,7 +1002,7 @@ static int load_config( const char *programdata_path) { int error; - git_buf config_path = GIT_BUF_INIT; + git_str config_path = GIT_STR_INIT; git_config *cfg = NULL; GIT_ASSERT_ARG(out); @@ -1014,13 +1011,13 @@ static int load_config( return error; if (repo) { - if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0) + if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0) error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0); if (error && error != GIT_ENOTFOUND) goto on_error; - git_buf_dispose(&config_path); + git_str_dispose(&config_path); } if (global_config_path != NULL && @@ -1053,15 +1050,15 @@ static int load_config( return 0; on_error: - git_buf_dispose(&config_path); + git_str_dispose(&config_path); git_config_free(cfg); *out = NULL; return error; } -static const char *path_unless_empty(git_buf *buf) +static const char *path_unless_empty(git_str *buf) { - return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL; + return git_str_len(buf) > 0 ? git_str_cstr(buf) : NULL; } int git_repository_config__weakptr(git_config **out, git_repository *repo) @@ -1069,19 +1066,19 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo) int error = 0; if (repo->_config == NULL) { - git_buf global_buf = GIT_BUF_INIT; - git_buf xdg_buf = GIT_BUF_INIT; - git_buf system_buf = GIT_BUF_INIT; - git_buf programdata_buf = GIT_BUF_INIT; + git_str global_buf = GIT_STR_INIT; + git_str xdg_buf = GIT_STR_INIT; + git_str system_buf = GIT_STR_INIT; + git_str programdata_buf = GIT_STR_INIT; git_config *config; - git_config_find_global(&global_buf); - git_config_find_xdg(&xdg_buf); - git_config_find_system(&system_buf); - git_config_find_programdata(&programdata_buf); + git_config__find_global(&global_buf); + git_config__find_xdg(&xdg_buf); + git_config__find_system(&system_buf); + git_config__find_programdata(&programdata_buf); /* If there is no global file, open a backend for it anyway */ - if (git_buf_len(&global_buf) == 0) + if (git_str_len(&global_buf) == 0) git_config__global_location(&global_buf); error = load_config( @@ -1099,10 +1096,10 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo) } } - git_buf_dispose(&global_buf); - git_buf_dispose(&xdg_buf); - git_buf_dispose(&system_buf); - git_buf_dispose(&programdata_buf); + git_str_dispose(&global_buf); + git_str_dispose(&xdg_buf); + git_str_dispose(&system_buf); + git_str_dispose(&programdata_buf); } *out = repo->_config; @@ -1147,10 +1144,10 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo) *out = git_atomic_load(repo->_odb); if (*out == NULL) { - git_buf odb_path = GIT_BUF_INIT; + git_str odb_path = GIT_STR_INIT; git_odb *odb; - if ((error = git_repository_item_path(&odb_path, repo, + if ((error = git_repository__item_path(&odb_path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 || (error = git_odb_new(&odb)) < 0) return error; @@ -1168,7 +1165,7 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo) git_odb_free(odb); } - git_buf_dispose(&odb_path); + git_str_dispose(&odb_path); *out = git_atomic_load(repo->_odb); } @@ -1244,10 +1241,10 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo) GIT_ASSERT_ARG(repo); if (repo->_index == NULL) { - git_buf index_path = GIT_BUF_INIT; + git_str index_path = GIT_STR_INIT; git_index *index; - if ((error = git_buf_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0) + if ((error = git_str_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0) return error; error = git_index_open(&index, index_path.ptr); @@ -1263,7 +1260,7 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo) GIT_INDEX_CAPABILITY_FROM_OWNER); } - git_buf_dispose(&index_path); + git_str_dispose(&index_path); } *out = repo->_index; @@ -1311,7 +1308,7 @@ static int reserved_names_add8dot3(git_repository *repo, const char *path) const char *def_dot_git = DOT_GIT; size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME); size_t def_dot_git_len = CONST_STRLEN(DOT_GIT); - git_buf *buf; + git_str *buf; if (!name) return 0; @@ -1327,17 +1324,17 @@ static int reserved_names_add8dot3(git_repository *repo, const char *path) if ((buf = git_array_alloc(repo->reserved_names)) == NULL) return -1; - git_buf_attach(buf, name, name_len); + git_str_attach(buf, name, name_len); return true; } bool git_repository__reserved_names( - git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs) + git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs) { GIT_UNUSED(include_ntfs); if (repo->reserved_names.size == 0) { - git_buf *buf; + git_str *buf; size_t i; /* Add the static defaults */ @@ -1389,7 +1386,7 @@ on_error: } #else bool git_repository__reserved_names( - git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs) + git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs) { GIT_UNUSED(repo); @@ -1435,7 +1432,7 @@ static git_vector user_extensions = GIT_VECTOR_INIT; static int check_valid_extension(const git_config_entry *entry, void *payload) { - git_buf cfg = GIT_BUF_INIT; + git_str cfg = GIT_STR_INIT; bool reject; const char *extension; size_t i; @@ -1444,7 +1441,7 @@ static int check_valid_extension(const git_config_entry *entry, void *payload) GIT_UNUSED(payload); git_vector_foreach (&user_extensions, i, extension) { - git_buf_clear(&cfg); + git_str_clear(&cfg); /* * Users can specify that they don't want to support an @@ -1453,7 +1450,7 @@ static int check_valid_extension(const git_config_entry *entry, void *payload) if ((reject = (extension[0] == '!')) == true) extension = &extension[1]; - if ((error = git_buf_printf(&cfg, "extensions.%s", extension)) < 0) + if ((error = git_str_printf(&cfg, "extensions.%s", extension)) < 0) goto done; if (strcmp(entry->name, cfg.ptr) == 0) { @@ -1467,7 +1464,7 @@ static int check_valid_extension(const git_config_entry *entry, void *payload) for (i = 0; i < ARRAY_SIZE(builtin_extensions); i++) { extension = builtin_extensions[i]; - if ((error = git_buf_printf(&cfg, "extensions.%s", extension)) < 0) + if ((error = git_str_printf(&cfg, "extensions.%s", extension)) < 0) goto done; if (strcmp(entry->name, cfg.ptr) == 0) @@ -1479,7 +1476,7 @@ fail: error = -1; done: - git_buf_dispose(&cfg); + git_str_dispose(&cfg); return error; } @@ -1557,12 +1554,12 @@ void git_repository__free_extensions(void) int git_repository_create_head(const char *git_dir, const char *ref_name) { - git_buf ref_path = GIT_BUF_INIT; + git_str ref_path = GIT_STR_INIT; git_filebuf ref = GIT_FILEBUF_INIT; const char *fmt; int error; - if ((error = git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 || + if ((error = git_str_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 || (error = git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE)) < 0) goto out; @@ -1576,7 +1573,7 @@ int git_repository_create_head(const char *git_dir, const char *ref_name) goto out; out: - git_buf_dispose(&ref_path); + git_str_dispose(&ref_path); git_filebuf_cleanup(&ref); return error; } @@ -1599,23 +1596,23 @@ static bool is_chmod_supported(const char *file_path) static bool is_filesystem_case_insensitive(const char *gitdir_path) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int is_insensitive = -1; - if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg")) - is_insensitive = git_path_exists(git_buf_cstr(&path)); + if (!git_str_joinpath(&path, gitdir_path, "CoNfIg")) + is_insensitive = git_path_exists(git_str_cstr(&path)); - git_buf_dispose(&path); + git_str_dispose(&path); return is_insensitive; } static bool are_symlinks_supported(const char *wd_path) { git_config *config = NULL; - git_buf global_buf = GIT_BUF_INIT; - git_buf xdg_buf = GIT_BUF_INIT; - git_buf system_buf = GIT_BUF_INIT; - git_buf programdata_buf = GIT_BUF_INIT; + git_str global_buf = GIT_STR_INIT; + git_str xdg_buf = GIT_STR_INIT; + git_str system_buf = GIT_STR_INIT; + git_str programdata_buf = GIT_STR_INIT; int symlinks = 0; /* @@ -1626,10 +1623,10 @@ static bool are_symlinks_supported(const char *wd_path) * _not_ set, then we do not test or enable symlink support. */ #ifdef GIT_WIN32 - git_config_find_global(&global_buf); - git_config_find_xdg(&xdg_buf); - git_config_find_system(&system_buf); - git_config_find_programdata(&programdata_buf); + git_config__find_global(&global_buf); + git_config__find_xdg(&xdg_buf); + git_config__find_system(&system_buf); + git_config__find_programdata(&programdata_buf); if (load_config(&config, NULL, path_unless_empty(&global_buf), @@ -1646,10 +1643,10 @@ static bool are_symlinks_supported(const char *wd_path) goto done; done: - git_buf_dispose(&global_buf); - git_buf_dispose(&xdg_buf); - git_buf_dispose(&system_buf); - git_buf_dispose(&programdata_buf); + git_str_dispose(&global_buf); + git_str_dispose(&xdg_buf); + git_str_dispose(&system_buf); + git_str_dispose(&programdata_buf); git_config_free(config); return symlinks != 0; } @@ -1673,7 +1670,7 @@ static int create_empty_file(const char *path, mode_t mode) static int repo_local_config( git_config **out, - git_buf *config_dir, + git_str *config_dir, git_repository *repo, const char *repo_dir) { @@ -1681,9 +1678,9 @@ static int repo_local_config( git_config *parent; const char *cfg_path; - if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0) + if (git_str_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0) return -1; - cfg_path = git_buf_cstr(config_dir); + cfg_path = git_str_cstr(config_dir); /* make LOCAL config if missing */ if (!git_path_isfile(cfg_path) && @@ -1759,7 +1756,7 @@ static int repo_init_config( uint32_t mode) { int error = 0; - git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT; + git_str cfg_path = GIT_STR_INIT, worktree_path = GIT_STR_INIT; git_config *config = NULL; bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0); bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0); @@ -1789,7 +1786,7 @@ static int repo_init_config( SET_REPO_CONFIG(bool, "core.logallrefupdates", true); if (!(flags & GIT_REPOSITORY_INIT__NATURAL_WD)) { - if ((error = git_buf_sets(&worktree_path, work_dir)) < 0) + if ((error = git_str_sets(&worktree_path, work_dir)) < 0) goto cleanup; if ((flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK)) @@ -1813,8 +1810,8 @@ static int repo_init_config( } cleanup: - git_buf_dispose(&cfg_path); - git_buf_dispose(&worktree_path); + git_str_dispose(&cfg_path); + git_str_dispose(&worktree_path); git_config_free(config); return error; @@ -1836,7 +1833,7 @@ static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p) int git_repository_reinit_filesystem(git_repository *repo, int recurse) { int error = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_config *config = NULL; const char *repo_dir = git_repository_path(repo); @@ -1845,7 +1842,7 @@ int git_repository_reinit_filesystem(git_repository *repo, int recurse) config, path.ptr, repo_dir, git_repository_workdir(repo), true); git_config_free(config); - git_buf_dispose(&path); + git_str_dispose(&path); git_repository__configmap_lookup_cache_clear(repo); @@ -1863,10 +1860,10 @@ static int repo_write_template( bool hidden, const char *content) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int fd, error = 0, flags; - if (git_buf_joinpath(&path, git_dir, file) < 0) + if (git_str_joinpath(&path, git_dir, file) < 0) return -1; if (allow_overwrite) @@ -1874,7 +1871,7 @@ static int repo_write_template( else flags = O_WRONLY | O_CREAT | O_EXCL; - fd = p_open(git_buf_cstr(&path), flags, mode); + fd = p_open(git_str_cstr(&path), flags, mode); if (fd >= 0) { error = p_write(fd, content, strlen(content)); @@ -1893,7 +1890,7 @@ static int repo_write_template( GIT_UNUSED(hidden); #endif - git_buf_dispose(&path); + git_str_dispose(&path); if (error) git_error_set(GIT_ERROR_OS, @@ -1906,13 +1903,13 @@ static int repo_write_gitlink( const char *in_dir, const char *to_repo, bool use_relative_path) { int error; - git_buf buf = GIT_BUF_INIT; - git_buf path_to_repo = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; + git_str path_to_repo = GIT_STR_INIT; struct stat st; git_path_dirname_r(&buf, to_repo); git_path_to_dir(&buf); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; /* don't write gitlink to natural workdir */ @@ -1923,7 +1920,7 @@ static int repo_write_gitlink( goto cleanup; } - if ((error = git_buf_joinpath(&buf, in_dir, DOT_GIT)) < 0) + if ((error = git_str_joinpath(&buf, in_dir, DOT_GIT)) < 0) goto cleanup; if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) { @@ -1933,22 +1930,22 @@ static int repo_write_gitlink( goto cleanup; } - git_buf_clear(&buf); + git_str_clear(&buf); - error = git_buf_sets(&path_to_repo, to_repo); + error = git_str_sets(&path_to_repo, to_repo); if (!error && use_relative_path) error = git_path_make_relative(&path_to_repo, in_dir); if (!error) - error = git_buf_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr); + error = git_str_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr); if (!error) error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr); cleanup: - git_buf_dispose(&buf); - git_buf_dispose(&path_to_repo); + git_str_dispose(&buf); + git_str_dispose(&path_to_repo); return error; } @@ -2001,12 +1998,12 @@ static int repo_init_structure( git_config *cfg = NULL; const char *tdir = NULL; bool default_template = false; - git_buf template_buf = GIT_BUF_INIT; + git_str template_buf = GIT_STR_INIT; if (opts->template_path) tdir = opts->template_path; else if ((error = git_config_open_default(&cfg)) >= 0) { - if (!git_config_get_path(&template_buf, cfg, "init.templatedir")) + if (!git_config__get_path(&template_buf, cfg, "init.templatedir")) tdir = template_buf.ptr; git_error_clear(); } @@ -2032,7 +2029,7 @@ static int repo_init_structure( error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode); } - git_buf_dispose(&template_buf); + git_str_dispose(&template_buf); git_config_free(cfg); if (error < 0) { @@ -2073,7 +2070,7 @@ static int repo_init_structure( return error; } -static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2) +static int mkdir_parent(git_str *buf, uint32_t mode, bool skip2) { /* When making parent directories during repository initialization * don't try to set gid or grant world write access @@ -2085,8 +2082,8 @@ static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2) } static int repo_init_directories( - git_buf *repo_path, - git_buf *wd_path, + git_str *repo_path, + git_str *wd_path, const char *given_repo, git_repository_init_options *opts) { @@ -2124,7 +2121,7 @@ static int repo_init_directories( git__suffixcmp(given_repo, "/" DOT_GIT) != 0 && git__suffixcmp(given_repo, "/" GIT_DIR) != 0; - if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0) + if (git_str_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0) return -1; has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0); @@ -2150,7 +2147,7 @@ static int repo_init_directories( if (git_path_to_dir(wd_path) < 0) return -1; } else { - git_buf_clear(wd_path); + git_str_clear(wd_path); } natural_wd = @@ -2219,11 +2216,11 @@ static int repo_init_directories( static int repo_init_head(const char *repo_dir, const char *given) { git_config *cfg = NULL; - git_buf head_path = GIT_BUF_INIT, cfg_branch = GIT_BUF_INIT; + git_str head_path = GIT_STR_INIT, cfg_branch = GIT_STR_INIT; const char *initial_head = NULL; int error; - if ((error = git_buf_joinpath(&head_path, repo_dir, GIT_HEAD_FILE)) < 0) + if ((error = git_str_joinpath(&head_path, repo_dir, GIT_HEAD_FILE)) < 0) goto out; /* @@ -2236,7 +2233,7 @@ static int repo_init_head(const char *repo_dir, const char *given) if (given) { initial_head = given; } else if ((error = git_config_open_default(&cfg)) >= 0 && - (error = git_config_get_string_buf(&cfg_branch, cfg, "init.defaultbranch")) >= 0 && + (error = git_config__get_string_buf(&cfg_branch, cfg, "init.defaultbranch")) >= 0 && *cfg_branch.ptr) { initial_head = cfg_branch.ptr; } @@ -2248,8 +2245,8 @@ static int repo_init_head(const char *repo_dir, const char *given) out: git_config_free(cfg); - git_buf_dispose(&head_path); - git_buf_dispose(&cfg_branch); + git_str_dispose(&head_path); + git_str_dispose(&cfg_branch); return error; } @@ -2283,8 +2280,8 @@ int git_repository_init_ext( const char *given_repo, git_repository_init_options *opts) { - git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT, - common_path = GIT_BUF_INIT; + git_str repo_path = GIT_STR_INIT, wd_path = GIT_STR_INIT, + common_path = GIT_STR_INIT; const char *wd; bool is_valid; int error; @@ -2298,7 +2295,7 @@ int git_repository_init_ext( if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0) goto out; - wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path); + wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_str_cstr(&wd_path); if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0) goto out; @@ -2332,9 +2329,9 @@ int git_repository_init_ext( goto out; out: - git_buf_dispose(&common_path); - git_buf_dispose(&repo_path); - git_buf_dispose(&wd_path); + git_str_dispose(&common_path); + git_str_dispose(&repo_path); + git_str_dispose(&wd_path); return error; } @@ -2522,7 +2519,7 @@ static int repo_contains_no_reference(git_repository *repo) return error; } -int git_repository_initialbranch(git_buf *out, git_repository *repo) +int git_repository_initialbranch(git_str *out, git_repository *repo) { git_config *config; git_config_entry *entry = NULL; @@ -2543,8 +2540,8 @@ int git_repository_initialbranch(git_buf *out, git_repository *repo) goto done; } - if ((error = git_buf_puts(out, GIT_REFS_HEADS_DIR)) < 0 || - (error = git_buf_puts(out, branch)) < 0 || + if ((error = git_str_puts(out, GIT_REFS_HEADS_DIR)) < 0 || + (error = git_str_puts(out, branch)) < 0 || (error = git_reference_name_is_valid(&valid, out->ptr)) < 0) goto done; @@ -2561,7 +2558,7 @@ done: int git_repository_is_empty(git_repository *repo) { git_reference *head = NULL; - git_buf initialbranch = GIT_BUF_INIT; + git_str initialbranch = GIT_STR_INIT; int result = 0; if ((result = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0 || @@ -2574,7 +2571,7 @@ int git_repository_is_empty(git_repository *repo) done: git_reference_free(head); - git_buf_dispose(&initialbranch); + git_str_dispose(&initialbranch); return result; } @@ -2603,7 +2600,18 @@ static const char *resolved_parent_path(const git_repository *repo, git_reposito return parent; } -int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item) +int git_repository_item_path( + git_buf *out, + const git_repository *repo, + git_repository_item_t item) +{ + GIT_BUF_WRAP_PRIVATE(out, git_repository__item_path, repo, item); +} + +int git_repository__item_path( + git_str *out, + const git_repository *repo, + git_repository_item_t item) { const char *parent = resolved_parent_path(repo, items[item].parent, items[item].fallback); if (parent == NULL) { @@ -2611,11 +2619,11 @@ int git_repository_item_path(git_buf *out, const git_repository *repo, git_repos return GIT_ENOTFOUND; } - if (git_buf_sets(out, parent) < 0) + if (git_str_sets(out, parent) < 0) return -1; if (items[item].name) { - if (git_buf_joinpath(out, parent, items[item].name) < 0) + if (git_str_joinpath(out, parent, items[item].name) < 0) return -1; } @@ -2644,7 +2652,7 @@ const char *git_repository_workdir(const git_repository *repo) } int git_repository_workdir_path( - git_buf *out, git_repository *repo, const char *path) + git_str *out, git_repository *repo, const char *path) { int error; @@ -2653,7 +2661,7 @@ int git_repository_workdir_path( return GIT_EBAREREPO; } - if (!(error = git_buf_joinpath(out, repo->workdir, path))) + if (!(error = git_str_joinpath(out, repo->workdir, path))) error = git_path_validate_workdir_buf(repo, out); return error; @@ -2669,7 +2677,7 @@ int git_repository_set_workdir( git_repository *repo, const char *workdir, int update_gitlink) { int error = 0; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(workdir); @@ -2701,7 +2709,7 @@ int git_repository_set_workdir( if (!error) { char *old_workdir = repo->workdir; - repo->workdir = git_buf_detach(&path); + repo->workdir = git_str_detach(&path); repo->is_bare = 0; git__free(old_workdir); @@ -2770,13 +2778,13 @@ cleanup: int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; char orig_head_str[GIT_OID_HEXSZ]; int error = 0; git_oid_fmt(orig_head_str, orig_head); - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 && + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 && (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 && (error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0) error = git_filebuf_commit(&file); @@ -2784,46 +2792,48 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } -int git_repository_message(git_buf *out, git_repository *repo) +static int git_repository__message(git_str *out, git_repository *repo) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; struct stat st; int error; - if ((error = git_buf_sanitize(out)) < 0) - return error; - - if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0) + if (git_str_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0) return -1; - if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) { + if ((error = p_stat(git_str_cstr(&path), &st)) < 0) { if (errno == ENOENT) error = GIT_ENOTFOUND; git_error_set(GIT_ERROR_OS, "could not access message file"); } else { - error = git_futils_readbuffer(out, git_buf_cstr(&path)); + error = git_futils_readbuffer(out, git_str_cstr(&path)); } - git_buf_dispose(&path); + git_str_dispose(&path); return error; } +int git_repository_message(git_buf *out, git_repository *repo) +{ + GIT_BUF_WRAP_PRIVATE(out, git_repository__message, repo); +} + int git_repository_message_remove(git_repository *repo) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; - if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0) + if (git_str_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0) return -1; - error = p_unlink(git_buf_cstr(&path)); - git_buf_dispose(&path); + error = p_unlink(git_str_cstr(&path)); + git_str_dispose(&path); return error; } @@ -2839,7 +2849,7 @@ int git_repository_hashfile( git_filter_list *fl = NULL; git_file fd = -1; uint64_t len; - git_buf full_path = GIT_BUF_INIT; + git_str full_path = GIT_STR_INIT; const char *workdir = git_repository_workdir(repo); /* as_path can be NULL */ @@ -2895,30 +2905,30 @@ cleanup: if (fd >= 0) p_close(fd); git_filter_list_free(fl); - git_buf_dispose(&full_path); + git_str_dispose(&full_path); return error; } -static int checkout_message(git_buf *out, git_reference *old, const char *new) +static int checkout_message(git_str *out, git_reference *old, const char *new) { - git_buf_puts(out, "checkout: moving from "); + git_str_puts(out, "checkout: moving from "); if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC) - git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old))); + git_str_puts(out, git_reference__shorthand(git_reference_symbolic_target(old))); else - git_buf_puts(out, git_oid_tostr_s(git_reference_target(old))); + git_str_puts(out, git_oid_tostr_s(git_reference_target(old))); - git_buf_puts(out, " to "); + git_str_puts(out, " to "); if (git_reference__is_branch(new) || git_reference__is_tag(new) || git_reference__is_remote(new)) - git_buf_puts(out, git_reference__shorthand(new)); + git_str_puts(out, git_reference__shorthand(new)); else - git_buf_puts(out, new); + git_str_puts(out, new); - if (git_buf_oom(out)) + if (git_str_oom(out)) return -1; return 0; @@ -2927,7 +2937,7 @@ static int checkout_message(git_buf *out, git_reference *old, const char *new) static int detach(git_repository *repo, const git_oid *id, const char *new) { int error; - git_buf log_message = GIT_BUF_INIT; + git_str log_message = GIT_STR_INIT; git_object *object = NULL, *peeled = NULL; git_reference *new_head = NULL, *current = NULL; @@ -2949,10 +2959,10 @@ static int detach(git_repository *repo, const git_oid *id, const char *new) if ((error = checkout_message(&log_message, current, new)) < 0) goto cleanup; - error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message)); + error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_str_cstr(&log_message)); cleanup: - git_buf_dispose(&log_message); + git_str_dispose(&log_message); git_object_free(object); git_object_free(peeled); git_reference_free(current); @@ -2965,7 +2975,7 @@ int git_repository_set_head( const char *refname) { git_reference *ref = NULL, *current = NULL, *new_head = NULL; - git_buf log_message = GIT_BUF_INIT; + git_str log_message = GIT_STR_INIT; int error; GIT_ASSERT_ARG(repo); @@ -2992,18 +3002,18 @@ int git_repository_set_head( if (!error) { if (git_reference_is_branch(ref)) { error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, - git_reference_name(ref), true, git_buf_cstr(&log_message)); + git_reference_name(ref), true, git_str_cstr(&log_message)); } else { error = detach(repo, git_reference_target(ref), git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL); } } else if (git_reference__is_branch(refname)) { error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname, - true, git_buf_cstr(&log_message)); + true, git_str_cstr(&log_message)); } cleanup: - git_buf_dispose(&log_message); + git_str_dispose(&log_message); git_reference_free(current); git_reference_free(ref); git_reference_free(new_head); @@ -3031,7 +3041,7 @@ int git_repository_detach_head(git_repository *repo) { git_reference *old_head = NULL, *new_head = NULL, *current = NULL; git_object *object = NULL; - git_buf log_message = GIT_BUF_INIT; + git_str log_message = GIT_STR_INIT; int error; GIT_ASSERT_ARG(repo); @@ -3049,10 +3059,10 @@ int git_repository_detach_head(git_repository *repo) goto cleanup; error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), - 1, git_buf_cstr(&log_message)); + 1, git_str_cstr(&log_message)); cleanup: - git_buf_dispose(&log_message); + git_str_dispose(&log_message); git_object_free(object); git_reference_free(old_head); git_reference_free(new_head); @@ -3066,12 +3076,12 @@ cleanup: */ int git_repository_state(git_repository *repo) { - git_buf repo_path = GIT_BUF_INIT; + git_str repo_path = GIT_STR_INIT; int state = GIT_REPOSITORY_STATE_NONE; GIT_ASSERT_ARG(repo); - if (git_buf_puts(&repo_path, repo->gitdir) < 0) + if (git_str_puts(&repo_path, repo->gitdir) < 0) return -1; if (git_path_contains_file(&repo_path, GIT_REBASE_MERGE_INTERACTIVE_FILE)) @@ -3099,24 +3109,24 @@ int git_repository_state(git_repository *repo) } else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE)) state = GIT_REPOSITORY_STATE_BISECT; - git_buf_dispose(&repo_path); + git_str_dispose(&repo_path); return state; } int git_repository__cleanup_files( git_repository *repo, const char *files[], size_t files_len) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; size_t i; int error; for (error = 0, i = 0; !error && i < files_len; ++i) { const char *path; - if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0) + if (git_str_joinpath(&buf, repo->gitdir, files[i]) < 0) return -1; - path = git_buf_cstr(&buf); + path = git_str_cstr(&buf); if (git_path_isfile(path)) { error = p_unlink(path); @@ -3125,10 +3135,10 @@ int git_repository__cleanup_files( GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS); } - git_buf_clear(&buf); + git_str_clear(&buf); } - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -3153,15 +3163,15 @@ int git_repository_state_cleanup(git_repository *repo) int git_repository_is_shallow(git_repository *repo) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; struct stat st; int error; - if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0) + if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0) return error; error = git_path_lstat(path.ptr, &st); - git_buf_dispose(&path); + git_str_dispose(&path); if (error == GIT_ENOTFOUND) { git_error_clear(); diff --git a/src/repository.h b/src/repository.h index cbc160140..1ea5a44f7 100644 --- a/src/repository.h +++ b/src/repository.h @@ -19,7 +19,7 @@ #include "array.h" #include "cache.h" #include "refs.h" -#include "buffer.h" +#include "str.h" #include "object.h" #include "attrcache.h" #include "submodule.h" @@ -148,7 +148,7 @@ struct git_repository { char *ident_name; char *ident_email; - git_array_t(git_buf) reserved_names; + git_array_t(git_str) reserved_names; unsigned is_bare:1; unsigned is_worktree:1; @@ -196,6 +196,8 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo); int git_repository__configmap_lookup(int *out, git_repository *repo, git_configmap_item item); void git_repository__configmap_lookup_cache_clear(git_repository *repo); +int git_repository__item_path(git_str *out, const git_repository *repo, git_repository_item_t item); + GIT_INLINE(int) git_repository__ensure_not_bare( git_repository *repo, const char *operation_name) @@ -216,10 +218,10 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head int git_repository__cleanup_files(git_repository *repo, const char *files[], size_t files_len); /* The default "reserved names" for a repository */ -extern git_buf git_repository__reserved_names_win32[]; +extern git_str git_repository__reserved_names_win32[]; extern size_t git_repository__reserved_names_win32_len; -extern git_buf git_repository__reserved_names_posix[]; +extern git_str git_repository__reserved_names_posix[]; extern size_t git_repository__reserved_names_posix_len; /* @@ -233,13 +235,13 @@ extern size_t git_repository__reserved_names_posix_len; * will still be populated with good defaults. */ bool git_repository__reserved_names( - git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs); + git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs); /* * The default branch for the repository; the `init.defaultBranch` * configuration option, if set, or `master` if it is not. */ -int git_repository_initialbranch(git_buf *out, git_repository *repo); +int git_repository_initialbranch(git_str *out, git_repository *repo); /* * Given a relative `path`, this makes it absolute based on the @@ -247,7 +249,7 @@ int git_repository_initialbranch(git_buf *out, git_repository *repo); * to ensure that the path is not longer than MAX_PATH on Windows * (unless `core.longpaths` is set in the repo config). */ -int git_repository_workdir_path(git_buf *out, git_repository *repo, const char *path); +int git_repository_workdir_path(git_str *out, git_repository *repo, const char *path); int git_repository__extensions(char ***out, size_t *out_len); int git_repository__set_extensions(const char **extensions, size_t len); diff --git a/src/reset.c b/src/reset.c index f21a620c6..b8327fe5e 100644 --- a/src/reset.c +++ b/src/reset.c @@ -111,7 +111,7 @@ static int reset( git_tree *tree = NULL; int error = 0; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; - git_buf log_message = GIT_BUF_INIT; + git_str log_message = GIT_STR_INIT; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(target); @@ -144,7 +144,7 @@ static int reset( goto cleanup; } - if ((error = git_buf_printf(&log_message, "reset: moving to %s", to)) < 0) + if ((error = git_str_printf(&log_message, "reset: moving to %s", to)) < 0) return error; if (reset_type == GIT_RESET_HARD) { @@ -157,7 +157,7 @@ static int reset( /* move HEAD to the new target */ if ((error = git_reference__update_terminal(repo, GIT_HEAD_FILE, - git_object_id(commit), NULL, git_buf_cstr(&log_message))) < 0) + git_object_id(commit), NULL, git_str_cstr(&log_message))) < 0) goto cleanup; if (reset_type > GIT_RESET_SOFT) { @@ -177,7 +177,7 @@ cleanup: git_object_free(commit); git_index_free(index); git_tree_free(tree); - git_buf_dispose(&log_message); + git_str_dispose(&log_message); return error; } diff --git a/src/revert.c b/src/revert.c index 683f0d70d..d6ab6ae3c 100644 --- a/src/revert.c +++ b/src/revert.c @@ -25,10 +25,10 @@ static int write_revert_head( const char *commit_oidstr) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; int error = 0; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_REVERT_HEAD_FILE)) >= 0 && + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_REVERT_HEAD_FILE)) >= 0 && (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_REVERT_FILE_MODE)) >= 0 && (error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0) error = git_filebuf_commit(&file); @@ -36,7 +36,7 @@ static int write_revert_head( if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -47,10 +47,10 @@ static int write_merge_msg( const char *commit_msgline) { git_filebuf file = GIT_FILEBUF_INIT; - git_buf file_path = GIT_BUF_INIT; + git_str file_path = GIT_STR_INIT; int error = 0; - if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || + if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 || (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_REVERT_FILE_MODE)) < 0 || (error = git_filebuf_printf(&file, "Revert \"%s\"\n\nThis reverts commit %s.\n", commit_msgline, commit_oidstr)) < 0) @@ -62,7 +62,7 @@ cleanup: if (error < 0) git_filebuf_cleanup(&file); - git_buf_dispose(&file_path); + git_str_dispose(&file_path); return error; } @@ -178,7 +178,7 @@ int git_revert( git_commit *our_commit = NULL; char commit_oidstr[GIT_OID_HEXSZ + 1]; const char *commit_msg; - git_buf their_label = GIT_BUF_INIT; + git_str their_label = GIT_STR_INIT; git_index *index = NULL; git_indexwriter indexwriter = GIT_INDEXWRITER_INIT; int error; @@ -199,8 +199,8 @@ int git_revert( goto on_error; } - if ((error = git_buf_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 || - (error = revert_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 || + if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 || + (error = revert_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 || (error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 || (error = write_revert_head(repo, commit_oidstr)) < 0 || (error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 || @@ -223,7 +223,7 @@ done: git_index_free(index); git_commit_free(our_commit); git_reference_free(our_ref); - git_buf_dispose(&their_label); + git_str_dispose(&their_label); return error; } diff --git a/src/revparse.c b/src/revparse.c index b4d5d4759..cf39936a5 100644 --- a/src/revparse.c +++ b/src/revparse.c @@ -7,7 +7,7 @@ #include "common.h" -#include "buffer.h" +#include "str.h" #include "tree.h" #include "refdb.h" #include "regexp.h" @@ -145,7 +145,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out, size_t i, numentries, cur; const git_reflog_entry *entry; const char *msg; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; cur = position; @@ -179,16 +179,16 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out, if (cur > 0) continue; - if ((git_buf_put(&buf, msg+regexmatches[1].start, regexmatches[1].end - regexmatches[1].start)) < 0) + if ((git_str_put(&buf, msg+regexmatches[1].start, regexmatches[1].end - regexmatches[1].start)) < 0) goto cleanup; - if ((error = git_reference_dwim(base_ref, repo, git_buf_cstr(&buf))) == 0) + if ((error = git_reference_dwim(base_ref, repo, git_str_cstr(&buf))) == 0) goto cleanup; if (error < 0 && error != GIT_ENOTFOUND) goto cleanup; - error = maybe_abbrev(out, repo, git_buf_cstr(&buf)); + error = maybe_abbrev(out, repo, git_str_cstr(&buf)); goto cleanup; } @@ -197,7 +197,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out, cleanup: git_reference_free(ref); - git_buf_dispose(&buf); + git_str_dispose(&buf); git_regexp_dispose(&preg); git_reflog_free(reflog); return error; @@ -314,12 +314,12 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s { bool is_numeric; int parsed = 0, error = -1; - git_buf identifier = GIT_BUF_INIT; + git_str identifier = GIT_STR_INIT; git_time_t timestamp; GIT_ASSERT(*out == NULL); - if (git_buf_put(&identifier, spec, identifier_len) < 0) + if (git_str_put(&identifier, spec, identifier_len) < 0) return -1; is_numeric = !try_parse_numeric(&parsed, curly_braces_content); @@ -331,15 +331,15 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s if (is_numeric) { if (parsed < 0) - error = retrieve_previously_checked_out_branch_or_revision(out, ref, repo, git_buf_cstr(&identifier), -parsed); + error = retrieve_previously_checked_out_branch_or_revision(out, ref, repo, git_str_cstr(&identifier), -parsed); else - error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), parsed); + error = retrieve_revobject_from_reflog(out, ref, repo, git_str_cstr(&identifier), parsed); goto cleanup; } if (!strcmp(curly_braces_content, "u") || !strcmp(curly_braces_content, "upstream")) { - error = retrieve_remote_tracking_reference(ref, git_buf_cstr(&identifier), repo); + error = retrieve_remote_tracking_reference(ref, git_str_cstr(&identifier), repo); goto cleanup; } @@ -347,10 +347,10 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s if (git__date_parse(×tamp, curly_braces_content) < 0) goto cleanup; - error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp); + error = retrieve_revobject_from_reflog(out, ref, repo, git_str_cstr(&identifier), (size_t)timestamp); cleanup: - git_buf_dispose(&identifier); + git_str_dispose(&identifier); return error; } @@ -520,9 +520,9 @@ static int handle_caret_curly_syntax(git_object **out, git_object *obj, const ch return git_object_peel(out, obj, expected_type); } -static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *pos) +static int extract_curly_braces_content(git_str *buf, const char *spec, size_t *pos) { - git_buf_clear(buf); + git_str_clear(buf); GIT_ASSERT_ARG(spec[*pos] == '^' || spec[*pos] == '@'); @@ -537,7 +537,7 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t * if (spec[*pos] == '\0') return GIT_EINVALIDSPEC; - if (git_buf_putc(buf, spec[(*pos)++]) < 0) + if (git_str_putc(buf, spec[(*pos)++]) < 0) return -1; } @@ -546,18 +546,18 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t * return 0; } -static int extract_path(git_buf *buf, const char *spec, size_t *pos) +static int extract_path(git_str *buf, const char *spec, size_t *pos) { - git_buf_clear(buf); + git_str_clear(buf); GIT_ASSERT_ARG(spec[*pos] == ':'); (*pos)++; - if (git_buf_puts(buf, spec + *pos) < 0) + if (git_str_puts(buf, spec + *pos) < 0) return -1; - *pos += git_buf_len(buf); + *pos += git_str_len(buf); return 0; } @@ -610,7 +610,7 @@ static int object_from_reference(git_object **object, git_reference *reference) static int ensure_base_rev_loaded(git_object **object, git_reference **reference, const char *spec, size_t identifier_len, git_repository *repo, bool allow_empty_identifier) { int error; - git_buf identifier = GIT_BUF_INIT; + git_str identifier = GIT_STR_INIT; if (*object != NULL) return 0; @@ -621,11 +621,11 @@ static int ensure_base_rev_loaded(git_object **object, git_reference **reference if (!allow_empty_identifier && identifier_len == 0) return GIT_EINVALIDSPEC; - if (git_buf_put(&identifier, spec, identifier_len) < 0) + if (git_str_put(&identifier, spec, identifier_len) < 0) return -1; - error = revparse_lookup_object(object, reference, repo, git_buf_cstr(&identifier)); - git_buf_dispose(&identifier); + error = revparse_lookup_object(object, reference, repo, git_str_cstr(&identifier)); + git_str_dispose(&identifier); return error; } @@ -669,7 +669,7 @@ static int revparse( { size_t pos = 0, identifier_len = 0; int error = -1, n; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_reference *reference = NULL; git_object *base_rev = NULL; @@ -698,7 +698,7 @@ static int revparse( if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0) goto cleanup; - if ((error = handle_caret_curly_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0) + if ((error = handle_caret_curly_syntax(&temp_object, base_rev, git_str_cstr(&buf))) < 0) goto cleanup; git_object_free(base_rev); @@ -750,11 +750,11 @@ static int revparse( if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, true)) < 0) goto cleanup; - if ((error = handle_colon_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0) + if ((error = handle_colon_syntax(&temp_object, base_rev, git_str_cstr(&buf))) < 0) goto cleanup; } else { - if (*git_buf_cstr(&buf) == '/') { - if ((error = handle_grep_syntax(&temp_object, repo, NULL, git_buf_cstr(&buf) + 1)) < 0) + if (*git_str_cstr(&buf) == '/') { + if ((error = handle_grep_syntax(&temp_object, repo, NULL, git_str_cstr(&buf) + 1)) < 0) goto cleanup; } else { @@ -783,7 +783,7 @@ static int revparse( if ((error = ensure_base_rev_is_not_known_yet(base_rev)) < 0) goto cleanup; - if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_buf_cstr(&buf))) < 0) + if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_str_cstr(&buf))) < 0) goto cleanup; if (temp_object != NULL) @@ -824,7 +824,7 @@ cleanup: git_reference_free(reference); } - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } diff --git a/src/revwalk.c b/src/revwalk.c index a686a9f6f..e29e9c9b9 100644 --- a/src/revwalk.c +++ b/src/revwalk.c @@ -131,7 +131,7 @@ int git_revwalk__push_glob(git_revwalk *walk, const char *glob, const git_revwal { git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT; int error = 0; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_reference *ref; git_reference_iterator *iter; size_t wildcard; @@ -144,15 +144,15 @@ int git_revwalk__push_glob(git_revwalk *walk, const char *glob, const git_revwal /* refs/ is implied if not given in the glob */ if (git__prefixcmp(glob, GIT_REFS_DIR) != 0) - git_buf_joinpath(&buf, GIT_REFS_DIR, glob); + git_str_joinpath(&buf, GIT_REFS_DIR, glob); else - git_buf_puts(&buf, glob); - GIT_ERROR_CHECK_ALLOC_BUF(&buf); + git_str_puts(&buf, glob); + GIT_ERROR_CHECK_ALLOC_STR(&buf); /* If no '?', '*' or '[' exist, we append '/ *' to the glob */ wildcard = strcspn(glob, "?*["); if (!glob[wildcard]) - git_buf_put(&buf, "/*", 2); + git_str_put(&buf, "/*", 2); if ((error = git_reference_iterator_glob_new(&iter, walk->repo, buf.ptr)) < 0) goto out; @@ -169,7 +169,7 @@ int git_revwalk__push_glob(git_revwalk *walk, const char *glob, const git_revwal if (error == GIT_ITEROVER) error = 0; out: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } diff --git a/src/signature.c b/src/signature.c index 1efda212a..acd5fd72b 100644 --- a/src/signature.c +++ b/src/signature.c @@ -299,7 +299,7 @@ int git_signature_from_buffer(git_signature **out, const char *buf) return error; } -void git_signature__writebuf(git_buf *buf, const char *header, const git_signature *sig) +void git_signature__writebuf(git_str *buf, const char *header, const git_signature *sig) { int offset, hours, mins; char sign; @@ -313,7 +313,7 @@ void git_signature__writebuf(git_buf *buf, const char *header, const git_signatu hours = offset / 60; mins = offset % 60; - git_buf_printf(buf, "%s%s <%s> %u %c%02d%02d\n", + git_str_printf(buf, "%s%s <%s> %u %c%02d%02d\n", header ? header : "", sig->name, sig->email, (unsigned)sig->when.time, sign, hours, mins); } diff --git a/src/signature.h b/src/signature.h index 40d7c54f9..5c8270954 100644 --- a/src/signature.h +++ b/src/signature.h @@ -15,7 +15,7 @@ #include <time.h> int git_signature__parse(git_signature *sig, const char **buffer_out, const char *buffer_end, const char *header, char ender); -void git_signature__writebuf(git_buf *buf, const char *header, const git_signature *sig); +void git_signature__writebuf(git_str *buf, const char *header, const git_signature *sig); bool git_signature__equal(const git_signature *one, const git_signature *two); int git_signature__pdup(git_signature **dest, const git_signature *source, git_pool *pool); diff --git a/src/sortedcache.c b/src/sortedcache.c index ee6363f6d..7ff900efe 100644 --- a/src/sortedcache.c +++ b/src/sortedcache.c @@ -201,7 +201,7 @@ void git_sortedcache_runlock(git_sortedcache *sc) /* if the file has changed, lock cache and load file contents into buf; * returns <0 on error, >0 if file has not changed */ -int git_sortedcache_lockandload(git_sortedcache *sc, git_buf *buf) +int git_sortedcache_lockandload(git_sortedcache *sc, git_str *buf) { int error, fd; struct stat st; diff --git a/src/sortedcache.h b/src/sortedcache.h index 0e1f63ceb..ef260a093 100644 --- a/src/sortedcache.h +++ b/src/sortedcache.h @@ -121,7 +121,7 @@ void git_sortedcache_wunlock(git_sortedcache *sc); * @return 0 if up-to-date, 1 if out-of-date, <0 on error */ GIT_WARN_UNUSED_RESULT int git_sortedcache_lockandload( - git_sortedcache *sc, git_buf *buf); + git_sortedcache *sc, git_str *buf); /* Refresh file timestamp after write completes * You should already be holding the write lock when you call this. diff --git a/src/stash.c b/src/stash.c index 49ea26fdd..5fc01ac36 100644 --- a/src/stash.c +++ b/src/stash.c @@ -9,7 +9,6 @@ #include "repository.h" #include "commit.h" -#include "message.h" #include "tree.h" #include "reflog.h" #include "blob.h" @@ -43,20 +42,20 @@ static int retrieve_head(git_reference **out, git_repository *repo) return error; } -static int append_abbreviated_oid(git_buf *out, const git_oid *b_commit) +static int append_abbreviated_oid(git_str *out, const git_oid *b_commit) { char *formatted_oid; formatted_oid = git_oid_allocfmt(b_commit); GIT_ERROR_CHECK_ALLOC(formatted_oid); - git_buf_put(out, formatted_oid, 7); + git_str_put(out, formatted_oid, 7); git__free(formatted_oid); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } -static int append_commit_description(git_buf *out, git_commit *commit) +static int append_commit_description(git_str *out, git_commit *commit) { const char *summary = git_commit_summary(commit); GIT_ERROR_CHECK_ALLOC(summary); @@ -64,16 +63,16 @@ static int append_commit_description(git_buf *out, git_commit *commit) if (append_abbreviated_oid(out, git_commit_id(commit)) < 0) return -1; - git_buf_putc(out, ' '); - git_buf_puts(out, summary); - git_buf_putc(out, '\n'); + git_str_putc(out, ' '); + git_str_puts(out, summary); + git_str_putc(out, '\n'); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } static int retrieve_base_commit_and_message( git_commit **b_commit, - git_buf *stash_message, + git_str *stash_message, git_repository *repo) { git_reference *head = NULL; @@ -83,9 +82,9 @@ static int retrieve_base_commit_and_message( return error; if (strcmp("HEAD", git_reference_name(head)) == 0) - error = git_buf_puts(stash_message, "(no branch): "); + error = git_str_puts(stash_message, "(no branch): "); else - error = git_buf_printf( + error = git_str_printf( stash_message, "%s: ", git_reference_name(head) + strlen(GIT_REFS_HEADS_DIR)); @@ -128,13 +127,13 @@ static int commit_index( { git_tree *i_tree = NULL; git_oid i_commit_oid; - git_buf msg = GIT_BUF_INIT; + git_str msg = GIT_STR_INIT; int error; if ((error = build_tree_from_index(&i_tree, repo, index)) < 0) goto cleanup; - if ((error = git_buf_printf(&msg, "index on %s\n", message)) < 0) + if ((error = git_str_printf(&msg, "index on %s\n", message)) < 0) goto cleanup; if ((error = git_commit_create( @@ -144,7 +143,7 @@ static int commit_index( stasher, stasher, NULL, - git_buf_cstr(&msg), + git_str_cstr(&msg), i_tree, 1, &parent)) < 0) @@ -154,7 +153,7 @@ static int commit_index( cleanup: git_tree_free(i_tree); - git_buf_dispose(&msg); + git_str_dispose(&msg); return error; } @@ -303,13 +302,13 @@ static int commit_untracked( { git_tree *u_tree = NULL; git_oid u_commit_oid; - git_buf msg = GIT_BUF_INIT; + git_str msg = GIT_STR_INIT; int error; if ((error = build_untracked_tree(&u_tree, repo, i_commit, flags)) < 0) goto cleanup; - if ((error = git_buf_printf(&msg, "untracked files on %s\n", message)) < 0) + if ((error = git_str_printf(&msg, "untracked files on %s\n", message)) < 0) goto cleanup; if ((error = git_commit_create( @@ -319,7 +318,7 @@ static int commit_untracked( stasher, stasher, NULL, - git_buf_cstr(&msg), + git_str_cstr(&msg), u_tree, 0, NULL)) < 0) @@ -329,7 +328,7 @@ static int commit_untracked( cleanup: git_tree_free(u_tree); - git_buf_dispose(&msg); + git_str_dispose(&msg); return error; } @@ -437,33 +436,33 @@ cleanup: return error; } -static int prepare_worktree_commit_message(git_buf *out, const char *user_message) +static int prepare_worktree_commit_message(git_str *out, const char *user_message) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error = 0; if (!user_message) { - git_buf_printf(&buf, "WIP on %s", git_buf_cstr(out)); + git_str_printf(&buf, "WIP on %s", git_str_cstr(out)); } else { const char *colon; - if ((colon = strchr(git_buf_cstr(out), ':')) == NULL) + if ((colon = strchr(git_str_cstr(out), ':')) == NULL) goto cleanup; - git_buf_puts(&buf, "On "); - git_buf_put(&buf, git_buf_cstr(out), colon - out->ptr); - git_buf_printf(&buf, ": %s\n", user_message); + git_str_puts(&buf, "On "); + git_str_put(&buf, git_str_cstr(out), colon - out->ptr); + git_str_printf(&buf, ": %s\n", user_message); } - if (git_buf_oom(&buf)) { + if (git_str_oom(&buf)) { error = -1; goto cleanup; } - git_buf_swap(out, &buf); + git_str_swap(out, &buf); cleanup: - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -543,7 +542,7 @@ int git_stash_save( { git_index *index = NULL; git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL; - git_buf msg = GIT_BUF_INIT; + git_str msg = GIT_STR_INIT; int error; GIT_ASSERT_ARG(out); @@ -563,24 +562,24 @@ int git_stash_save( goto cleanup; if ((error = commit_index(&i_commit, repo, index, stasher, - git_buf_cstr(&msg), b_commit)) < 0) + git_str_cstr(&msg), b_commit)) < 0) goto cleanup; if ((flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) && (error = commit_untracked(&u_commit, repo, stasher, - git_buf_cstr(&msg), i_commit, flags)) < 0) + git_str_cstr(&msg), i_commit, flags)) < 0) goto cleanup; if ((error = prepare_worktree_commit_message(&msg, message)) < 0) goto cleanup; - if ((error = commit_worktree(out, repo, stasher, git_buf_cstr(&msg), + if ((error = commit_worktree(out, repo, stasher, git_str_cstr(&msg), i_commit, b_commit, u_commit)) < 0) goto cleanup; - git_buf_rtrim(&msg); + git_str_rtrim(&msg); - if ((error = update_reflog(out, repo, git_buf_cstr(&msg))) < 0) + if ((error = update_reflog(out, repo, git_str_cstr(&msg))) < 0) goto cleanup; if ((error = reset_index_and_workdir(repo, (flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit, @@ -589,7 +588,7 @@ int git_stash_save( cleanup: - git_buf_dispose(&msg); + git_str_dispose(&msg); git_commit_free(i_commit); git_commit_free(b_commit); git_commit_free(u_commit); diff --git a/src/buffer.c b/src/str.c index fe087ea11..7b50800c1 100644 --- a/src/buffer.c +++ b/src/str.c @@ -4,42 +4,42 @@ * 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 "buffer.h" + +#include "str.h" #include "posix.h" -#include "git2/buffer.h" #include <ctype.h> -/* Used as default value for git_buf->ptr so that people can always - * assume ptr is non-NULL and zero terminated even for new git_bufs. +/* Used as default value for git_str->ptr so that people can always + * assume ptr is non-NULL and zero terminated even for new git_strs. */ -char git_buf__initbuf[1]; +char git_str__initstr[1]; -char git_buf__oom[1]; +char git_str__oom[1]; #define ENSURE_SIZE(b, d) \ - if ((b)->ptr == git_buf__oom || \ - ((d) > (b)->asize && git_buf_grow((b), (d)) < 0))\ + if ((b)->ptr == git_str__oom || \ + ((d) > (b)->asize && git_str_grow((b), (d)) < 0))\ return -1; -int git_buf_init(git_buf *buf, size_t initial_size) +int git_str_init(git_str *buf, size_t initial_size) { buf->asize = 0; buf->size = 0; - buf->ptr = git_buf__initbuf; + buf->ptr = git_str__initstr; ENSURE_SIZE(buf, initial_size); return 0; } -int git_buf_try_grow( - git_buf *buf, size_t target_size, bool mark_oom) +int git_str_try_grow( + git_str *buf, size_t target_size, bool mark_oom) { char *new_ptr; size_t new_size; - if (buf->ptr == git_buf__oom) + if (buf->ptr == git_str__oom) return -1; if (buf->asize == 0 && buf->size != 0) { @@ -74,9 +74,9 @@ int git_buf_try_grow( if (new_size < buf->size) { if (mark_oom) { - if (buf->ptr && buf->ptr != git_buf__initbuf) + if (buf->ptr && buf->ptr != git_str__initstr) git__free(buf->ptr); - buf->ptr = git_buf__oom; + buf->ptr = git_str__oom; } git_error_set_oom(); @@ -87,9 +87,9 @@ int git_buf_try_grow( if (!new_ptr) { if (mark_oom) { - if (buf->ptr && (buf->ptr != git_buf__initbuf)) + if (buf->ptr && (buf->ptr != git_str__initstr)) git__free(buf->ptr); - buf->ptr = git_buf__oom; + buf->ptr = git_str__oom; } return -1; } @@ -105,59 +105,46 @@ int git_buf_try_grow( return 0; } -int git_buf_grow(git_buf *buffer, size_t target_size) +int git_str_grow(git_str *buffer, size_t target_size) { - return git_buf_try_grow(buffer, target_size, true); + return git_str_try_grow(buffer, target_size, true); } -int git_buf_grow_by(git_buf *buffer, size_t additional_size) +int git_str_grow_by(git_str *buffer, size_t additional_size) { size_t newsize; if (GIT_ADD_SIZET_OVERFLOW(&newsize, buffer->size, additional_size)) { - buffer->ptr = git_buf__oom; + buffer->ptr = git_str__oom; return -1; } - return git_buf_try_grow(buffer, newsize, true); + return git_str_try_grow(buffer, newsize, true); } -void git_buf_dispose(git_buf *buf) +void git_str_dispose(git_str *buf) { if (!buf) return; - if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_buf__oom) + if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_str__oom) git__free(buf->ptr); - git_buf_init(buf, 0); + git_str_init(buf, 0); } #ifndef GIT_DEPRECATE_HARD -void git_buf_free(git_buf *buf) +void git_str_free(git_str *buf) { - git_buf_dispose(buf); + git_str_dispose(buf); } #endif -int git_buf_sanitize(git_buf *buf) -{ - if (buf->ptr == NULL) { - GIT_ASSERT_ARG(buf->size == 0 && buf->asize == 0); - - buf->ptr = git_buf__initbuf; - } else if (buf->asize > buf->size) { - buf->ptr[buf->size] = '\0'; - } - - return 0; -} - -void git_buf_clear(git_buf *buf) +void git_str_clear(git_str *buf) { buf->size = 0; if (!buf->ptr) { - buf->ptr = git_buf__initbuf; + buf->ptr = git_str__initstr; buf->asize = 0; } @@ -165,12 +152,12 @@ void git_buf_clear(git_buf *buf) buf->ptr[0] = '\0'; } -int git_buf_set(git_buf *buf, const void *data, size_t len) +int git_str_set(git_str *buf, const void *data, size_t len) { size_t alloclen; if (len == 0 || data == NULL) { - git_buf_clear(buf); + git_str_clear(buf); } else { if (data != buf->ptr) { GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, len, 1); @@ -186,12 +173,12 @@ int git_buf_set(git_buf *buf, const void *data, size_t len) return 0; } -int git_buf_sets(git_buf *buf, const char *string) +int git_str_sets(git_str *buf, const char *string) { - return git_buf_set(buf, string, string ? strlen(string) : 0); + return git_str_set(buf, string, string ? strlen(string) : 0); } -int git_buf_putc(git_buf *buf, char c) +int git_str_putc(git_str *buf, char c) { size_t new_size; GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, 2); @@ -201,7 +188,7 @@ int git_buf_putc(git_buf *buf, char c) return 0; } -int git_buf_putcn(git_buf *buf, char c, size_t len) +int git_str_putcn(git_str *buf, char c, size_t len) { size_t new_size; GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len); @@ -213,7 +200,7 @@ int git_buf_putcn(git_buf *buf, char c, size_t len) return 0; } -int git_buf_put(git_buf *buf, const char *data, size_t len) +int git_str_put(git_str *buf, const char *data, size_t len) { if (len) { size_t new_size; @@ -230,17 +217,17 @@ int git_buf_put(git_buf *buf, const char *data, size_t len) return 0; } -int git_buf_puts(git_buf *buf, const char *string) +int git_str_puts(git_str *buf, const char *string) { GIT_ASSERT_ARG(string); - return git_buf_put(buf, string, strlen(string)); + return git_str_put(buf, string, strlen(string)); } static const char base64_encode[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -int git_buf_encode_base64(git_buf *buf, const char *data, size_t len) +int git_str_encode_base64(git_str *buf, const char *data, size_t len) { size_t extra = len % 3; uint8_t *write, a, b, c; @@ -302,7 +289,7 @@ static const int8_t base64_decode[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; -int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len) +int git_str_decode_base64(git_str *buf, const char *base64, size_t len) { size_t i; int8_t a, b, c, d; @@ -342,7 +329,7 @@ int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len) static const char base85_encode[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"; -int git_buf_encode_base85(git_buf *buf, const char *data, size_t len) +int git_str_encode_base85(git_str *buf, const char *data, size_t len) { size_t blocks = (len / 4) + !!(len % 4), alloclen; @@ -401,8 +388,8 @@ static const int8_t base85_decode[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; -int git_buf_decode_base85( - git_buf *buf, +int git_str_decode_base85( + git_str *buf, const char *base85, size_t base85_len, size_t output_len) @@ -465,8 +452,8 @@ on_error: #define HEX_DECODE(c) ((c | 32) % 39 - 9) -int git_buf_decode_percent( - git_buf *buf, +int git_str_decode_percent( + git_str *buf, const char *str, size_t str_len) { @@ -493,7 +480,7 @@ int git_buf_decode_percent( return 0; } -int git_buf_vprintf(git_buf *buf, const char *format, va_list ap) +int git_str_vprintf(git_str *buf, const char *format, va_list ap) { size_t expected_size, new_size; int len; @@ -516,7 +503,7 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap) if (len < 0) { git__free(buf->ptr); - buf->ptr = git_buf__oom; + buf->ptr = git_str__oom; return -1; } @@ -533,19 +520,19 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap) return 0; } -int git_buf_printf(git_buf *buf, const char *format, ...) +int git_str_printf(git_str *buf, const char *format, ...) { int r; va_list ap; va_start(ap, format); - r = git_buf_vprintf(buf, format, ap); + r = git_str_vprintf(buf, format, ap); va_end(ap); return r; } -int git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf) +int git_str_copy_cstr(char *data, size_t datasize, const git_str *buf) { size_t copylen; @@ -567,12 +554,12 @@ int git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf) return 0; } -void git_buf_consume_bytes(git_buf *buf, size_t len) +void git_str_consume_bytes(git_str *buf, size_t len) { - git_buf_consume(buf, buf->ptr + len); + git_str_consume(buf, buf->ptr + len); } -void git_buf_consume(git_buf *buf, const char *end) +void git_str_consume(git_str *buf, const char *end) { if (end > buf->ptr && end <= buf->ptr + buf->size) { size_t consumed = end - buf->ptr; @@ -582,7 +569,7 @@ void git_buf_consume(git_buf *buf, const char *end) } } -void git_buf_truncate(git_buf *buf, size_t len) +void git_str_truncate(git_str *buf, size_t len) { if (len >= buf->size) return; @@ -592,49 +579,49 @@ void git_buf_truncate(git_buf *buf, size_t len) buf->ptr[buf->size] = '\0'; } -void git_buf_shorten(git_buf *buf, size_t amount) +void git_str_shorten(git_str *buf, size_t amount) { if (buf->size > amount) - git_buf_truncate(buf, buf->size - amount); + git_str_truncate(buf, buf->size - amount); else - git_buf_clear(buf); + git_str_clear(buf); } -void git_buf_truncate_at_char(git_buf *buf, char separator) +void git_str_truncate_at_char(git_str *buf, char separator) { - ssize_t idx = git_buf_find(buf, separator); + ssize_t idx = git_str_find(buf, separator); if (idx >= 0) - git_buf_truncate(buf, (size_t)idx); + git_str_truncate(buf, (size_t)idx); } -void git_buf_rtruncate_at_char(git_buf *buf, char separator) +void git_str_rtruncate_at_char(git_str *buf, char separator) { - ssize_t idx = git_buf_rfind_next(buf, separator); - git_buf_truncate(buf, idx < 0 ? 0 : (size_t)idx); + ssize_t idx = git_str_rfind_next(buf, separator); + git_str_truncate(buf, idx < 0 ? 0 : (size_t)idx); } -void git_buf_swap(git_buf *buf_a, git_buf *buf_b) +void git_str_swap(git_str *str_a, git_str *str_b) { - git_buf t = *buf_a; - *buf_a = *buf_b; - *buf_b = t; + git_str t = *str_a; + *str_a = *str_b; + *str_b = t; } -char *git_buf_detach(git_buf *buf) +char *git_str_detach(git_str *buf) { char *data = buf->ptr; - if (buf->asize == 0 || buf->ptr == git_buf__oom) + if (buf->asize == 0 || buf->ptr == git_str__oom) return NULL; - git_buf_init(buf, 0); + git_str_init(buf, 0); return data; } -int git_buf_attach(git_buf *buf, char *ptr, size_t asize) +int git_str_attach(git_str *buf, char *ptr, size_t asize) { - git_buf_dispose(buf); + git_str_dispose(buf); if (ptr) { buf->ptr = ptr; @@ -649,13 +636,13 @@ int git_buf_attach(git_buf *buf, char *ptr, size_t asize) return 0; } -void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size) +void git_str_attach_notowned(git_str *buf, const char *ptr, size_t size) { - if (git_buf_is_allocated(buf)) - git_buf_dispose(buf); + if (git_str_is_allocated(buf)) + git_str_dispose(buf); if (!size) { - git_buf_init(buf, 0); + git_str_init(buf, 0); } else { buf->ptr = (char *)ptr; buf->asize = 0; @@ -663,7 +650,7 @@ void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size) } } -int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) +int git_str_join_n(git_str *buf, char separator, int nbuf, ...) { va_list ap; int i; @@ -698,7 +685,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) return 0; GIT_ERROR_CHECK_ALLOC_ADD(&total_size, total_size, 1); - if (git_buf_grow_by(buf, total_size) < 0) + if (git_str_grow_by(buf, total_size) < 0) return -1; out = buf->ptr + buf->size; @@ -751,8 +738,8 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...) return 0; } -int git_buf_join( - git_buf *buf, +int git_str_join( + git_str *buf, char separator, const char *str_a, const char *str_b) @@ -800,8 +787,8 @@ int git_buf_join( return 0; } -int git_buf_join3( - git_buf *buf, +int git_str_join3( + git_str *buf, char separator, const char *str_a, const char *str_b, @@ -860,7 +847,7 @@ int git_buf_join3( return 0; } -void git_buf_rtrim(git_buf *buf) +void git_str_rtrim(git_str *buf) { while (buf->size > 0) { if (!git__isspace(buf->ptr[buf->size - 1])) @@ -873,15 +860,15 @@ void git_buf_rtrim(git_buf *buf) buf->ptr[buf->size] = '\0'; } -int git_buf_cmp(const git_buf *a, const git_buf *b) +int git_str_cmp(const git_str *a, const git_str *b) { int result = memcmp(a->ptr, b->ptr, min(a->size, b->size)); return (result != 0) ? result : (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; } -int git_buf_splice( - git_buf *buf, +int git_str_splice( + git_str *buf, size_t where, size_t nb_to_remove, const char *data, @@ -915,10 +902,10 @@ int git_buf_splice( } /* Quote per http://marc.info/?l=git&m=112927316408690&w=2 */ -int git_buf_quote(git_buf *buf) +int git_str_quote(git_str *buf) { const char whitespace[] = { 'a', 'b', 't', 'n', 'v', 'f', 'r' }; - git_buf quoted = GIT_BUF_INIT; + git_str quoted = GIT_STR_INIT; size_t i = 0; bool quote = false; int error = 0; @@ -938,55 +925,55 @@ int git_buf_quote(git_buf *buf) if (!quote) goto done; - git_buf_putc("ed, '"'); - git_buf_put("ed, buf->ptr, i); + git_str_putc("ed, '"'); + git_str_put("ed, buf->ptr, i); for (; i < buf->size; i++) { /* whitespace - use the map above, which is ordered by ascii value */ if (buf->ptr[i] >= '\a' && buf->ptr[i] <= '\r') { - git_buf_putc("ed, '\\'); - git_buf_putc("ed, whitespace[buf->ptr[i] - '\a']); + git_str_putc("ed, '\\'); + git_str_putc("ed, whitespace[buf->ptr[i] - '\a']); } /* double quote and backslash must be escaped */ else if (buf->ptr[i] == '"' || buf->ptr[i] == '\\') { - git_buf_putc("ed, '\\'); - git_buf_putc("ed, buf->ptr[i]); + git_str_putc("ed, '\\'); + git_str_putc("ed, buf->ptr[i]); } /* escape anything unprintable as octal */ else if (buf->ptr[i] != ' ' && (buf->ptr[i] < '!' || buf->ptr[i] > '~')) { - git_buf_printf("ed, "\\%03o", (unsigned char)buf->ptr[i]); + git_str_printf("ed, "\\%03o", (unsigned char)buf->ptr[i]); } /* yay, printable! */ else { - git_buf_putc("ed, buf->ptr[i]); + git_str_putc("ed, buf->ptr[i]); } } - git_buf_putc("ed, '"'); + git_str_putc("ed, '"'); - if (git_buf_oom("ed)) { + if (git_str_oom("ed)) { error = -1; goto done; } - git_buf_swap("ed, buf); + git_str_swap("ed, buf); done: - git_buf_dispose("ed); + git_str_dispose("ed); return error; } /* Unquote per http://marc.info/?l=git&m=112927316408690&w=2 */ -int git_buf_unquote(git_buf *buf) +int git_str_unquote(git_str *buf) { size_t i, j; char ch; - git_buf_rtrim(buf); + git_str_rtrim(buf); if (buf->size < 2 || buf->ptr[0] != '"' || buf->ptr[buf->size-1] != '"') goto invalid; @@ -1055,8 +1042,8 @@ invalid: return -1; } -int git_buf_puts_escaped( - git_buf *buf, +int git_str_puts_escaped( + git_str *buf, const char *string, const char *esc_chars, const char *esc_with) @@ -1079,7 +1066,7 @@ int git_buf_puts_escaped( } GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, total, 1); - if (git_buf_grow_by(buf, alloclen) < 0) + if (git_str_grow_by(buf, alloclen) < 0) return -1; for (scan = string; *scan; ) { @@ -1105,12 +1092,12 @@ int git_buf_puts_escaped( return 0; } -void git_buf_unescape(git_buf *buf) +void git_str_unescape(git_str *buf) { buf->size = git__unescape(buf->ptr); } -int git_buf_crlf_to_lf(git_buf *tgt, const git_buf *src) +int git_str_crlf_to_lf(git_str *tgt, const git_str *src) { const char *scan = src->ptr; const char *scan_end = src->ptr + src->size; @@ -1121,11 +1108,11 @@ int git_buf_crlf_to_lf(git_buf *tgt, const git_buf *src) GIT_ASSERT(tgt != src); if (!next) - return git_buf_set(tgt, src->ptr, src->size); + return git_str_set(tgt, src->ptr, src->size); /* reduce reallocs while in the loop */ GIT_ERROR_CHECK_ALLOC_ADD(&new_size, src->size, 1); - if (git_buf_grow(tgt, new_size) < 0) + if (git_str_grow(tgt, new_size) < 0) return -1; out = tgt->ptr; @@ -1157,7 +1144,7 @@ int git_buf_crlf_to_lf(git_buf *tgt, const git_buf *src) return 0; } -int git_buf_lf_to_crlf(git_buf *tgt, const git_buf *src) +int git_str_lf_to_crlf(git_str *tgt, const git_str *src) { const char *start = src->ptr; const char *end = start + src->size; @@ -1168,12 +1155,12 @@ int git_buf_lf_to_crlf(git_buf *tgt, const git_buf *src) GIT_ASSERT(tgt != src); if (!next) - return git_buf_set(tgt, src->ptr, src->size); + return git_str_set(tgt, src->ptr, src->size); /* attempt to reduce reallocs while in the loop */ GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, src->size, src->size >> 4); GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1); - if (git_buf_grow(tgt, alloclen) < 0) + if (git_str_grow(tgt, alloclen) < 0) return -1; tgt->size = 0; @@ -1185,7 +1172,7 @@ int git_buf_lf_to_crlf(git_buf *tgt, const git_buf *src) copylen--; GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, copylen, 3); - if (git_buf_grow_by(tgt, alloclen) < 0) + if (git_str_grow_by(tgt, alloclen) < 0) return -1; if (copylen) { @@ -1198,21 +1185,21 @@ int git_buf_lf_to_crlf(git_buf *tgt, const git_buf *src) } tgt->ptr[tgt->size] = '\0'; - return git_buf_put(tgt, scan, end - scan); + return git_str_put(tgt, scan, end - scan); } -int git_buf_common_prefix(git_buf *buf, char *const *const strings, size_t count) +int git_str_common_prefix(git_str *buf, char *const *const strings, size_t count) { size_t i; const char *str, *pfx; - git_buf_clear(buf); + git_str_clear(buf); if (!strings || !count) return 0; /* initialize common prefix to first string */ - if (git_buf_sets(buf, strings[0]) < 0) + if (git_str_sets(buf, strings[0]) < 0) return -1; /* go through the rest of the strings, truncating to shared prefix */ @@ -1223,7 +1210,7 @@ int git_buf_common_prefix(git_buf *buf, char *const *const strings, size_t count str++, pfx++) /* scanning */; - git_buf_truncate(buf, pfx - buf->ptr); + git_str_truncate(buf, pfx - buf->ptr); if (!buf->size) break; @@ -1232,15 +1219,15 @@ int git_buf_common_prefix(git_buf *buf, char *const *const strings, size_t count return 0; } -int git_buf_is_binary(const git_buf *buf) +int git_str_is_binary(const git_str *buf) { const char *scan = buf->ptr, *end = buf->ptr + buf->size; - git_buf_bom_t bom; + git_str_bom_t bom; int printable = 0, nonprintable = 0; - scan += git_buf_detect_bom(&bom, buf); + scan += git_str_detect_bom(&bom, buf); - if (bom > GIT_BUF_BOM_UTF8) + if (bom > GIT_STR_BOM_UTF8) return 1; while (scan < end) { @@ -1260,17 +1247,17 @@ int git_buf_is_binary(const git_buf *buf) return ((printable >> 7) < nonprintable); } -int git_buf_contains_nul(const git_buf *buf) +int git_str_contains_nul(const git_str *buf) { return (memchr(buf->ptr, '\0', buf->size) != NULL); } -int git_buf_detect_bom(git_buf_bom_t *bom, const git_buf *buf) +int git_str_detect_bom(git_str_bom_t *bom, const git_str *buf) { const char *ptr; size_t len; - *bom = GIT_BUF_BOM_NONE; + *bom = GIT_STR_BOM_NONE; /* need at least 2 bytes to look for any BOM */ if (buf->size < 2) return 0; @@ -1281,19 +1268,19 @@ int git_buf_detect_bom(git_buf_bom_t *bom, const git_buf *buf) switch (*ptr++) { case 0: if (len >= 4 && ptr[0] == 0 && ptr[1] == '\xFE' && ptr[2] == '\xFF') { - *bom = GIT_BUF_BOM_UTF32_BE; + *bom = GIT_STR_BOM_UTF32_BE; return 4; } break; case '\xEF': if (len >= 3 && ptr[0] == '\xBB' && ptr[1] == '\xBF') { - *bom = GIT_BUF_BOM_UTF8; + *bom = GIT_STR_BOM_UTF8; return 3; } break; case '\xFE': if (*ptr == '\xFF') { - *bom = GIT_BUF_BOM_UTF16_BE; + *bom = GIT_STR_BOM_UTF16_BE; return 2; } break; @@ -1301,10 +1288,10 @@ int git_buf_detect_bom(git_buf_bom_t *bom, const git_buf *buf) if (*ptr != '\xFE') break; if (len >= 4 && ptr[1] == 0 && ptr[2] == 0) { - *bom = GIT_BUF_BOM_UTF32_LE; + *bom = GIT_STR_BOM_UTF32_LE; return 4; } else { - *bom = GIT_BUF_BOM_UTF16_LE; + *bom = GIT_STR_BOM_UTF16_LE; return 2; } break; @@ -1315,8 +1302,8 @@ int git_buf_detect_bom(git_buf_bom_t *bom, const git_buf *buf) return 0; } -bool git_buf_gather_text_stats( - git_buf_text_stats *stats, const git_buf *buf, bool skip_bom) +bool git_str_gather_text_stats( + git_str_text_stats *stats, const git_str *buf, bool skip_bom) { const char *scan = buf->ptr, *end = buf->ptr + buf->size; int skip; @@ -1324,7 +1311,7 @@ bool git_buf_gather_text_stats( memset(stats, 0, sizeof(*stats)); /* BOM detection */ - skip = git_buf_detect_bom(&stats->bom, buf); + skip = git_str_detect_bom(&stats->bom, buf); if (skip_bom) scan += skip; diff --git a/src/str.h b/src/str.h new file mode 100644 index 000000000..af7acc21f --- /dev/null +++ b/src/str.h @@ -0,0 +1,354 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * 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_str_h__ +#define INCLUDE_str_h__ + +#include "common.h" + +struct git_str { + char *ptr; + size_t asize; + size_t size; +}; + +typedef enum { + GIT_STR_BOM_NONE = 0, + GIT_STR_BOM_UTF8 = 1, + GIT_STR_BOM_UTF16_LE = 2, + GIT_STR_BOM_UTF16_BE = 3, + GIT_STR_BOM_UTF32_LE = 4, + GIT_STR_BOM_UTF32_BE = 5 +} git_str_bom_t; + +typedef struct { + git_str_bom_t bom; /* BOM found at head of text */ + unsigned int nul, cr, lf, crlf; /* NUL, CR, LF and CRLF counts */ + unsigned int printable, nonprintable; /* These are just approximations! */ +} git_str_text_stats; + +extern char git_str__initstr[]; +extern char git_str__oom[]; + +/* Use to initialize string buffer structure when git_str is on stack */ +#define GIT_STR_INIT { git_str__initstr, 0, 0 } + +/** + * Static initializer for git_str from static string buffer + */ +#define GIT_STR_INIT_CONST(str, len) { (char *)(str), 0, (size_t)(len) } + +GIT_INLINE(bool) git_str_is_allocated(const git_str *str) +{ + return (str->ptr != NULL && str->asize > 0); +} + +/** + * Initialize a git_str structure. + * + * For the cases where GIT_STR_INIT cannot be used to do static + * initialization. + */ +extern int git_str_init(git_str *str, size_t initial_size); + +extern void git_str_dispose(git_str *str); + +/** + * Resize the string buffer allocation to make more space. + * + * This will attempt to grow the string buffer to accommodate the target + * size. The bstring buffer's `ptr` will be replaced with a newly + * allocated block of data. Be careful so that memory allocated by the + * caller is not lost. As a special variant, if you pass `target_size` as + * 0 and the memory is not allocated by libgit2, this will allocate a new + * buffer of size `size` and copy the external data into it. + * + * Currently, this will never shrink a buffer, only expand it. + * + * If the allocation fails, this will return an error and the buffer will be + * marked as invalid for future operations, invaliding the contents. + * + * @param str The buffer to be resized; may or may not be allocated yet + * @param target_size The desired available size + * @return 0 on success, -1 on allocation failure + */ +int git_str_grow(git_str *str, size_t target_size); + +/** + * Resize the buffer allocation to make more space. + * + * This will attempt to grow the string buffer to accommodate the + * additional size. It is similar to `git_str_grow`, but performs the + * new size calculation, checking for overflow. + * + * Like `git_str_grow`, if this is a user-supplied string buffer, + * this will allocate a new string uffer. + */ +extern int git_str_grow_by(git_str *str, size_t additional_size); + +/** + * Attempt to grow the buffer to hold at least `target_size` bytes. + * + * If the allocation fails, this will return an error. If `mark_oom` is + * true, this will mark the string buffer as invalid for future + * operations; if false, existing string buffer content will be preserved, + * but calling code must handle that string buffer was not expanded. If + * `preserve_external` is true, then any existing data pointed to be + * `ptr` even if `asize` is zero will be copied into the newly allocated + * string buffer. + */ +extern int git_str_try_grow( + git_str *str, size_t target_size, bool mark_oom); + +extern void git_str_swap(git_str *str_a, git_str *str_b); +extern char *git_str_detach(git_str *str); +extern int git_str_attach(git_str *str, char *ptr, size_t asize); + +/* Populates a `git_str` where the contents are not "owned" by the string + * buffer, and calls to `git_str_dispose` will not free the given str. + */ +extern void git_str_attach_notowned( + git_str *str, const char *ptr, size_t size); + +/** + * Test if there have been any reallocation failures with this git_str. + * + * Any function that writes to a git_str can fail due to memory allocation + * issues. If one fails, the git_str will be marked with an OOM error and + * further calls to modify the string buffer will fail. Check + * git_str_oom() at the end of your sequence and it will be true if you + * ran out of memory at any point with that string buffer. + * + * @return false if no error, true if allocation error + */ +GIT_INLINE(bool) git_str_oom(const git_str *str) +{ + return (str->ptr == git_str__oom); +} + +/* + * Functions below that return int value error codes will return 0 on + * success or -1 on failure (which generally means an allocation failed). + * Using a git_str where the allocation has failed with result in -1 from + * all further calls using that string buffer. As a result, you can + * ignore the return code of these functions and call them in a series + * then just call git_str_oom at the end. + */ + +int git_str_set(git_str *str, const void *data, size_t datalen); + +int git_str_sets(git_str *str, const char *string); +int git_str_putc(git_str *str, char c); +int git_str_putcn(git_str *str, char c, size_t len); +int git_str_put(git_str *str, const char *data, size_t len); +int git_str_puts(git_str *str, const char *string); +int git_str_printf(git_str *str, const char *format, ...) GIT_FORMAT_PRINTF(2, 3); +int git_str_vprintf(git_str *str, const char *format, va_list ap); +void git_str_clear(git_str *str); +void git_str_consume_bytes(git_str *str, size_t len); +void git_str_consume(git_str *str, const char *end); +void git_str_truncate(git_str *str, size_t len); +void git_str_shorten(git_str *str, size_t amount); +void git_str_truncate_at_char(git_str *path, char separator); +void git_str_rtruncate_at_char(git_str *path, char separator); + +/** General join with separator */ +int git_str_join_n(git_str *str, char separator, int len, ...); +/** Fast join of two strings - first may legally point into `str` data */ +int git_str_join(git_str *str, char separator, const char *str_a, const char *str_b); +/** Fast join of three strings - cannot reference `str` data */ +int git_str_join3(git_str *str, char separator, const char *str_a, const char *str_b, const char *str_c); + +/** + * Join two strings as paths, inserting a slash between as needed. + * @return 0 on success, -1 on failure + */ +GIT_INLINE(int) git_str_joinpath(git_str *str, const char *a, const char *b) +{ + return git_str_join(str, '/', a, b); +} + +GIT_INLINE(const char *) git_str_cstr(const git_str *str) +{ + return str->ptr; +} + +GIT_INLINE(size_t) git_str_len(const git_str *str) +{ + return str->size; +} + +int git_str_copy_cstr(char *data, size_t datasize, const git_str *str); + +#define git_str_PUTS(str, cstr) git_str_put(str, cstr, sizeof(cstr) - 1) + +GIT_INLINE(ssize_t) git_str_rfind_next(const git_str *str, char ch) +{ + ssize_t idx = (ssize_t)str->size - 1; + while (idx >= 0 && str->ptr[idx] == ch) idx--; + while (idx >= 0 && str->ptr[idx] != ch) idx--; + return idx; +} + +GIT_INLINE(ssize_t) git_str_rfind(const git_str *str, char ch) +{ + ssize_t idx = (ssize_t)str->size - 1; + while (idx >= 0 && str->ptr[idx] != ch) idx--; + return idx; +} + +GIT_INLINE(ssize_t) git_str_find(const git_str *str, char ch) +{ + void *found = memchr(str->ptr, ch, str->size); + return found ? (ssize_t)((const char *)found - str->ptr) : -1; +} + +/* Remove whitespace from the end of the string buffer */ +void git_str_rtrim(git_str *str); + +int git_str_cmp(const git_str *a, const git_str *b); + +/* Quote and unquote a string buffer as specified in + * http://marc.info/?l=git&m=112927316408690&w=2 + */ +int git_str_quote(git_str *str); +int git_str_unquote(git_str *str); + +/* Write data as base64 encoded in string buffer */ +int git_str_encode_base64(git_str *str, const char *data, size_t len); +/* Decode the given bas64 and write the result to the string buffer */ +int git_str_decode_base64(git_str *str, const char *base64, size_t len); + +/* Write data as "base85" encoded in string buffer */ +int git_str_encode_base85(git_str *str, const char *data, size_t len); +/* Decode the given "base85" and write the result to the string buffer */ +int git_str_decode_base85(git_str *str, const char *base64, size_t len, size_t output_len); + +/* + * Decode the given percent-encoded string and write the result to the + * string buffer. + */ +int git_str_decode_percent(git_str *str, const char *encoded, size_t len); + +/* + * Insert, remove or replace a portion of the string buffer. + * + * @param str The string buffer to work with + * + * @param where The location in the string buffer where the transformation + * should be applied. + * + * @param nb_to_remove The number of chars to be removed. 0 to not + * remove any character in the string buffer. + * + * @param data A pointer to the data which should be inserted. + * + * @param nb_to_insert The number of chars to be inserted. 0 to not + * insert any character from the string buffer. + * + * @return 0 or an error code. + */ +int git_str_splice( + git_str *str, + size_t where, + size_t nb_to_remove, + const char *data, + size_t nb_to_insert); + +/** + * Append string to string buffer, prefixing each character from + * `esc_chars` with `esc_with` string. + * + * @param str String buffer to append data to + * @param string String to escape and append + * @param esc_chars Characters to be escaped + * @param esc_with String to insert in from of each found character + * @return 0 on success, <0 on failure (probably allocation problem) + */ +extern int git_str_puts_escaped( + git_str *str, + const char *string, + const char *esc_chars, + const char *esc_with); + +/** + * Append string escaping characters that are regex special + */ +GIT_INLINE(int) git_str_puts_escape_regex(git_str *str, const char *string) +{ + return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\"); +} + +/** + * Unescape all characters in a string buffer in place + * + * I.e. remove backslashes + */ +extern void git_str_unescape(git_str *str); + +/** + * Replace all \r\n with \n. + * + * @return 0 on success, -1 on memory error + */ +extern int git_str_crlf_to_lf(git_str *tgt, const git_str *src); + +/** + * Replace all \n with \r\n. Does not modify existing \r\n. + * + * @return 0 on success, -1 on memory error + */ +extern int git_str_lf_to_crlf(git_str *tgt, const git_str *src); + +/** + * Fill string buffer with the common prefix of a array of strings + * + * String buffer will be set to empty if there is no common prefix + */ +extern int git_str_common_prefix(git_str *buf, char *const *const strings, size_t count); + +/** + * Check if a string buffer begins with a UTF BOM + * + * @param bom Set to the type of BOM detected or GIT_BOM_NONE + * @param str String buffer in which to check the first bytes for a BOM + * @return Number of bytes of BOM data (or 0 if no BOM found) + */ +extern int git_str_detect_bom(git_str_bom_t *bom, const git_str *str); + +/** + * Gather stats for a piece of text + * + * Fill the `stats` structure with counts of unreadable characters, carriage + * returns, etc, so it can be used in heuristics. This automatically skips + * a trailing EOF (\032 character). Also it will look for a BOM at the + * start of the text and can be told to skip that as well. + * + * @param stats Structure to be filled in + * @param str Text to process + * @param skip_bom Exclude leading BOM from stats if true + * @return Does the string buffer heuristically look like binary data + */ +extern bool git_str_gather_text_stats( + git_str_text_stats *stats, const git_str *str, bool skip_bom); + +/** +* Check quickly if string buffer looks like it contains binary data +* +* @param str string buffer to check +* @return 1 if string buffer looks like non-text data +*/ +int git_str_is_binary(const git_str *str); + +/** +* Check quickly if buffer contains a NUL byte +* +* @param str string buffer to check +* @return 1 if string buffer contains a NUL byte +*/ +int git_str_contains_nul(const git_str *str); + +#endif diff --git a/src/submodule.c b/src/submodule.c index 7cbb9fa3a..b0f7294be 100644 --- a/src/submodule.c +++ b/src/submodule.c @@ -7,11 +7,8 @@ #include "submodule.h" -#include "git2/config.h" -#include "git2/sys/config.h" -#include "git2/types.h" -#include "git2/index.h" -#include "buffer.h" +#include "buf.h" +#include "branch.h" #include "vector.h" #include "posix.h" #include "config_backend.h" @@ -20,10 +17,16 @@ #include "tree.h" #include "iterator.h" #include "path.h" +#include "str.h" #include "index.h" #include "worktree.h" #include "clone.h" +#include "git2/config.h" +#include "git2/sys/config.h" +#include "git2/types.h" +#include "git2/index.h" + #define GIT_MODULES_FILE ".gitmodules" static git_configmap _sm_update_map[] = { @@ -63,8 +66,8 @@ enum { static int submodule_alloc(git_submodule **out, git_repository *repo, const char *name); static git_config_backend *open_gitmodules(git_repository *repo, int gitmod); static int gitmodules_snapshot(git_config **snap, git_repository *repo); -static int get_url_base(git_buf *url, git_repository *repo); -static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo); +static int get_url_base(git_str *url, git_repository *repo); +static int lookup_head_remote_key(git_str *remote_key, git_repository *repo); static int lookup_default_remote(git_remote **remote, git_repository *repo); static int submodule_load_each(const git_config_entry *entry, void *payload); static int submodule_read_config(git_submodule *sm, git_config *cfg); @@ -79,11 +82,11 @@ static int submodule_cmp(const void *a, const void *b) return strcmp(((git_submodule *)a)->name, ((git_submodule *)b)->name); } -static int submodule_config_key_trunc_puts(git_buf *key, const char *suffix) +static int submodule_config_key_trunc_puts(git_str *key, const char *suffix) { - ssize_t idx = git_buf_rfind(key, '.'); - git_buf_truncate(key, (size_t)(idx + 1)); - return git_buf_puts(key, suffix); + ssize_t idx = git_str_rfind(key, '.'); + git_str_truncate(key, (size_t)(idx + 1)); + return git_str_puts(key, suffix); } /* @@ -128,7 +131,7 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa { int error = 0; git_index *index; - git_buf dir = GIT_BUF_INIT; + git_str dir = GIT_STR_INIT; *occupied = false; if ((error = git_repository_index__weakptr(&index, repo)) < 0) @@ -143,7 +146,7 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa goto out; } - if ((error = git_buf_sets(&dir, path)) < 0) + if ((error = git_str_sets(&dir, path)) < 0) goto out; if ((error = git_path_to_dir(&dir)) < 0) @@ -161,7 +164,7 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa error = 0; out: - git_buf_dispose(&dir); + git_str_dispose(&dir); return error; } @@ -195,7 +198,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf const char *key = "submodule\\..*\\.path"; git_config_iterator *iter = NULL; git_config_entry *entry; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_strmap *names; int isvalid, error; @@ -219,8 +222,8 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf goto out; } - git_buf_clear(&buf); - git_buf_put(&buf, fdot + 1, ldot - fdot - 1); + git_str_clear(&buf); + git_str_put(&buf, fdot + 1, ldot - fdot - 1); isvalid = git_submodule_name_is_valid(repo, buf.ptr, 0); if (isvalid < 0) { error = isvalid; @@ -229,7 +232,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf if (!isvalid) continue; - if ((error = git_strmap_set(names, git__strdup(entry->value), git_buf_detach(&buf))) < 0) { + if ((error = git_strmap_set(names, git__strdup(entry->value), git_str_detach(&buf))) < 0) { git_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table"); error = -1; goto out; @@ -243,7 +246,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf out: free_submodule_names(names); - git_buf_dispose(&buf); + git_str_dispose(&buf); git_config_iterator_free(iter); return error; } @@ -329,10 +332,10 @@ int git_submodule__lookup_with_cache( if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) { git_config_backend *mods; const char *pattern = "submodule\\..*\\.path"; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; fbp_data data = { NULL, NULL }; - git_buf_puts(&path, name); + git_str_puts(&path, name); while (path.ptr[path.size-1] == '/') { path.ptr[--path.size] = '\0'; } @@ -347,14 +350,14 @@ int git_submodule__lookup_with_cache( if (error < 0) { git_submodule_free(sm); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } if (data.name) { git__free(sm->name); sm->name = data.name; - sm->path = git_buf_detach(&path); + sm->path = git_str_detach(&path); /* Try to load again with the right name */ if ((error = git_submodule_reload(sm, false)) < 0) { @@ -363,7 +366,7 @@ int git_submodule__lookup_with_cache( } } - git_buf_dispose(&path); + git_str_dispose(&path); } if ((error = git_submodule_location(&location, sm)) < 0) { @@ -378,8 +381,8 @@ int git_submodule__lookup_with_cache( /* If it's not configured, we still check if there's a repo at the path */ if (git_repository_workdir(repo)) { - git_buf path = GIT_BUF_INIT; - if (git_buf_join3(&path, '/', + git_str path = GIT_STR_INIT; + if (git_str_join3(&path, '/', git_repository_workdir(repo), name, DOT_GIT) < 0 || git_path_validate_workdir_buf(NULL, &path) < 0) @@ -388,7 +391,7 @@ int git_submodule__lookup_with_cache( if (git_path_exists(path.ptr)) error = GIT_EEXISTS; - git_buf_dispose(&path); + git_str_dispose(&path); } submodule_set_lookup_error(error, name); @@ -405,7 +408,7 @@ int git_submodule__lookup_with_cache( int git_submodule_name_is_valid(git_repository *repo, const char *name, int flags) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error, isvalid; if (flags == 0) @@ -416,11 +419,11 @@ int git_submodule_name_is_valid(git_repository *repo, const char *name, int flag if ((error = git_path_normalize_slashes(&buf, name)) < 0) return error; } else { - git_buf_attach_notowned(&buf, name, strlen(name)); + git_str_attach_notowned(&buf, name, strlen(name)); } isvalid = git_path_validate(repo, buf.ptr, 0, flags); - git_buf_dispose(&buf); + git_str_dispose(&buf); return isvalid; } @@ -554,7 +557,7 @@ int git_submodule__map(git_repository *repo, git_strmap *map) int error = 0; git_index *idx = NULL; git_tree *head = NULL; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_submodule *sm; git_config *mods = NULL; bool has_workdir; @@ -613,7 +616,7 @@ cleanup: /* TODO: if we got an error, mark submodule config as invalid? */ git_index_free(idx); git_tree_free(head); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -682,7 +685,7 @@ static int submodule_repo_init( bool use_gitlink) { int error = 0; - git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT; + git_str workdir = GIT_STR_INIT, repodir = GIT_STR_INIT; git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT; git_repository *subrepo = NULL; @@ -701,10 +704,10 @@ static int submodule_repo_init( * Old style: sub-repo goes directly into repo/<name>/.git/ */ if (use_gitlink) { - error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES); + error = git_repository__item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES); if (error < 0) goto cleanup; - error = git_buf_joinpath(&repodir, repodir.ptr, path); + error = git_str_joinpath(&repodir, repodir.ptr, path); if (error < 0) goto cleanup; @@ -718,14 +721,57 @@ static int submodule_repo_init( error = git_repository_init_ext(&subrepo, workdir.ptr, &initopt); cleanup: - git_buf_dispose(&workdir); - git_buf_dispose(&repodir); + git_str_dispose(&workdir); + git_str_dispose(&repodir); *out = subrepo; return error; } +static int git_submodule__resolve_url( + git_str *out, + git_repository *repo, + const char *url) +{ + int error = 0; + git_str normalized = GIT_STR_INIT; + + GIT_ASSERT_ARG(out); + GIT_ASSERT_ARG(repo); + GIT_ASSERT_ARG(url); + + /* We do this in all platforms in case someone on Windows created the .gitmodules */ + if (strchr(url, '\\')) { + if ((error = git_path_normalize_slashes(&normalized, url)) < 0) + return error; + + url = normalized.ptr; + } + + + if (git_path_is_relative(url)) { + if (!(error = get_url_base(out, repo))) + error = git_path_apply_relative(out, url); + } else if (strchr(url, ':') != NULL || url[0] == '/') { + error = git_str_sets(out, url); + } else { + git_error_set(GIT_ERROR_SUBMODULE, "invalid format for submodule URL"); + error = -1; + } + + git_str_dispose(&normalized); + return error; +} + +int git_submodule_resolve_url( + git_buf *out, + git_repository *repo, + const char *url) +{ + GIT_BUF_WRAP_PRIVATE(out, git_submodule__resolve_url, repo, url); +} + int git_submodule_add_setup( git_submodule **out, git_repository *repo, @@ -736,7 +782,7 @@ int git_submodule_add_setup( int error = 0; git_config_backend *mods = NULL; git_submodule *sm = NULL; - git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT; + git_str name = GIT_STR_INIT, real_url = GIT_STR_INIT; git_repository *subrepo = NULL; bool path_occupied; @@ -781,7 +827,7 @@ int git_submodule_add_setup( return -1; } - if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 || + if ((error = git_str_printf(&name, "submodule.%s.path", path)) < 0 || (error = git_config_backend_set_string(mods, name.ptr, path)) < 0) goto cleanup; @@ -789,7 +835,7 @@ int git_submodule_add_setup( (error = git_config_backend_set_string(mods, name.ptr, url)) < 0) goto cleanup; - git_buf_clear(&name); + git_str_clear(&name); /* init submodule repository and add origin remote as needed */ @@ -804,7 +850,7 @@ int git_submodule_add_setup( git_path_contains(&name, DOT_GIT))) { /* resolve the actual URL to use */ - if ((error = git_submodule_resolve_url(&real_url, repo, url)) < 0) + if ((error = git_submodule__resolve_url(&real_url, repo, url)) < 0) goto cleanup; if ((error = submodule_repo_init(&subrepo, repo, path, real_url.ptr, use_gitlink)) < 0) @@ -826,8 +872,8 @@ cleanup: git_config_backend_free(mods); git_repository_free(subrepo); - git_buf_dispose(&real_url); - git_buf_dispose(&name); + git_str_dispose(&real_url); + git_str_dispose(&name); return error; } @@ -841,13 +887,13 @@ int git_submodule_repo_init( git_repository *sub_repo = NULL; const char *configured_url; git_config *cfg = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(sm); /* get the configured remote url of the submodule */ - if ((error = git_buf_printf(&buf, "submodule.%s.url", sm->name)) < 0 || + if ((error = git_str_printf(&buf, "submodule.%s.url", sm->name)) < 0 || (error = git_repository_config_snapshot(&cfg, sm->repo)) < 0 || (error = git_config_get_string(&configured_url, cfg, buf.ptr)) < 0 || (error = submodule_repo_init(&sub_repo, sm->repo, sm->path, configured_url, use_gitlink)) < 0) @@ -857,7 +903,7 @@ int git_submodule_repo_init( done: git_config_free(cfg); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -881,7 +927,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi { int error; git_repository *clone; - git_buf rel_path = GIT_BUF_INIT; + git_str rel_path = GIT_STR_INIT; git_submodule_update_options sub_opts = GIT_SUBMODULE_UPDATE_OPTIONS_INIT; git_clone_options opts = GIT_CLONE_OPTIONS_INIT; @@ -903,7 +949,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi if (error < 0) goto cleanup; - error = git_clone__submodule(&clone, git_submodule_url(submodule), git_buf_cstr(&rel_path), &opts); + error = git_clone__submodule(&clone, git_submodule_url(submodule), git_str_cstr(&rel_path), &opts); if (error < 0) goto cleanup; @@ -913,7 +959,7 @@ int git_submodule_clone(git_repository **out, git_submodule *submodule, const gi *out = clone; cleanup: - git_buf_dispose(&rel_path); + git_str_dispose(&rel_path); return error; } @@ -937,7 +983,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index) int error; git_repository *sm_repo = NULL; git_index *index; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_commit *head; git_index_entry entry; struct stat st; @@ -997,7 +1043,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index) cleanup: git_repository_free(sm_repo); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -1034,44 +1080,9 @@ const char *git_submodule_url(git_submodule *submodule) return submodule->url; } -int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url) -{ - int error = 0; - git_buf normalized = GIT_BUF_INIT; - - GIT_ASSERT_ARG(out); - GIT_ASSERT_ARG(repo); - GIT_ASSERT_ARG(url); - - if ((error = git_buf_sanitize(out)) < 0) - return error; - - /* We do this in all platforms in case someone on Windows created the .gitmodules */ - if (strchr(url, '\\')) { - if ((error = git_path_normalize_slashes(&normalized, url)) < 0) - return error; - - url = normalized.ptr; - } - - - if (git_path_is_relative(url)) { - if (!(error = get_url_base(out, repo))) - error = git_path_apply_relative(out, url); - } else if (strchr(url, ':') != NULL || url[0] == '/') { - error = git_buf_sets(out, url); - } else { - git_error_set(GIT_ERROR_SUBMODULE, "invalid format for submodule URL"); - error = -1; - } - - git_buf_dispose(&normalized); - return error; -} - static int write_var(git_repository *repo, const char *name, const char *var, const char *val) { - git_buf key = GIT_BUF_INIT; + git_str key = GIT_STR_INIT; git_config_backend *mods; int error; @@ -1079,7 +1090,7 @@ static int write_var(git_repository *repo, const char *name, const char *var, co if (!mods) return -1; - if ((error = git_buf_printf(&key, "submodule.%s.%s", name, var)) < 0) + if ((error = git_str_printf(&key, "submodule.%s.%s", name, var)) < 0) goto cleanup; if (val) @@ -1087,7 +1098,7 @@ static int write_var(git_repository *repo, const char *name, const char *var, co else error = git_config_backend_delete(mods, key.ptr); - git_buf_dispose(&key); + git_str_dispose(&key); cleanup: git_config_backend_free(mods); @@ -1227,7 +1238,7 @@ static int submodule_repo_create( const char *path) { int error = 0; - git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT; + git_str workdir = GIT_STR_INIT, repodir = GIT_STR_INIT; git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT; git_repository *subrepo = NULL; @@ -1249,18 +1260,18 @@ static int submodule_repo_create( * <repo-dir>/modules/<name>/ with a gitlink in the * sub-repo workdir directory to that repository. */ - error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES); + error = git_repository__item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES); if (error < 0) goto cleanup; - error = git_buf_joinpath(&repodir, repodir.ptr, path); + error = git_str_joinpath(&repodir, repodir.ptr, path); if (error < 0) goto cleanup; error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt); cleanup: - git_buf_dispose(&workdir); - git_buf_dispose(&repodir); + git_str_dispose(&workdir); + git_str_dispose(&repodir); *out = subrepo; @@ -1309,7 +1320,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio git_repository *sub_repo = NULL; git_remote *remote = NULL; git_object *target_commit = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT; git_clone_options clone_options = GIT_CLONE_OPTIONS_INIT; @@ -1337,10 +1348,10 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio * info has been copied into .git/config */ if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 || - (error = git_buf_printf(&buf, "submodule.%s.url", git_submodule_name(sm))) < 0) + (error = git_str_printf(&buf, "submodule.%s.url", git_submodule_name(sm))) < 0) goto done; - if ((error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0) { + if ((error = git_config_get_string(&submodule_url, config, git_str_cstr(&buf))) < 0) { /* * If the error is not "not found" or if it is "not found" and we are not * initializing the submodule, then return error. @@ -1362,7 +1373,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio config = NULL; if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 || - (error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0) + (error = git_config_get_string(&submodule_url, config, git_str_cstr(&buf))) < 0) goto done; } @@ -1420,7 +1431,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio } done: - git_buf_dispose(&buf); + git_str_dispose(&buf); git_config_free(config); git_object_free(target_commit); git_remote_free(remote); @@ -1433,7 +1444,7 @@ int git_submodule_init(git_submodule *sm, int overwrite) { int error; const char *val; - git_buf key = GIT_BUF_INIT, effective_submodule_url = GIT_BUF_INIT; + git_str key = GIT_STR_INIT, effective_submodule_url = GIT_STR_INIT; git_config *cfg = NULL; if (!sm->url) { @@ -1447,8 +1458,8 @@ int git_submodule_init(git_submodule *sm, int overwrite) /* write "submodule.NAME.url" */ - if ((error = git_submodule_resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 || - (error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 || + if ((error = git_submodule__resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 || + (error = git_str_printf(&key, "submodule.%s.url", sm->name)) < 0 || (error = git_config__update_entry( cfg, key.ptr, effective_submodule_url.ptr, overwrite != 0, false)) < 0) goto cleanup; @@ -1458,7 +1469,7 @@ int git_submodule_init(git_submodule *sm, int overwrite) val = (sm->update == GIT_SUBMODULE_UPDATE_CHECKOUT) ? NULL : submodule_update_to_str(sm->update); - if ((error = git_buf_printf(&key, "submodule.%s.update", sm->name)) < 0 || + if ((error = git_str_printf(&key, "submodule.%s.update", sm->name)) < 0 || (error = git_config__update_entry( cfg, key.ptr, val, overwrite != 0, false)) < 0) goto cleanup; @@ -1467,15 +1478,15 @@ int git_submodule_init(git_submodule *sm, int overwrite) cleanup: git_config_free(cfg); - git_buf_dispose(&key); - git_buf_dispose(&effective_submodule_url); + git_str_dispose(&key); + git_str_dispose(&effective_submodule_url); return error; } int git_submodule_sync(git_submodule *sm) { - git_buf key = GIT_BUF_INIT, url = GIT_BUF_INIT, remote_name = GIT_BUF_INIT; + git_str key = GIT_STR_INIT, url = GIT_STR_INIT, remote_name = GIT_STR_INIT; git_repository *smrepo = NULL; git_config *cfg = NULL; int error = 0; @@ -1487,8 +1498,8 @@ int git_submodule_sync(git_submodule *sm) /* copy URL over to config only if it already exists */ if ((error = git_repository_config__weakptr(&cfg, sm->repo)) < 0 || - (error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 || - (error = git_submodule_resolve_url(&url, sm->repo, sm->url)) < 0 || + (error = git_str_printf(&key, "submodule.%s.url", sm->name)) < 0 || + (error = git_submodule__resolve_url(&url, sm->repo, sm->url)) < 0 || (error = git_config__update_entry(cfg, key.ptr, url.ptr, true, true)) < 0) goto out; @@ -1501,9 +1512,9 @@ int git_submodule_sync(git_submodule *sm) goto out; if (lookup_head_remote_key(&remote_name, smrepo) == 0) { - if ((error = git_buf_join3(&key, '.', "remote", remote_name.ptr, "url")) < 0) + if ((error = git_str_join3(&key, '.', "remote", remote_name.ptr, "url")) < 0) goto out; - } else if ((error = git_buf_sets(&key, "remote.origin.url")) < 0) { + } else if ((error = git_str_sets(&key, "remote.origin.url")) < 0) { goto out; } @@ -1512,9 +1523,9 @@ int git_submodule_sync(git_submodule *sm) out: git_repository_free(smrepo); - git_buf_dispose(&remote_name); - git_buf_dispose(&key); - git_buf_dispose(&url); + git_str_dispose(&remote_name); + git_str_dispose(&key); + git_str_dispose(&url); return error; } @@ -1522,7 +1533,7 @@ static int git_submodule__open( git_repository **subrepo, git_submodule *sm, bool bare) { int error; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; unsigned int flags = GIT_REPOSITORY_OPEN_NO_SEARCH; const char *wd; @@ -1535,7 +1546,7 @@ static int git_submodule__open( wd = git_repository_workdir(sm->repo); - if (git_buf_join3(&path, '/', wd, sm->path, DOT_GIT) < 0) + if (git_str_join3(&path, '/', wd, sm->path, DOT_GIT) < 0) return -1; sm->flags = sm->flags & @@ -1561,13 +1572,13 @@ static int git_submodule__open( sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED | GIT_SUBMODULE_STATUS_IN_WD; } else { - git_buf_rtruncate_at_char(&path, '/'); /* remove "/.git" */ + git_str_rtruncate_at_char(&path, '/'); /* remove "/.git" */ if (git_path_isdir(path.ptr)) sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED; } - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -1921,13 +1932,13 @@ static int submodule_parse_recurse(git_submodule_recurse_t *out, const char *val return 0; } -static int get_value(const char **out, git_config *cfg, git_buf *buf, const char *name, const char *field) +static int get_value(const char **out, git_config *cfg, git_str *buf, const char *name, const char *field) { int error; - git_buf_clear(buf); + git_str_clear(buf); - if ((error = git_buf_printf(buf, "submodule.%s.%s", name, field)) < 0 || + if ((error = git_str_printf(buf, "submodule.%s.%s", name, field)) < 0 || (error = git_config_get_string(out, cfg, buf->ptr)) < 0) return error; @@ -1944,7 +1955,7 @@ static bool looks_like_command_line_option(const char *s) static int submodule_read_config(git_submodule *sm, git_config *cfg) { - git_buf key = GIT_BUF_INIT; + git_str key = GIT_STR_INIT; const char *value; int error, in_config = 0; @@ -2025,7 +2036,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg) error = 0; cleanup: - git_buf_dispose(&key); + git_str_dispose(&key); return error; } @@ -2034,7 +2045,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload) lfc_data *data = payload; const char *namestart, *property; git_strmap *map = data->map; - git_buf name = GIT_BUF_INIT; + git_str name = GIT_STR_INIT; git_submodule *sm; int error, isvalid; @@ -2049,7 +2060,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload) property++; - if ((error = git_buf_set(&name, namestart, property - namestart -1)) < 0) + if ((error = git_str_set(&name, namestart, property - namestart -1)) < 0) return error; isvalid = git_submodule_name_is_valid(data->repo, name.ptr, 0); @@ -2083,13 +2094,13 @@ static int submodule_load_each(const git_config_entry *entry, void *payload) error = 0; done: - git_buf_dispose(&name); + git_str_dispose(&name); return error; } static int submodule_load_from_wd_lite(git_submodule *sm) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; if (git_repository_workdir_path(&path, sm->repo, sm->path) < 0) return -1; @@ -2100,7 +2111,7 @@ static int submodule_load_from_wd_lite(git_submodule *sm) if (git_path_contains(&path, DOT_GIT)) sm->flags |= GIT_SUBMODULE_STATUS_IN_WD; - git_buf_dispose(&path); + git_str_dispose(&path); return 0; } @@ -2112,7 +2123,7 @@ static int submodule_load_from_wd_lite(git_submodule *sm) static int gitmodules_snapshot(git_config **snap, git_repository *repo) { git_config *mods = NULL; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; if (git_repository_workdir(repo) == NULL) @@ -2123,7 +2134,7 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo) if ((error = git_config_open_ondisk(&mods, path.ptr)) < 0) goto cleanup; - git_buf_dispose(&path); + git_str_dispose(&path); if ((error = git_config_snapshot(snap, mods)) < 0) goto cleanup; @@ -2133,7 +2144,7 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo) cleanup: if (mods) git_config_free(mods); - git_buf_dispose(&path); + git_str_dispose(&path); return error; } @@ -2142,7 +2153,7 @@ static git_config_backend *open_gitmodules( git_repository *repo, int okay_to_create) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_config_backend *mods = NULL; if (git_repository_workdir(repo) != NULL) { @@ -2161,17 +2172,17 @@ static git_config_backend *open_gitmodules( } } - git_buf_dispose(&path); + git_str_dispose(&path); return mods; } /* Lookup name of remote of the local tracking branch HEAD points to */ -static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo) +static int lookup_head_remote_key(git_str *remote_name, git_repository *repo) { int error; git_reference *head = NULL; - git_buf upstream_name = GIT_BUF_INIT; + git_str upstream_name = GIT_STR_INIT; /* lookup and dereference HEAD */ if ((error = git_repository_head(&head, repo)) < 0) @@ -2190,18 +2201,18 @@ static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo) } /* lookup remote tracking branch of HEAD */ - if ((error = git_branch_upstream_name( + if ((error = git_branch__upstream_name( &upstream_name, repo, git_reference_name(head))) < 0) goto done; /* lookup remote of remote tracking branch */ - if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0) + if ((error = git_branch__remote_name(remote_name, repo, upstream_name.ptr)) < 0) goto done; done: - git_buf_dispose(&upstream_name); + git_str_dispose(&upstream_name); git_reference_free(head); return error; @@ -2211,13 +2222,13 @@ done: static int lookup_head_remote(git_remote **remote, git_repository *repo) { int error; - git_buf remote_name = GIT_BUF_INIT; + git_str remote_name = GIT_STR_INIT; /* lookup remote of remote tracking branch name */ if (!(error = lookup_head_remote_key(&remote_name, repo))) error = git_remote_lookup(remote, repo, remote_name.ptr); - git_buf_dispose(&remote_name); + git_str_dispose(&remote_name); return error; } @@ -2240,14 +2251,14 @@ static int lookup_default_remote(git_remote **remote, git_repository *repo) return error; } -static int get_url_base(git_buf *url, git_repository *repo) +static int get_url_base(git_str *url, git_repository *repo) { int error; git_worktree *wt = NULL; git_remote *remote = NULL; if ((error = lookup_default_remote(&remote, repo)) == 0) { - error = git_buf_sets(url, git_remote_url(remote)); + error = git_str_sets(url, git_remote_url(remote)); goto out; } else if (error != GIT_ENOTFOUND) goto out; @@ -2258,9 +2269,9 @@ static int get_url_base(git_buf *url, git_repository *repo) if (git_repository_is_worktree(repo)) { if ((error = git_worktree_open_from_repository(&wt, repo)) < 0) goto out; - error = git_buf_sets(url, wt->parent_path); + error = git_str_sets(url, wt->parent_path); } else { - error = git_buf_sets(url, git_repository_workdir(repo)); + error = git_str_sets(url, git_repository_workdir(repo)); } out: diff --git a/src/sysdir.c b/src/sysdir.c index dcbd48bc3..457d7f8a8 100644 --- a/src/sysdir.c +++ b/src/sysdir.c @@ -8,7 +8,7 @@ #include "sysdir.h" #include "runtime.h" -#include "buffer.h" +#include "str.h" #include "path.h" #include <ctype.h> #if GIT_WIN32 @@ -18,27 +18,27 @@ #include <pwd.h> #endif -static int git_sysdir_guess_programdata_dirs(git_buf *out) +static int git_sysdir_guess_programdata_dirs(git_str *out) { #ifdef GIT_WIN32 return git_win32__find_programdata_dirs(out); #else - git_buf_clear(out); + git_str_clear(out); return 0; #endif } -static int git_sysdir_guess_system_dirs(git_buf *out) +static int git_sysdir_guess_system_dirs(git_str *out) { #ifdef GIT_WIN32 return git_win32__find_system_dirs(out, L"etc\\"); #else - return git_buf_sets(out, "/etc"); + return git_str_sets(out, "/etc"); #endif } #ifndef GIT_WIN32 -static int get_passwd_home(git_buf *out, uid_t uid) +static int get_passwd_home(git_str *out, uid_t uid) { struct passwd pwd, *pwdptr; char *buf = NULL; @@ -66,7 +66,7 @@ static int get_passwd_home(git_buf *out, uid_t uid) goto out; } - if ((error = git_buf_puts(out, pwdptr->pw_dir)) < 0) + if ((error = git_str_puts(out, pwdptr->pw_dir)) < 0) goto out; out: @@ -75,7 +75,7 @@ out: } #endif -static int git_sysdir_guess_global_dirs(git_buf *out) +static int git_sysdir_guess_global_dirs(git_str *out) { #ifdef GIT_WIN32 return git_win32__find_global_dirs(out); @@ -114,12 +114,12 @@ static int git_sysdir_guess_global_dirs(git_buf *out) #endif } -static int git_sysdir_guess_xdg_dirs(git_buf *out) +static int git_sysdir_guess_xdg_dirs(git_str *out) { #ifdef GIT_WIN32 return git_win32__find_xdg_dirs(out); #else - git_buf env = GIT_BUF_INIT; + git_str env = GIT_STR_INIT; int error; uid_t uid, euid; @@ -132,13 +132,13 @@ static int git_sysdir_guess_xdg_dirs(git_buf *out) */ if (uid == euid) { if ((error = git__getenv(&env, "XDG_CONFIG_HOME")) == 0) - error = git_buf_joinpath(out, env.ptr, "git"); + error = git_str_joinpath(out, env.ptr, "git"); if (error == GIT_ENOTFOUND && (error = git__getenv(&env, "HOME")) == 0) - error = git_buf_joinpath(out, env.ptr, ".config/git"); + error = git_str_joinpath(out, env.ptr, ".config/git"); } else { if ((error = get_passwd_home(&env, euid)) == 0) - error = git_buf_joinpath(out, env.ptr, ".config/git"); + error = git_str_joinpath(out, env.ptr, ".config/git"); } if (error == GIT_ENOTFOUND) { @@ -146,31 +146,31 @@ static int git_sysdir_guess_xdg_dirs(git_buf *out) error = 0; } - git_buf_dispose(&env); + git_str_dispose(&env); return error; #endif } -static int git_sysdir_guess_template_dirs(git_buf *out) +static int git_sysdir_guess_template_dirs(git_str *out) { #ifdef GIT_WIN32 return git_win32__find_system_dirs(out, L"share\\git-core\\templates"); #else - return git_buf_sets(out, "/usr/share/git-core/templates"); + return git_str_sets(out, "/usr/share/git-core/templates"); #endif } struct git_sysdir__dir { - git_buf buf; - int (*guess)(git_buf *out); + git_str buf; + int (*guess)(git_str *out); }; static struct git_sysdir__dir git_sysdir__dirs[] = { - { GIT_BUF_INIT, git_sysdir_guess_system_dirs }, - { GIT_BUF_INIT, git_sysdir_guess_global_dirs }, - { GIT_BUF_INIT, git_sysdir_guess_xdg_dirs }, - { GIT_BUF_INIT, git_sysdir_guess_programdata_dirs }, - { GIT_BUF_INIT, git_sysdir_guess_template_dirs }, + { GIT_STR_INIT, git_sysdir_guess_system_dirs }, + { GIT_STR_INIT, git_sysdir_guess_global_dirs }, + { GIT_STR_INIT, git_sysdir_guess_xdg_dirs }, + { GIT_STR_INIT, git_sysdir_guess_programdata_dirs }, + { GIT_STR_INIT, git_sysdir_guess_template_dirs }, }; static void git_sysdir_global_shutdown(void) @@ -178,7 +178,7 @@ static void git_sysdir_global_shutdown(void) size_t i; for (i = 0; i < ARRAY_SIZE(git_sysdir__dirs); ++i) - git_buf_dispose(&git_sysdir__dirs[i].buf); + git_str_dispose(&git_sysdir__dirs[i].buf); } int git_sysdir_global_init(void) @@ -202,7 +202,7 @@ static int git_sysdir_check_selector(git_sysdir_t which) } -int git_sysdir_get(const git_buf **out, git_sysdir_t which) +int git_sysdir_get(const git_str **out, git_sysdir_t which) { GIT_ASSERT_ARG(out); @@ -219,7 +219,7 @@ int git_sysdir_get(const git_buf **out, git_sysdir_t which) int git_sysdir_set(git_sysdir_t which, const char *search_path) { const char *expand_path = NULL; - git_buf merge = GIT_BUF_INIT; + git_str merge = GIT_STR_INIT; GIT_ERROR_CHECK_ERROR(git_sysdir_check_selector(which)); @@ -233,48 +233,48 @@ int git_sysdir_set(git_sysdir_t which, const char *search_path) /* if $PATH is not referenced, then just set the path */ if (!expand_path) { if (search_path) - git_buf_sets(&git_sysdir__dirs[which].buf, search_path); + git_str_sets(&git_sysdir__dirs[which].buf, search_path); goto done; } /* otherwise set to join(before $PATH, old value, after $PATH) */ if (expand_path > search_path) - git_buf_set(&merge, search_path, expand_path - search_path); + git_str_set(&merge, search_path, expand_path - search_path); - if (git_buf_len(&git_sysdir__dirs[which].buf)) - git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR, + if (git_str_len(&git_sysdir__dirs[which].buf)) + git_str_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, git_sysdir__dirs[which].buf.ptr); expand_path += strlen(PATH_MAGIC); if (*expand_path) - git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, expand_path); + git_str_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, expand_path); - git_buf_swap(&git_sysdir__dirs[which].buf, &merge); - git_buf_dispose(&merge); + git_str_swap(&git_sysdir__dirs[which].buf, &merge); + git_str_dispose(&merge); done: - if (git_buf_oom(&git_sysdir__dirs[which].buf)) + if (git_str_oom(&git_sysdir__dirs[which].buf)) return -1; return 0; } static int git_sysdir_find_in_dirlist( - git_buf *path, + git_str *path, const char *name, git_sysdir_t which, const char *label) { size_t len; const char *scan, *next = NULL; - const git_buf *syspath; + const git_str *syspath; GIT_ERROR_CHECK_ERROR(git_sysdir_get(&syspath, which)); - if (!syspath || !git_buf_len(syspath)) + if (!syspath || !git_str_len(syspath)) goto done; - for (scan = git_buf_cstr(syspath); scan; scan = next) { + for (scan = git_str_cstr(syspath); scan; scan = next) { /* find unescaped separator or end of string */ for (next = scan; *next; ++next) { if (*next == GIT_PATH_LIST_SEPARATOR && @@ -287,9 +287,9 @@ static int git_sysdir_find_in_dirlist( if (!len) continue; - GIT_ERROR_CHECK_ERROR(git_buf_set(path, scan, len)); + GIT_ERROR_CHECK_ERROR(git_str_set(path, scan, len)); if (name) - GIT_ERROR_CHECK_ERROR(git_buf_joinpath(path, path->ptr, name)); + GIT_ERROR_CHECK_ERROR(git_str_joinpath(path, path->ptr, name)); if (git_path_exists(path->ptr)) return 0; @@ -300,47 +300,47 @@ done: git_error_set(GIT_ERROR_OS, "the %s file '%s' doesn't exist", label, name); else git_error_set(GIT_ERROR_OS, "the %s directory doesn't exist", label); - git_buf_dispose(path); + git_str_dispose(path); return GIT_ENOTFOUND; } -int git_sysdir_find_system_file(git_buf *path, const char *filename) +int git_sysdir_find_system_file(git_str *path, const char *filename) { return git_sysdir_find_in_dirlist( path, filename, GIT_SYSDIR_SYSTEM, "system"); } -int git_sysdir_find_global_file(git_buf *path, const char *filename) +int git_sysdir_find_global_file(git_str *path, const char *filename) { return git_sysdir_find_in_dirlist( path, filename, GIT_SYSDIR_GLOBAL, "global"); } -int git_sysdir_find_xdg_file(git_buf *path, const char *filename) +int git_sysdir_find_xdg_file(git_str *path, const char *filename) { return git_sysdir_find_in_dirlist( path, filename, GIT_SYSDIR_XDG, "global/xdg"); } -int git_sysdir_find_programdata_file(git_buf *path, const char *filename) +int git_sysdir_find_programdata_file(git_str *path, const char *filename) { return git_sysdir_find_in_dirlist( path, filename, GIT_SYSDIR_PROGRAMDATA, "ProgramData"); } -int git_sysdir_find_template_dir(git_buf *path) +int git_sysdir_find_template_dir(git_str *path) { return git_sysdir_find_in_dirlist( path, NULL, GIT_SYSDIR_TEMPLATE, "template"); } -int git_sysdir_expand_global_file(git_buf *path, const char *filename) +int git_sysdir_expand_global_file(git_str *path, const char *filename) { int error; if ((error = git_sysdir_find_global_file(path, NULL)) == 0) { if (filename) - error = git_buf_joinpath(path, path->ptr, filename); + error = git_str_joinpath(path, path->ptr, filename); } return error; diff --git a/src/sysdir.h b/src/sysdir.h index cc5599e38..d12bac9d9 100644 --- a/src/sysdir.h +++ b/src/sysdir.h @@ -10,7 +10,7 @@ #include "common.h" #include "posix.h" -#include "buffer.h" +#include "str.h" /** * Find a "global" file (i.e. one in a user's home directory). @@ -19,7 +19,7 @@ * @param filename name of file to find in the home directory * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error */ -extern int git_sysdir_find_global_file(git_buf *path, const char *filename); +extern int git_sysdir_find_global_file(git_str *path, const char *filename); /** * Find an "XDG" file (i.e. one in user's XDG config path). @@ -28,7 +28,7 @@ extern int git_sysdir_find_global_file(git_buf *path, const char *filename); * @param filename name of file to find in the home directory * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error */ -extern int git_sysdir_find_xdg_file(git_buf *path, const char *filename); +extern int git_sysdir_find_xdg_file(git_str *path, const char *filename); /** * Find a "system" file (i.e. one shared for all users of the system). @@ -37,7 +37,7 @@ extern int git_sysdir_find_xdg_file(git_buf *path, const char *filename); * @param filename name of file to find in the home directory * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error */ -extern int git_sysdir_find_system_file(git_buf *path, const char *filename); +extern int git_sysdir_find_system_file(git_str *path, const char *filename); /** * Find a "ProgramData" file (i.e. one in %PROGRAMDATA%) @@ -46,7 +46,7 @@ extern int git_sysdir_find_system_file(git_buf *path, const char *filename); * @param filename name of file to find in the ProgramData directory * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error */ -extern int git_sysdir_find_programdata_file(git_buf *path, const char *filename); +extern int git_sysdir_find_programdata_file(git_str *path, const char *filename); /** * Find template directory. @@ -54,7 +54,7 @@ extern int git_sysdir_find_programdata_file(git_buf *path, const char *filename) * @param path buffer to write the full path into * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error */ -extern int git_sysdir_find_template_dir(git_buf *path); +extern int git_sysdir_find_template_dir(git_str *path); /** * Expand the name of a "global" file (i.e. one in a user's home @@ -66,7 +66,7 @@ extern int git_sysdir_find_template_dir(git_buf *path); * @param filename name of file in the home directory * @return 0 on success or -1 on error */ -extern int git_sysdir_expand_global_file(git_buf *path, const char *filename); +extern int git_sysdir_expand_global_file(git_str *path, const char *filename); typedef enum { GIT_SYSDIR_SYSTEM = 0, @@ -87,11 +87,11 @@ extern int git_sysdir_global_init(void); /** * Get the search path for global/system/xdg files * - * @param out pointer to git_buf containing search path + * @param out pointer to git_str containing search path * @param which which list of paths to return * @return 0 on success, <0 on failure */ -extern int git_sysdir_get(const git_buf **out, git_sysdir_t which); +extern int git_sysdir_get(const git_str **out, git_sysdir_t which); /** * Set search paths for global/system/xdg files @@ -9,7 +9,6 @@ #include "commit.h" #include "signature.h" -#include "message.h" #include "wildmatch.h" #include "git2/object.h" #include "git2/repository.h" @@ -176,7 +175,7 @@ int git_tag__parse(void *_tag, git_odb_object *odb_obj) static int retrieve_tag_reference( git_reference **tag_reference_out, - git_buf *ref_name_out, + git_str *ref_name_out, git_repository *repo, const char *tag_name) { @@ -185,7 +184,7 @@ static int retrieve_tag_reference( *tag_reference_out = NULL; - if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) + if (git_str_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) return -1; error = git_reference_lookup(&tag_ref, repo, ref_name_out->ptr); @@ -199,11 +198,11 @@ static int retrieve_tag_reference( static int retrieve_tag_reference_oid( git_oid *oid, - git_buf *ref_name_out, + git_str *ref_name_out, git_repository *repo, const char *tag_name) { - if (git_buf_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) + if (git_str_joinpath(ref_name_out, GIT_REFS_TAGS_DIR, tag_name) < 0) return -1; return git_reference_name_to_id(oid, repo, ref_name_out->ptr); @@ -217,16 +216,16 @@ static int write_tag_annotation( const git_signature *tagger, const char *message) { - git_buf tag = GIT_BUF_INIT; + git_str tag = GIT_STR_INIT; git_odb *odb; git_oid__writebuf(&tag, "object ", git_object_id(target)); - git_buf_printf(&tag, "type %s\n", git_object_type2string(git_object_type(target))); - git_buf_printf(&tag, "tag %s\n", tag_name); + git_str_printf(&tag, "type %s\n", git_object_type2string(git_object_type(target))); + git_str_printf(&tag, "tag %s\n", tag_name); git_signature__writebuf(&tag, "tagger ", tagger); - git_buf_putc(&tag, '\n'); + git_str_putc(&tag, '\n'); - if (git_buf_puts(&tag, message) < 0) + if (git_str_puts(&tag, message) < 0) goto on_error; if (git_repository_odb__weakptr(&odb, repo) < 0) @@ -235,11 +234,11 @@ static int write_tag_annotation( if (git_odb_write(oid, odb, tag.ptr, tag.size, GIT_OBJECT_TAG) < 0) goto on_error; - git_buf_dispose(&tag); + git_str_dispose(&tag); return 0; on_error: - git_buf_dispose(&tag); + git_str_dispose(&tag); git_error_set(GIT_ERROR_OBJECT, "failed to create tag annotation"); return -1; } @@ -255,7 +254,7 @@ static int git_tag_create__internal( int create_tag_annotation) { git_reference *new_ref = NULL; - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; int error; @@ -276,7 +275,7 @@ static int git_tag_create__internal( /** Ensure the tag name doesn't conflict with an already existing * reference unless overwriting has explicitly been requested **/ if (error == 0 && !allow_ref_overwrite) { - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); git_error_set(GIT_ERROR_TAG, "tag already exists"); return GIT_EEXISTS; } @@ -291,7 +290,7 @@ static int git_tag_create__internal( cleanup: git_reference_free(new_ref); - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; } @@ -344,7 +343,7 @@ int git_tag_create_from_buffer(git_oid *oid, git_repository *repo, const char *b git_odb_object *target_obj; git_reference *new_ref = NULL; - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; GIT_ASSERT_ARG(oid); GIT_ASSERT_ARG(buffer); @@ -395,7 +394,7 @@ int git_tag_create_from_buffer(git_oid *oid, git_repository *repo, const char *b git_odb_stream_free(stream); if (error < 0) { - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; } @@ -403,7 +402,7 @@ int git_tag_create_from_buffer(git_oid *oid, git_repository *repo, const char *b &new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL); git_reference_free(new_ref); - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; @@ -418,12 +417,12 @@ on_error: int git_tag_delete(git_repository *repo, const char *tag_name) { git_reference *tag_ref; - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; int error; error = retrieve_tag_reference(&tag_ref, &ref_name, repo, tag_name); - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); if (error < 0) return error; @@ -535,7 +534,7 @@ int git_tag_peel(git_object **tag_target, const git_tag *tag) int git_tag_name_is_valid(int *valid, const char *name) { - git_buf ref_name = GIT_BUF_INIT; + git_str ref_name = GIT_STR_INIT; int error = 0; GIT_ASSERT(valid); @@ -547,14 +546,14 @@ int git_tag_name_is_valid(int *valid, const char *name) if (!name || name[0] == '-') goto done; - if ((error = git_buf_puts(&ref_name, GIT_REFS_TAGS_DIR)) < 0 || - (error = git_buf_puts(&ref_name, name)) < 0) + if ((error = git_str_puts(&ref_name, GIT_REFS_TAGS_DIR)) < 0 || + (error = git_str_puts(&ref_name, name)) < 0) goto done; error = git_reference_name_is_valid(valid, ref_name.ptr); done: - git_buf_dispose(&ref_name); + git_str_dispose(&ref_name); return error; } diff --git a/src/threadstate.c b/src/threadstate.c index e2c08975f..f67cf082b 100644 --- a/src/threadstate.c +++ b/src/threadstate.c @@ -36,7 +36,7 @@ static void threadstate_dispose(git_threadstate *threadstate) if (!threadstate) return; - if (threadstate->error_t.message != git_buf__initbuf) + if (threadstate->error_t.message != git_str__initstr) git__free(threadstate->error_t.message); threadstate->error_t.message = NULL; } @@ -76,7 +76,7 @@ git_threadstate *git_threadstate_get(void) return threadstate; if ((threadstate = git__calloc(1, sizeof(git_threadstate))) == NULL || - git_buf_init(&threadstate->error_buf, 0) < 0) + git_str_init(&threadstate->error_buf, 0) < 0) return NULL; git_tlsdata_set(tls_key, threadstate); diff --git a/src/threadstate.h b/src/threadstate.h index 51810a939..c10f26b59 100644 --- a/src/threadstate.h +++ b/src/threadstate.h @@ -12,7 +12,7 @@ typedef struct { git_error *last_error; git_error error_t; - git_buf error_buf; + git_str error_buf; char oid_fmt[GIT_OID_HEXSZ+1]; } git_threadstate; diff --git a/src/trace.c b/src/trace.c index efc7b01a2..c316bcacf 100644 --- a/src/trace.c +++ b/src/trace.c @@ -7,7 +7,7 @@ #include "trace.h" -#include "buffer.h" +#include "str.h" #include "runtime.h" #include "git2/trace.h" diff --git a/src/trace.h b/src/trace.h index a233aa225..eb20ec57b 100644 --- a/src/trace.h +++ b/src/trace.h @@ -10,7 +10,7 @@ #include "common.h" #include <git2/trace.h> -#include "buffer.h" +#include "str.h" #ifdef GIT_TRACE @@ -27,13 +27,13 @@ GIT_INLINE(void) git_trace__write_fmt( va_list ap) { git_trace_cb callback = git_trace__data.callback; - git_buf message = GIT_BUF_INIT; + git_str message = GIT_STR_INIT; - git_buf_vprintf(&message, fmt, ap); + git_str_vprintf(&message, fmt, ap); - callback(level, git_buf_cstr(&message)); + callback(level, git_str_cstr(&message)); - git_buf_dispose(&message); + git_str_dispose(&message); } #define git_trace_level() (git_trace__data.level) diff --git a/src/transport.c b/src/transport.c index e128aa6c7..fa1d35fce 100644 --- a/src/transport.c +++ b/src/transport.c @@ -143,7 +143,7 @@ int git_transport_register( git_transport_cb cb, void *param) { - git_buf prefix = GIT_BUF_INIT; + git_str prefix = GIT_STR_INIT; transport_definition *d, *definition = NULL; size_t i; int error = 0; @@ -151,7 +151,7 @@ int git_transport_register( GIT_ASSERT_ARG(scheme); GIT_ASSERT_ARG(cb); - if ((error = git_buf_printf(&prefix, "%s://", scheme)) < 0) + if ((error = git_str_printf(&prefix, "%s://", scheme)) < 0) goto on_error; git_vector_foreach(&custom_transports, i, d) { @@ -164,7 +164,7 @@ int git_transport_register( definition = git__calloc(1, sizeof(transport_definition)); GIT_ERROR_CHECK_ALLOC(definition); - definition->prefix = git_buf_detach(&prefix); + definition->prefix = git_str_detach(&prefix); definition->fn = cb; definition->param = param; @@ -174,21 +174,21 @@ int git_transport_register( return 0; on_error: - git_buf_dispose(&prefix); + git_str_dispose(&prefix); git__free(definition); return error; } int git_transport_unregister(const char *scheme) { - git_buf prefix = GIT_BUF_INIT; + git_str prefix = GIT_STR_INIT; transport_definition *d; size_t i; int error = 0; GIT_ASSERT_ARG(scheme); - if ((error = git_buf_printf(&prefix, "%s://", scheme)) < 0) + if ((error = git_str_printf(&prefix, "%s://", scheme)) < 0) goto done; git_vector_foreach(&custom_transports, i, d) { @@ -210,7 +210,7 @@ int git_transport_unregister(const char *scheme) error = GIT_ENOTFOUND; done: - git_buf_dispose(&prefix); + git_str_dispose(&prefix); return error; } diff --git a/src/transports/auth.c b/src/transports/auth.c index 51763e359..90b6b124f 100644 --- a/src/transports/auth.c +++ b/src/transports/auth.c @@ -7,17 +7,15 @@ #include "auth.h" -#include "git2.h" -#include "buffer.h" #include "git2/sys/credential.h" static int basic_next_token( - git_buf *out, + git_str *out, git_http_auth_context *ctx, git_credential *c) { git_credential_userpass_plaintext *cred; - git_buf raw = GIT_BUF_INIT; + git_str raw = GIT_STR_INIT; int error = GIT_EAUTH; GIT_UNUSED(ctx); @@ -29,11 +27,11 @@ static int basic_next_token( cred = (git_credential_userpass_plaintext *)c; - git_buf_printf(&raw, "%s:%s", cred->username, cred->password); + git_str_printf(&raw, "%s:%s", cred->username, cred->password); - if (git_buf_oom(&raw) || - git_buf_puts(out, "Basic ") < 0 || - git_buf_encode_base64(out, git_buf_cstr(&raw), raw.size) < 0) + if (git_str_oom(&raw) || + git_str_puts(out, "Basic ") < 0 || + git_str_encode_base64(out, git_str_cstr(&raw), raw.size) < 0) goto on_error; error = 0; @@ -42,7 +40,7 @@ on_error: if (raw.size) git__memzero(raw.ptr, raw.size); - git_buf_dispose(&raw); + git_str_dispose(&raw); return error; } diff --git a/src/transports/auth.h b/src/transports/auth.h index 9caac4676..824d7198c 100644 --- a/src/transports/auth.h +++ b/src/transports/auth.h @@ -10,7 +10,6 @@ #include "common.h" -#include "git2.h" #include "netops.h" typedef enum { @@ -35,7 +34,7 @@ struct git_http_auth_context { int (*set_challenge)(git_http_auth_context *ctx, const char *challenge); /** Gets the next authentication token from the context */ - int (*next_token)(git_buf *out, git_http_auth_context *ctx, git_credential *cred); + int (*next_token)(git_str *out, git_http_auth_context *ctx, git_credential *cred); /** Examines if all tokens have been presented. */ int (*is_complete)(git_http_auth_context *ctx); diff --git a/src/transports/auth_negotiate.c b/src/transports/auth_negotiate.c index 31469933e..6380504be 100644 --- a/src/transports/auth_negotiate.c +++ b/src/transports/auth_negotiate.c @@ -10,7 +10,6 @@ #if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK) #include "git2.h" -#include "buffer.h" #include "auth.h" #include "git2/sys/credential.h" @@ -33,7 +32,7 @@ typedef struct { git_http_auth_context parent; unsigned configured : 1, complete : 1; - git_buf target; + git_str target; char *challenge; gss_ctx_id_t gss_context; gss_OID oid; @@ -87,14 +86,14 @@ static void negotiate_context_dispose(http_auth_negotiate_context *ctx) ctx->gss_context = GSS_C_NO_CONTEXT; } - git_buf_dispose(&ctx->target); + git_str_dispose(&ctx->target); git__free(ctx->challenge); ctx->challenge = NULL; } static int negotiate_next_token( - git_buf *buf, + git_str *buf, git_http_auth_context *c, git_credential *cred) { @@ -104,7 +103,7 @@ static int negotiate_next_token( input_token = GSS_C_EMPTY_BUFFER, output_token = GSS_C_EMPTY_BUFFER; gss_buffer_t input_token_ptr = GSS_C_NO_BUFFER; - git_buf input_buf = GIT_BUF_INIT; + git_str input_buf = GIT_STR_INIT; gss_name_t server = NULL; gss_OID mech; size_t challenge_len; @@ -142,7 +141,7 @@ static int negotiate_next_token( } if (challenge_len > 9) { - if (git_buf_decode_base64(&input_buf, + if (git_str_decode_base64(&input_buf, ctx->challenge + 10, challenge_len - 10) < 0) { git_error_set(GIT_ERROR_NET, "invalid negotiate challenge from server"); error = -1; @@ -192,16 +191,16 @@ static int negotiate_next_token( goto done; } - git_buf_puts(buf, "Negotiate "); - git_buf_encode_base64(buf, output_token.value, output_token.length); + git_str_puts(buf, "Negotiate "); + git_str_encode_base64(buf, output_token.value, output_token.length); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) error = -1; done: gss_release_name(&status_minor, &server); gss_release_buffer(&status_minor, (gss_buffer_t) &output_token); - git_buf_dispose(&input_buf); + git_str_dispose(&input_buf); return error; } @@ -270,10 +269,10 @@ static int negotiate_init_context( return GIT_EAUTH; } - git_buf_puts(&ctx->target, "HTTP@"); - git_buf_puts(&ctx->target, url->host); + git_str_puts(&ctx->target, "HTTP@"); + git_str_puts(&ctx->target, url->host); - if (git_buf_oom(&ctx->target)) + if (git_str_oom(&ctx->target)) return -1; ctx->gss_context = GSS_C_NO_CONTEXT; diff --git a/src/transports/auth_ntlm.c b/src/transports/auth_ntlm.c index 742db75b3..f49ce101a 100644 --- a/src/transports/auth_ntlm.c +++ b/src/transports/auth_ntlm.c @@ -5,11 +5,11 @@ * a Linking Exception. For full terms see the included COPYING file. */ -#include "git2.h" +#include "auth_ntlm.h" + #include "common.h" -#include "buffer.h" +#include "str.h" #include "auth.h" -#include "auth_ntlm.h" #include "git2/sys/credential.h" #ifdef GIT_NTLM @@ -77,12 +77,12 @@ done: } static int ntlm_next_token( - git_buf *buf, + git_str *buf, git_http_auth_context *c, git_credential *cred) { http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c; - git_buf input_buf = GIT_BUF_INIT; + git_str input_buf = GIT_STR_INIT; const unsigned char *msg; size_t challenge_len, msg_len; int error = GIT_EAUTH; @@ -129,7 +129,7 @@ static int ntlm_next_token( goto done; } - if (git_buf_decode_base64(&input_buf, + if (git_str_decode_base64(&input_buf, ctx->challenge + 5, challenge_len - 5) < 0) { git_error_set(GIT_ERROR_NET, "invalid NTLM challenge from server"); goto done; @@ -149,16 +149,16 @@ static int ntlm_next_token( } } - git_buf_puts(buf, "NTLM "); - git_buf_encode_base64(buf, (const char *)msg, msg_len); + git_str_puts(buf, "NTLM "); + git_str_encode_base64(buf, (const char *)msg, msg_len); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) goto done; error = 0; done: - git_buf_dispose(&input_buf); + git_str_dispose(&input_buf); return error; } diff --git a/src/transports/auth_ntlm.h b/src/transports/auth_ntlm.h index a7cd6d795..40689498c 100644 --- a/src/transports/auth_ntlm.h +++ b/src/transports/auth_ntlm.h @@ -8,7 +8,6 @@ #ifndef INCLUDE_transports_auth_ntlm_h__ #define INCLUDE_transports_auth_ntlm_h__ -#include "git2.h" #include "auth.h" /* NTLM requires a full request/challenge/response */ diff --git a/src/transports/git.c b/src/transports/git.c index 7c93155a8..591e2ab03 100644 --- a/src/transports/git.c +++ b/src/transports/git.c @@ -7,12 +7,10 @@ #include "common.h" -#include "git2.h" -#include "buffer.h" #include "netops.h" -#include "git2/sys/transport.h" #include "stream.h" #include "streams/socket.h" +#include "git2/sys/transport.h" #define OWNING_SUBTRANSPORT(s) ((git_subtransport *)(s)->parent.subtransport) @@ -39,7 +37,7 @@ typedef struct { * * For example: 0035git-upload-pack /libgit2/libgit2\0host=github.com\0 */ -static int gen_proto(git_buf *request, const char *cmd, const char *url) +static int gen_proto(git_str *request, const char *cmd, const char *url) { char *delim, *repo; char host[] = "host="; @@ -61,13 +59,13 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url) len = 4 + strlen(cmd) + 1 + strlen(repo) + 1 + strlen(host) + (delim - url) + 1; - git_buf_grow(request, len); - git_buf_printf(request, "%04x%s %s%c%s", + git_str_grow(request, len); + git_str_printf(request, "%04x%s %s%c%s", (unsigned int)(len & 0x0FFFF), cmd, repo, 0, host); - git_buf_put(request, url, delim - url); - git_buf_putc(request, '\0'); + git_str_put(request, url, delim - url); + git_str_putc(request, '\0'); - if (git_buf_oom(request)) + if (git_str_oom(request)) return -1; return 0; @@ -75,7 +73,7 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url) static int send_command(git_proto_stream *s) { - git_buf request = GIT_BUF_INIT; + git_str request = GIT_STR_INIT; int error; if ((error = gen_proto(&request, s->cmd, s->url)) < 0) @@ -87,7 +85,7 @@ static int send_command(git_proto_stream *s) s->sent_command = 1; cleanup: - git_buf_dispose(&request); + git_str_dispose(&request); return error; } diff --git a/src/transports/http.c b/src/transports/http.c index 914335aba..adcb1ac43 100644 --- a/src/transports/http.c +++ b/src/transports/http.c @@ -9,13 +9,10 @@ #ifndef GIT_WINHTTP -#include "git2.h" #include "http_parser.h" -#include "buffer.h" #include "net.h" #include "netops.h" #include "remote.h" -#include "git2/sys/credential.h" #include "smart.h" #include "auth.h" #include "http.h" @@ -25,6 +22,7 @@ #include "streams/tls.h" #include "streams/socket.h" #include "httpclient.h" +#include "git2/sys/credential.h" bool git_http__expect_continue = false; diff --git a/src/transports/http.h b/src/transports/http.h index 5c360b883..8e8e7226e 100644 --- a/src/transports/http.h +++ b/src/transports/http.h @@ -8,7 +8,6 @@ #ifndef INCLUDE_transports_http_h__ #define INCLUDE_transports_http_h__ -#include "buffer.h" #include "settings.h" #include "httpclient.h" @@ -16,14 +15,14 @@ extern bool git_http__expect_continue; -GIT_INLINE(int) git_http__user_agent(git_buf *buf) +GIT_INLINE(int) git_http__user_agent(git_str *buf) { const char *ua = git_libgit2__user_agent(); if (!ua) ua = "libgit2 " LIBGIT2_VERSION; - return git_buf_printf(buf, "git/2.0 (%s)", ua); + return git_str_printf(buf, "git/2.0 (%s)", ua); } #endif diff --git a/src/transports/httpclient.c b/src/transports/httpclient.c index 5b8949a04..75782da82 100644 --- a/src/transports/httpclient.c +++ b/src/transports/httpclient.c @@ -84,8 +84,8 @@ typedef struct { git_http_response *response; /* Temporary buffers to avoid extra mallocs */ - git_buf parse_header_name; - git_buf parse_header_value; + git_str parse_header_name; + git_str parse_header_value; /* Parser state */ int error; @@ -120,8 +120,8 @@ struct git_http_client { request_chunked : 1; /* Temporary buffers to avoid extra mallocs */ - git_buf request_msg; - git_buf read_buf; + git_str request_msg; + git_str read_buf; /* A subset of information from the request */ size_t request_body_len, @@ -160,8 +160,8 @@ static int on_header_complete(http_parser *parser) git_http_client *client = ctx->client; git_http_response *response = ctx->response; - git_buf *name = &ctx->parse_header_name; - git_buf *value = &ctx->parse_header_value; + git_str *name = &ctx->parse_header_name; + git_str *value = &ctx->parse_header_value; if (!strcasecmp("Content-Type", name->ptr)) { if (response->content_type) { @@ -193,7 +193,7 @@ static int on_header_complete(http_parser *parser) } else if (!strcasecmp("Transfer-Encoding", name->ptr) && !strcasecmp("chunked", value->ptr)) { ctx->response->chunked = 1; - } else if (!strcasecmp("Proxy-Authenticate", git_buf_cstr(name))) { + } else if (!strcasecmp("Proxy-Authenticate", git_str_cstr(name))) { char *dup = git__strndup(value->ptr, value->size); GIT_ERROR_CHECK_ALLOC(dup); @@ -232,15 +232,15 @@ static int on_header_field(http_parser *parser, const char *str, size_t len) if (on_header_complete(parser) < 0) return ctx->parse_status = PARSE_STATUS_ERROR; - git_buf_clear(&ctx->parse_header_name); - git_buf_clear(&ctx->parse_header_value); + git_str_clear(&ctx->parse_header_name); + git_str_clear(&ctx->parse_header_value); /* Fall through */ case PARSE_HEADER_NONE: case PARSE_HEADER_NAME: ctx->parse_header_state = PARSE_HEADER_NAME; - if (git_buf_put(&ctx->parse_header_name, str, len) < 0) + if (git_str_put(&ctx->parse_header_name, str, len) < 0) return ctx->parse_status = PARSE_STATUS_ERROR; break; @@ -263,7 +263,7 @@ static int on_header_value(http_parser *parser, const char *str, size_t len) case PARSE_HEADER_VALUE: ctx->parse_header_state = PARSE_HEADER_VALUE; - if (git_buf_put(&ctx->parse_header_value, str, len) < 0) + if (git_str_put(&ctx->parse_header_value, str, len) < 0) return ctx->parse_status = PARSE_STATUS_ERROR; break; @@ -548,7 +548,7 @@ static void free_auth_context(git_http_server *server) } static int apply_credentials( - git_buf *buf, + git_str *buf, git_http_server *server, const char *header_name, git_credential *credentials) @@ -556,7 +556,7 @@ static int apply_credentials( git_http_auth_context *auth = server->auth_context; git_vector *challenges = &server->auth_challenges; const char *challenge; - git_buf token = GIT_BUF_INIT; + git_str token = GIT_STR_INIT; int error = 0; /* We've started a new request without creds; free the context. */ @@ -602,15 +602,15 @@ static int apply_credentials( } if (token.size > 0) - error = git_buf_printf(buf, "%s: %s\r\n", header_name, token.ptr); + error = git_str_printf(buf, "%s: %s\r\n", header_name, token.ptr); done: - git_buf_dispose(&token); + git_str_dispose(&token); return error; } GIT_INLINE(int) apply_server_credentials( - git_buf *buf, + git_str *buf, git_http_client *client, git_http_request *request) { @@ -621,7 +621,7 @@ GIT_INLINE(int) apply_server_credentials( } GIT_INLINE(int) apply_proxy_credentials( - git_buf *buf, + git_str *buf, git_http_client *client, git_http_request *request) { @@ -631,54 +631,54 @@ GIT_INLINE(int) apply_proxy_credentials( request->proxy_credentials); } -static int puts_host_and_port(git_buf *buf, git_net_url *url, bool force_port) +static int puts_host_and_port(git_str *buf, git_net_url *url, bool force_port) { bool ipv6 = git_net_url_is_ipv6(url); if (ipv6) - git_buf_putc(buf, '['); + git_str_putc(buf, '['); - git_buf_puts(buf, url->host); + git_str_puts(buf, url->host); if (ipv6) - git_buf_putc(buf, ']'); + git_str_putc(buf, ']'); if (force_port || !git_net_url_is_default_port(url)) { - git_buf_putc(buf, ':'); - git_buf_puts(buf, url->port); + git_str_putc(buf, ':'); + git_str_puts(buf, url->port); } - return git_buf_oom(buf) ? -1 : 0; + return git_str_oom(buf) ? -1 : 0; } static int generate_connect_request( git_http_client *client, git_http_request *request) { - git_buf *buf; + git_str *buf; int error; - git_buf_clear(&client->request_msg); + git_str_clear(&client->request_msg); buf = &client->request_msg; - git_buf_puts(buf, "CONNECT "); + git_str_puts(buf, "CONNECT "); puts_host_and_port(buf, &client->server.url, true); - git_buf_puts(buf, " HTTP/1.1\r\n"); + git_str_puts(buf, " HTTP/1.1\r\n"); - git_buf_puts(buf, "User-Agent: "); + git_str_puts(buf, "User-Agent: "); git_http__user_agent(buf); - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); - git_buf_puts(buf, "Host: "); + git_str_puts(buf, "Host: "); puts_host_and_port(buf, &client->server.url, true); - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); if ((error = apply_proxy_credentials(buf, client, request) < 0)) return -1; - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); - return git_buf_oom(buf) ? -1 : 0; + return git_str_oom(buf) ? -1 : 0; } static bool use_connect_proxy(git_http_client *client) @@ -690,53 +690,53 @@ static int generate_request( git_http_client *client, git_http_request *request) { - git_buf *buf; + git_str *buf; size_t i; int error; GIT_ASSERT_ARG(client); GIT_ASSERT_ARG(request); - git_buf_clear(&client->request_msg); + git_str_clear(&client->request_msg); buf = &client->request_msg; /* GET|POST path HTTP/1.1 */ - git_buf_puts(buf, name_for_method(request->method)); - git_buf_putc(buf, ' '); + git_str_puts(buf, name_for_method(request->method)); + git_str_putc(buf, ' '); if (request->proxy && strcmp(request->url->scheme, "https")) git_net_url_fmt(buf, request->url); else git_net_url_fmt_path(buf, request->url); - git_buf_puts(buf, " HTTP/1.1\r\n"); + git_str_puts(buf, " HTTP/1.1\r\n"); - git_buf_puts(buf, "User-Agent: "); + git_str_puts(buf, "User-Agent: "); git_http__user_agent(buf); - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); - git_buf_puts(buf, "Host: "); + git_str_puts(buf, "Host: "); puts_host_and_port(buf, request->url, false); - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); if (request->accept) - git_buf_printf(buf, "Accept: %s\r\n", request->accept); + git_str_printf(buf, "Accept: %s\r\n", request->accept); else - git_buf_puts(buf, "Accept: */*\r\n"); + git_str_puts(buf, "Accept: */*\r\n"); if (request->content_type) - git_buf_printf(buf, "Content-Type: %s\r\n", + git_str_printf(buf, "Content-Type: %s\r\n", request->content_type); if (request->chunked) - git_buf_puts(buf, "Transfer-Encoding: chunked\r\n"); + git_str_puts(buf, "Transfer-Encoding: chunked\r\n"); if (request->content_length > 0) - git_buf_printf(buf, "Content-Length: %"PRIuZ "\r\n", + git_str_printf(buf, "Content-Length: %"PRIuZ "\r\n", request->content_length); if (request->expect_continue) - git_buf_printf(buf, "Expect: 100-continue\r\n"); + git_str_printf(buf, "Expect: 100-continue\r\n"); if ((error = apply_server_credentials(buf, client, request)) < 0 || (!use_connect_proxy(client) && @@ -748,13 +748,13 @@ static int generate_request( const char *hdr = request->custom_headers->strings[i]; if (hdr) - git_buf_printf(buf, "%s\r\n", hdr); + git_str_printf(buf, "%s\r\n", hdr); } } - git_buf_puts(buf, "\r\n"); + git_str_puts(buf, "\r\n"); - if (git_buf_oom(buf)) + if (git_str_oom(buf)) return -1; return 0; @@ -1077,7 +1077,7 @@ GIT_INLINE(int) client_read(git_http_client *client) client->proxy.stream : client->server.stream; /* - * We use a git_buf for convenience, but statically allocate it and + * We use a git_str for convenience, but statically allocate it and * don't resize. Limit our consumption to INT_MAX since calling * functions use an int return type to return number of bytes read. */ @@ -1198,7 +1198,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client) return -1; } - git_buf_consume_bytes(&client->read_buf, parsed_len); + git_str_consume_bytes(&client->read_buf, parsed_len); return (int)parsed_len; } @@ -1235,7 +1235,7 @@ static void complete_response_body(git_http_client *client) } done: - git_buf_clear(&client->read_buf); + git_str_clear(&client->read_buf); } int git_http_client_send_request( @@ -1257,12 +1257,12 @@ int git_http_client_send_request( return 0; if (git_trace_level() >= GIT_TRACE_DEBUG) { - git_buf url = GIT_BUF_INIT; + git_str url = GIT_STR_INIT; git_net_url_fmt(&url, request->url); git_trace(GIT_TRACE_DEBUG, "Sending %s request to %s", name_for_method(request->method), url.ptr ? url.ptr : "<invalid>"); - git_buf_dispose(&url); + git_str_dispose(&url); } if ((error = http_client_connect(client, request)) < 0 || @@ -1314,7 +1314,7 @@ int git_http_client_send_body( size_t buffer_len) { git_http_server *server; - git_buf hdr = GIT_BUF_INIT; + git_str hdr = GIT_STR_INIT; int error; GIT_ASSERT_ARG(client); @@ -1341,7 +1341,7 @@ int git_http_client_send_body( client->request_body_remain -= buffer_len; } else { - if ((error = git_buf_printf(&hdr, "%" PRIxZ "\r\n", buffer_len)) < 0 || + if ((error = git_str_printf(&hdr, "%" PRIxZ "\r\n", buffer_len)) < 0 || (error = stream_write(server, hdr.ptr, hdr.size)) < 0 || (error = stream_write(server, buffer, buffer_len)) < 0 || (error = stream_write(server, "\r\n", 2)) < 0) @@ -1349,7 +1349,7 @@ int git_http_client_send_body( } done: - git_buf_dispose(&hdr); + git_str_dispose(&hdr); return error; } @@ -1422,8 +1422,8 @@ int git_http_client_read_response( GIT_ASSERT(client->state == READING_BODY || client->state == DONE); done: - git_buf_dispose(&parser_context.parse_header_name); - git_buf_dispose(&parser_context.parse_header_value); + git_str_dispose(&parser_context.parse_header_name); + git_str_dispose(&parser_context.parse_header_value); return error; } @@ -1531,7 +1531,7 @@ int git_http_client_new( client = git__calloc(1, sizeof(git_http_client)); GIT_ERROR_CHECK_ALLOC(client); - git_buf_init(&client->read_buf, GIT_READ_BUFFER_SIZE); + git_str_init(&client->read_buf, GIT_READ_BUFFER_SIZE); GIT_ERROR_CHECK_ALLOC(client->read_buf.ptr); if (opts) @@ -1560,7 +1560,7 @@ static void http_client_close(git_http_client *client) http_server_close(&client->server); http_server_close(&client->proxy); - git_buf_dispose(&client->request_msg); + git_str_dispose(&client->request_msg); client->state = 0; client->request_count = 0; @@ -1574,6 +1574,6 @@ void git_http_client_free(git_http_client *client) return; http_client_close(client); - git_buf_dispose(&client->read_buf); + git_str_dispose(&client->read_buf); git__free(client); } diff --git a/src/transports/local.c b/src/transports/local.c index bb31b1345..0656ea592 100644 --- a/src/transports/local.c +++ b/src/transports/local.c @@ -7,6 +7,16 @@ #include "common.h" +#include "pack-objects.h" +#include "refs.h" +#include "posix.h" +#include "path.h" +#include "repository.h" +#include "odb.h" +#include "push.h" +#include "remote.h" +#include "proxy.h" + #include "git2/types.h" #include "git2/net.h" #include "git2/repository.h" @@ -19,17 +29,6 @@ #include "git2/commit.h" #include "git2/revparse.h" -#include "pack-objects.h" -#include "refs.h" -#include "posix.h" -#include "path.h" -#include "buffer.h" -#include "repository.h" -#include "odb.h" -#include "push.h" -#include "remote.h" -#include "proxy.h" - typedef struct { git_transport parent; git_remote *owner; @@ -71,7 +70,7 @@ static int add_ref(transport_local *t, const char *name) git_remote_head *head; git_oid obj_id; git_object *obj = NULL, *target = NULL; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; if ((error = git_reference_lookup(&ref, t->repo, name)) < 0) @@ -132,11 +131,11 @@ static int add_ref(transport_local *t, const char *name) head = git__calloc(1, sizeof(git_remote_head)); GIT_ERROR_CHECK_ALLOC(head); - if (git_buf_join(&buf, 0, name, peeled) < 0) { + if (git_str_join(&buf, 0, name, peeled) < 0) { free_head(head); return -1; } - head->name = git_buf_detach(&buf); + head->name = git_str_detach(&buf); if (!(error = git_tag_peel(&target, (git_tag *)obj))) { git_oid_cpy(&head->oid, git_object_id(target)); @@ -210,7 +209,7 @@ static int local_connect( int error; transport_local *t = (transport_local *) transport; const char *path; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; GIT_UNUSED(cred_acquire_cb); GIT_UNUSED(cred_acquire_payload); @@ -228,14 +227,14 @@ static int local_connect( /* 'url' may be a url or path; convert to a path */ if ((error = git_path_from_url_or_path(&buf, url)) < 0) { - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } - path = git_buf_cstr(&buf); + path = git_str_cstr(&buf); error = git_repository_open(&repo, path); - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error < 0) return -1; @@ -346,7 +345,7 @@ static int local_push( push_spec *spec; char *url = NULL; const char *path; - git_buf buf = GIT_BUF_INIT, odb_path = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT, odb_path = GIT_STR_INIT; int error; size_t j; @@ -354,14 +353,14 @@ static int local_push( /* 'push->remote->url' may be a url or path; convert to a path */ if ((error = git_path_from_url_or_path(&buf, push->remote->url)) < 0) { - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } - path = git_buf_cstr(&buf); + path = git_str_cstr(&buf); error = git_repository_open(&remote_repo, path); - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error < 0) return error; @@ -378,12 +377,12 @@ static int local_push( goto on_error; } - if ((error = git_repository_item_path(&odb_path, remote_repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 - || (error = git_buf_joinpath(&odb_path, odb_path.ptr, "pack")) < 0) + if ((error = git_repository__item_path(&odb_path, remote_repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 + || (error = git_str_joinpath(&odb_path, odb_path.ptr, "pack")) < 0) goto on_error; error = git_packbuilder_write(push->pb, odb_path.ptr, 0, transfer_to_push_transfer, (void *) cbs); - git_buf_dispose(&odb_path); + git_str_dispose(&odb_path); if (error < 0) goto on_error; @@ -479,7 +478,7 @@ static const char *compressing_objects_fmt = "Compressing objects: %.0f%% (%d/%d static int local_counting(int stage, unsigned int current, unsigned int total, void *payload) { - git_buf progress_info = GIT_BUF_INIT; + git_str progress_info = GIT_STR_INIT; transport_local *t = payload; int error; @@ -487,22 +486,22 @@ static int local_counting(int stage, unsigned int current, unsigned int total, v return 0; if (stage == GIT_PACKBUILDER_ADDING_OBJECTS) { - git_buf_printf(&progress_info, counting_objects_fmt, current); + git_str_printf(&progress_info, counting_objects_fmt, current); } else if (stage == GIT_PACKBUILDER_DELTAFICATION) { float perc = (((float) current) / total) * 100; - git_buf_printf(&progress_info, compressing_objects_fmt, perc, current, total); + git_str_printf(&progress_info, compressing_objects_fmt, perc, current, total); if (current == total) - git_buf_printf(&progress_info, ", done\n"); + git_str_printf(&progress_info, ", done\n"); else - git_buf_putc(&progress_info, '\r'); + git_str_putc(&progress_info, '\r'); } - if (git_buf_oom(&progress_info)) + if (git_str_oom(&progress_info)) return -1; - error = t->progress_cb(git_buf_cstr(&progress_info), (int)git_buf_len(&progress_info), t->message_cb_payload); - git_buf_dispose(&progress_info); + error = t->progress_cb(git_str_cstr(&progress_info), (int)git_str_len(&progress_info), t->message_cb_payload); + git_str_dispose(&progress_info); return error; } @@ -545,7 +544,7 @@ static int local_download_pack( git_packbuilder *pack = NULL; git_odb_writepack *writepack = NULL; git_odb *odb = NULL; - git_buf progress_info = GIT_BUF_INIT; + git_str progress_info = GIT_STR_INIT; if ((error = git_revwalk_new(&walk, t->repo)) < 0) goto cleanup; @@ -584,11 +583,11 @@ static int local_download_pack( if ((error = git_packbuilder_insert_walk(pack, walk))) goto cleanup; - if ((error = git_buf_printf(&progress_info, counting_objects_fmt, git_packbuilder_object_count(pack))) < 0) + if ((error = git_str_printf(&progress_info, counting_objects_fmt, git_packbuilder_object_count(pack))) < 0) goto cleanup; if (t->progress_cb && - (error = t->progress_cb(git_buf_cstr(&progress_info), (int)git_buf_len(&progress_info), t->message_cb_payload)) < 0) + (error = t->progress_cb(git_str_cstr(&progress_info), (int)git_str_len(&progress_info), t->message_cb_payload)) < 0) goto cleanup; /* Walk the objects, building a packfile */ @@ -596,13 +595,13 @@ static int local_download_pack( goto cleanup; /* One last one with the newline */ - git_buf_clear(&progress_info); - git_buf_printf(&progress_info, counting_objects_fmt, git_packbuilder_object_count(pack)); - if ((error = git_buf_putc(&progress_info, '\n')) < 0) + git_str_clear(&progress_info); + git_str_printf(&progress_info, counting_objects_fmt, git_packbuilder_object_count(pack)); + if ((error = git_str_putc(&progress_info, '\n')) < 0) goto cleanup; if (t->progress_cb && - (error = t->progress_cb(git_buf_cstr(&progress_info), (int)git_buf_len(&progress_info), t->message_cb_payload)) < 0) + (error = t->progress_cb(git_str_cstr(&progress_info), (int)git_str_len(&progress_info), t->message_cb_payload)) < 0) goto cleanup; if ((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) != 0) @@ -627,7 +626,7 @@ static int local_download_pack( cleanup: if (writepack) writepack->free(writepack); - git_buf_dispose(&progress_info); + git_str_dispose(&progress_info); git_packbuilder_free(pack); git_revwalk_free(walk); return error; diff --git a/src/transports/smart.c b/src/transports/smart.c index 587f14358..fe024de2f 100644 --- a/src/transports/smart.c +++ b/src/transports/smart.c @@ -164,20 +164,20 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs) if (symrefs) { git_refspec *spec; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; size_t j; int error = 0; git_vector_foreach(symrefs, j, spec) { - git_buf_clear(&buf); + git_str_clear(&buf); if (git_refspec_src_matches(spec, ref->head.name) && - !(error = git_refspec_transform(&buf, spec, ref->head.name))) { + !(error = git_refspec__transform(&buf, spec, ref->head.name))) { git__free(ref->head.symref_target); - ref->head.symref_target = git_buf_detach(&buf); + ref->head.symref_target = git_str_detach(&buf); } } - git_buf_dispose(&buf); + git_str_dispose(&buf); if (error < 0) return error; diff --git a/src/transports/smart.h b/src/transports/smart.h index a05d4c9e3..225e64996 100644 --- a/src/transports/smart.h +++ b/src/transports/smart.h @@ -12,8 +12,8 @@ #include "git2.h" #include "vector.h" #include "netops.h" -#include "buffer.h" #include "push.h" +#include "str.h" #include "git2/sys/transport.h" #define GIT_SIDE_BAND_DATA 1 @@ -189,11 +189,11 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs); /* smart_pkt.c */ int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen); -int git_pkt_buffer_flush(git_buf *buf); +int git_pkt_buffer_flush(git_str *buf); int git_pkt_send_flush(GIT_SOCKET s); -int git_pkt_buffer_done(git_buf *buf); -int git_pkt_buffer_wants(const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, git_buf *buf); -int git_pkt_buffer_have(git_oid *oid, git_buf *buf); +int git_pkt_buffer_done(git_str *buf); +int git_pkt_buffer_wants(const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, git_str *buf); +int git_pkt_buffer_have(git_oid *oid, git_str *buf); void git_pkt_free(git_pkt *pkt); #endif diff --git a/src/transports/smart_pkt.c b/src/transports/smart_pkt.c index 56b680d28..b42edd0d6 100644 --- a/src/transports/smart_pkt.c +++ b/src/transports/smart_pkt.c @@ -7,16 +7,16 @@ #include "common.h" -#include "git2/types.h" -#include "git2/errors.h" -#include "git2/refs.h" -#include "git2/revwalk.h" - #include "smart.h" #include "util.h" #include "netops.h" #include "posix.h" -#include "buffer.h" +#include "str.h" + +#include "git2/types.h" +#include "git2/errors.h" +#include "git2/refs.h" +#include "git2/revwalk.h" #include <ctype.h> @@ -522,43 +522,43 @@ void git_pkt_free(git_pkt *pkt) git__free(pkt); } -int git_pkt_buffer_flush(git_buf *buf) +int git_pkt_buffer_flush(git_str *buf) { - return git_buf_put(buf, pkt_flush_str, strlen(pkt_flush_str)); + return git_str_put(buf, pkt_flush_str, strlen(pkt_flush_str)); } -static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_buf *buf) +static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_str *buf) { - git_buf str = GIT_BUF_INIT; + git_str str = GIT_STR_INIT; char oid[GIT_OID_HEXSZ +1] = {0}; size_t len; /* Prefer multi_ack_detailed */ if (caps->multi_ack_detailed) - git_buf_puts(&str, GIT_CAP_MULTI_ACK_DETAILED " "); + git_str_puts(&str, GIT_CAP_MULTI_ACK_DETAILED " "); else if (caps->multi_ack) - git_buf_puts(&str, GIT_CAP_MULTI_ACK " "); + git_str_puts(&str, GIT_CAP_MULTI_ACK " "); /* Prefer side-band-64k if the server supports both */ if (caps->side_band_64k) - git_buf_printf(&str, "%s ", GIT_CAP_SIDE_BAND_64K); + git_str_printf(&str, "%s ", GIT_CAP_SIDE_BAND_64K); else if (caps->side_band) - git_buf_printf(&str, "%s ", GIT_CAP_SIDE_BAND); + git_str_printf(&str, "%s ", GIT_CAP_SIDE_BAND); if (caps->include_tag) - git_buf_puts(&str, GIT_CAP_INCLUDE_TAG " "); + git_str_puts(&str, GIT_CAP_INCLUDE_TAG " "); if (caps->thin_pack) - git_buf_puts(&str, GIT_CAP_THIN_PACK " "); + git_str_puts(&str, GIT_CAP_THIN_PACK " "); if (caps->ofs_delta) - git_buf_puts(&str, GIT_CAP_OFS_DELTA " "); + git_str_puts(&str, GIT_CAP_OFS_DELTA " "); - if (git_buf_oom(&str)) + if (git_str_oom(&str)) return -1; len = strlen("XXXXwant ") + GIT_OID_HEXSZ + 1 /* NUL */ + - git_buf_len(&str) + 1 /* LF */; + git_str_len(&str) + 1 /* LF */; if (len > 0xffff) { git_error_set(GIT_ERROR_NET, @@ -566,13 +566,13 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca return -1; } - git_buf_grow_by(buf, len); + git_str_grow_by(buf, len); git_oid_fmt(oid, &head->oid); - git_buf_printf(buf, - "%04xwant %s %s\n", (unsigned int)len, oid, git_buf_cstr(&str)); - git_buf_dispose(&str); + git_str_printf(buf, + "%04xwant %s %s\n", (unsigned int)len, oid, git_str_cstr(&str)); + git_str_dispose(&str); - GIT_ERROR_CHECK_ALLOC_BUF(buf); + GIT_ERROR_CHECK_ALLOC_STR(buf); return 0; } @@ -586,7 +586,7 @@ int git_pkt_buffer_wants( const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, - git_buf *buf) + git_str *buf) { size_t i = 0; const git_remote_head *head; @@ -612,26 +612,26 @@ int git_pkt_buffer_wants( continue; git_oid_fmt(oid, &head->oid); - git_buf_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - git_buf_put(buf, oid, GIT_OID_HEXSZ); - git_buf_putc(buf, '\n'); - if (git_buf_oom(buf)) + git_str_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); + git_str_put(buf, oid, GIT_OID_HEXSZ); + git_str_putc(buf, '\n'); + if (git_str_oom(buf)) return -1; } return git_pkt_buffer_flush(buf); } -int git_pkt_buffer_have(git_oid *oid, git_buf *buf) +int git_pkt_buffer_have(git_oid *oid, git_str *buf) { char oidhex[GIT_OID_HEXSZ + 1]; memset(oidhex, 0x0, sizeof(oidhex)); git_oid_fmt(oidhex, oid); - return git_buf_printf(buf, "%s%s\n", pkt_have_prefix, oidhex); + return git_str_printf(buf, "%s%s\n", pkt_have_prefix, oidhex); } -int git_pkt_buffer_done(git_buf *buf) +int git_pkt_buffer_done(git_str *buf) { - return git_buf_puts(buf, pkt_done_str); + return git_str_puts(buf, pkt_done_str); } diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c index 91de163e9..a9a623cc7 100644 --- a/src/transports/smart_protocol.c +++ b/src/transports/smart_protocol.c @@ -89,7 +89,7 @@ static int append_symref(const char **out, git_vector *symrefs, const char *ptr) { int error; const char *end; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; git_refspec *mapping = NULL; ptr += strlen(GIT_CAP_SYMREF); @@ -101,15 +101,15 @@ static int append_symref(const char **out, git_vector *symrefs, const char *ptr) !(end = strchr(ptr, '\0'))) goto on_invalid; - if ((error = git_buf_put(&buf, ptr, end - ptr)) < 0) + if ((error = git_str_put(&buf, ptr, end - ptr)) < 0) return error; /* symref mapping has refspec format */ mapping = git__calloc(1, sizeof(git_refspec)); GIT_ERROR_CHECK_ALLOC(mapping); - error = git_refspec__parse(mapping, git_buf_cstr(&buf), true); - git_buf_dispose(&buf); + error = git_refspec__parse(mapping, git_str_cstr(&buf), true); + git_str_dispose(&buf); /* if the error isn't OOM, then it's a parse error; let's use a nicer message */ if (error < 0) { @@ -310,7 +310,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c transport_smart *t = (transport_smart *)transport; git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT; gitno_buffer *buf = &t->buffer; - git_buf data = GIT_BUF_INIT; + git_str data = GIT_STR_INIT; git_revwalk *walk = NULL; int error = -1; git_pkt_type pkt_type; @@ -354,7 +354,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c } git_pkt_buffer_flush(&data); - if (git_buf_oom(&data)) { + if (git_str_oom(&data)) { error = -1; goto on_error; } @@ -362,7 +362,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) goto on_error; - git_buf_clear(&data); + git_str_clear(&data); if (t->caps.multi_ack || t->caps.multi_ack_detailed) { if ((error = store_common(t)) < 0) goto on_error; @@ -397,7 +397,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c goto on_error; } - if (git_buf_oom(&data)) { + if (git_str_oom(&data)) { error = -1; goto on_error; } @@ -417,7 +417,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c goto on_error; } - if (git_buf_oom(&data)) { + if (git_str_oom(&data)) { error = -1; goto on_error; } @@ -434,7 +434,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0) goto on_error; - git_buf_dispose(&data); + git_str_dispose(&data); git_revwalk_free(walk); /* Now let's eat up whatever the server gives us */ @@ -454,7 +454,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c on_error: git_revwalk_free(walk); - git_buf_dispose(&data); + git_str_dispose(&data); return error; } @@ -626,7 +626,7 @@ done: return error; } -static int gen_pktline(git_buf *buf, git_push *push) +static int gen_pktline(git_str *buf, git_push *push) { push_spec *spec; size_t i, len; @@ -647,24 +647,24 @@ static int gen_pktline(git_buf *buf, git_push *push) git_oid_fmt(old_id, &spec->roid); git_oid_fmt(new_id, &spec->loid); - git_buf_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst); + git_str_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst); if (i == 0) { - git_buf_putc(buf, '\0'); + git_str_putc(buf, '\0'); /* Core git always starts their capabilities string with a space */ if (push->report_status) { - git_buf_putc(buf, ' '); - git_buf_printf(buf, GIT_CAP_REPORT_STATUS); + git_str_putc(buf, ' '); + git_str_printf(buf, GIT_CAP_REPORT_STATUS); } - git_buf_putc(buf, ' '); - git_buf_printf(buf, GIT_CAP_SIDE_BAND_64K); + git_str_putc(buf, ' '); + git_str_printf(buf, GIT_CAP_SIDE_BAND_64K); } - git_buf_putc(buf, '\n'); + git_str_putc(buf, '\n'); } - git_buf_puts(buf, "0000"); - return git_buf_oom(buf) ? -1 : 0; + git_str_puts(buf, "0000"); + return git_str_oom(buf) ? -1 : 0; } static int add_push_report_pkt(git_push *push, git_pkt *pkt) @@ -707,7 +707,7 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt) return 0; } -static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_buf *data_pkt_buf) +static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_str *data_pkt_buf) { git_pkt *pkt; const char *line, *line_end = NULL; @@ -718,7 +718,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, if (reading_from_buf) { /* We had an existing partial packet, so add the new * packet to the buffer and parse the whole thing */ - git_buf_put(data_pkt_buf, data_pkt->data, data_pkt->len); + git_str_put(data_pkt_buf, data_pkt->data, data_pkt->len); line = data_pkt_buf->ptr; line_len = data_pkt_buf->size; } @@ -734,7 +734,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, /* Buffer the data when the inner packet is split * across multiple sideband packets */ if (!reading_from_buf) - git_buf_put(data_pkt_buf, line, line_len); + git_str_put(data_pkt_buf, line, line_len); error = 0; goto done; } @@ -757,7 +757,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, done: if (reading_from_buf) - git_buf_consume(data_pkt_buf, line_end); + git_str_consume(data_pkt_buf, line_end); return error; } @@ -767,7 +767,7 @@ static int parse_report(transport_smart *transport, git_push *push) const char *line_end = NULL; gitno_buffer *buf = &transport->buffer; int error, recvd; - git_buf data_pkt_buf = GIT_BUF_INIT; + git_str data_pkt_buf = GIT_STR_INIT; for (;;) { if (buf->offset > 0) @@ -847,7 +847,7 @@ static int parse_report(transport_smart *transport, git_push *push) } } done: - git_buf_dispose(&data_pkt_buf); + git_str_dispose(&data_pkt_buf); return error; } @@ -991,7 +991,7 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c { transport_smart *t = (transport_smart *)transport; struct push_packbuilder_payload packbuilder_payload = {0}; - git_buf pktline = GIT_BUF_INIT; + git_str pktline = GIT_STR_INIT; int error = 0, need_pack = 0; push_spec *spec; unsigned int i; @@ -1036,7 +1036,7 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c if ((error = git_smart__get_push_stream(t, &packbuilder_payload.stream)) < 0 || (error = gen_pktline(&pktline, push)) < 0 || - (error = packbuilder_payload.stream->write(packbuilder_payload.stream, git_buf_cstr(&pktline), git_buf_len(&pktline))) < 0) + (error = packbuilder_payload.stream->write(packbuilder_payload.stream, git_str_cstr(&pktline), git_str_len(&pktline))) < 0) goto done; if (need_pack && @@ -1071,6 +1071,6 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c } done: - git_buf_dispose(&pktline); + git_str_dispose(&pktline); return error; } diff --git a/src/transports/ssh.c b/src/transports/ssh.c index 1b00be79c..e3bb5eef6 100644 --- a/src/transports/ssh.c +++ b/src/transports/ssh.c @@ -12,8 +12,6 @@ #endif #include "runtime.h" -#include "git2.h" -#include "buffer.h" #include "net.h" #include "netops.h" #include "smart.h" @@ -65,7 +63,7 @@ static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg) * * For example: git-upload-pack '/libgit2/libgit2' */ -static int gen_proto(git_buf *request, const char *cmd, const char *url) +static int gen_proto(git_str *request, const char *cmd, const char *url) { const char *repo; int len; @@ -94,13 +92,13 @@ done: len = strlen(cmd) + 1 /* Space */ + 1 /* Quote */ + strlen(repo) + 1 /* Quote */ + 1; - git_buf_grow(request, len); - git_buf_puts(request, cmd); - git_buf_puts(request, " '"); - git_buf_decode_percent(request, repo, strlen(repo)); - git_buf_puts(request, "'"); + git_str_grow(request, len); + git_str_puts(request, cmd); + git_str_puts(request, " '"); + git_str_decode_percent(request, repo, strlen(repo)); + git_str_puts(request, "'"); - if (git_buf_oom(request)) + if (git_str_oom(request)) return -1; return 0; @@ -109,7 +107,7 @@ done: static int send_command(ssh_stream *s) { int error; - git_buf request = GIT_BUF_INIT; + git_str request = GIT_STR_INIT; error = gen_proto(&request, s->cmd, s->url); if (error < 0) @@ -124,7 +122,7 @@ static int send_command(ssh_stream *s) s->sent_command = 1; cleanup: - git_buf_dispose(&request); + git_str_dispose(&request); return error; } @@ -580,7 +578,7 @@ post_extract: case LIBSSH2_HOSTKEY_TYPE_DSS: cert.raw_type = GIT_CERT_SSH_RAW_TYPE_DSS; break; - + #ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256 case LIBSSH2_HOSTKEY_TYPE_ECDSA_256: cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_256; @@ -592,7 +590,7 @@ post_extract: cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_521; break; #endif - + #ifdef LIBSSH2_HOSTKEY_TYPE_ED25519 case LIBSSH2_HOSTKEY_TYPE_ED25519: cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ED25519; diff --git a/src/transports/winhttp.c b/src/transports/winhttp.c index f4801a451..efbaf0298 100644 --- a/src/transports/winhttp.c +++ b/src/transports/winhttp.c @@ -11,8 +11,8 @@ #include "git2.h" #include "git2/transport.h" -#include "buffer.h" #include "posix.h" +#include "str.h" #include "netops.h" #include "smart.h" #include "remote.h" @@ -372,7 +372,7 @@ static int apply_credentials( static int winhttp_stream_connect(winhttp_stream *s) { winhttp_subtransport *t = OWNING_SUBTRANSPORT(s); - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; char *proxy_url = NULL; wchar_t ct[MAX_CONTENT_TYPE_LEN]; LPCWSTR types[] = { L"*/*", NULL }; @@ -391,13 +391,13 @@ static int winhttp_stream_connect(winhttp_stream *s) if ((git__suffixcmp(t->server.url.path, "/") == 0) && (git__prefixcmp(service_url, "/") == 0)) service_url++; /* Prepare URL */ - git_buf_printf(&buf, "%s%s", t->server.url.path, service_url); + git_str_printf(&buf, "%s%s", t->server.url.path, service_url); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; /* Convert URL to wide characters */ - if (git__utf8_to_16_alloc(&s->request_uri, git_buf_cstr(&buf)) < 0) { + if (git__utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert string to wide form"); goto on_error; } @@ -438,7 +438,7 @@ static int winhttp_stream_connect(winhttp_stream *s) } if (proxy_url) { - git_buf processed_url = GIT_BUF_INIT; + git_str processed_url = GIT_STR_INIT; WINHTTP_PROXY_INFO proxy_info; wchar_t *proxy_wide; @@ -453,28 +453,28 @@ static int winhttp_stream_connect(winhttp_stream *s) goto on_error; } - git_buf_puts(&processed_url, t->proxy.url.scheme); - git_buf_PUTS(&processed_url, "://"); + git_str_puts(&processed_url, t->proxy.url.scheme); + git_str_PUTS(&processed_url, "://"); if (git_net_url_is_ipv6(&t->proxy.url)) - git_buf_putc(&processed_url, '['); + git_str_putc(&processed_url, '['); - git_buf_puts(&processed_url, t->proxy.url.host); + git_str_puts(&processed_url, t->proxy.url.host); if (git_net_url_is_ipv6(&t->proxy.url)) - git_buf_putc(&processed_url, ']'); + git_str_putc(&processed_url, ']'); if (!git_net_url_is_default_port(&t->proxy.url)) - git_buf_printf(&processed_url, ":%s", t->proxy.url.port); + git_str_printf(&processed_url, ":%s", t->proxy.url.port); - if (git_buf_oom(&processed_url)) { + if (git_str_oom(&processed_url)) { error = -1; goto on_error; } /* Convert URL to wide characters */ error = git__utf8_to_16_alloc(&proxy_wide, processed_url.ptr); - git_buf_dispose(&processed_url); + git_str_dispose(&processed_url); if (error < 0) goto on_error; @@ -525,13 +525,13 @@ static int winhttp_stream_connect(winhttp_stream *s) if (post_verb == s->verb) { /* Send Content-Type and Accept headers -- only necessary on a POST */ - git_buf_clear(&buf); - if (git_buf_printf(&buf, + git_str_clear(&buf); + if (git_str_printf(&buf, "Content-Type: application/x-git-%s-request", s->service) < 0) goto on_error; - if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf)) < 0) { + if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert content-type to wide characters"); goto on_error; } @@ -542,13 +542,13 @@ static int winhttp_stream_connect(winhttp_stream *s) goto on_error; } - git_buf_clear(&buf); - if (git_buf_printf(&buf, + git_str_clear(&buf); + if (git_str_printf(&buf, "Accept: application/x-git-%s-result", s->service) < 0) goto on_error; - if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf)) < 0) { + if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert accept header to wide characters"); goto on_error; } @@ -562,9 +562,9 @@ static int winhttp_stream_connect(winhttp_stream *s) for (i = 0; i < t->owner->custom_headers.count; i++) { if (t->owner->custom_headers.strings[i]) { - git_buf_clear(&buf); - git_buf_puts(&buf, t->owner->custom_headers.strings[i]); - if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf)) < 0) { + git_str_clear(&buf); + git_str_puts(&buf, t->owner->custom_headers.strings[i]); + if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) { git_error_set(GIT_ERROR_OS, "failed to convert custom header to wide characters"); goto on_error; } @@ -597,7 +597,7 @@ on_error: winhttp_stream_close(s); git__free(proxy_url); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } @@ -646,23 +646,23 @@ static int parse_unauthorized_response( static int write_chunk(HINTERNET request, const char *buffer, size_t len) { DWORD bytes_written; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; /* Chunk header */ - git_buf_printf(&buf, "%"PRIXZ"\r\n", len); + git_str_printf(&buf, "%"PRIXZ"\r\n", len); - if (git_buf_oom(&buf)) + if (git_str_oom(&buf)) return -1; if (!WinHttpWriteData(request, - git_buf_cstr(&buf), (DWORD)git_buf_len(&buf), + git_str_cstr(&buf), (DWORD)git_str_len(&buf), &bytes_written)) { - git_buf_dispose(&buf); + git_str_dispose(&buf); git_error_set(GIT_ERROR_OS, "failed to write chunk header"); return -1; } - git_buf_dispose(&buf); + git_str_dispose(&buf); /* Chunk body */ if (!WinHttpWriteData(request, @@ -756,7 +756,7 @@ static int winhttp_connect( wchar_t *wide_host = NULL; int32_t port; wchar_t *wide_ua = NULL; - git_buf ipv6 = GIT_BUF_INIT, ua = GIT_BUF_INIT; + git_str ipv6 = GIT_STR_INIT, ua = GIT_STR_INIT; const char *host; int error = -1; int default_timeout = TIMEOUT_INFINITE; @@ -777,7 +777,7 @@ static int winhttp_connect( /* IPv6? Add braces around the host. */ if (git_net_url_is_ipv6(&t->server.url)) { - if (git_buf_printf(&ipv6, "[%s]", t->server.url.host) < 0) + if (git_str_printf(&ipv6, "[%s]", t->server.url.host) < 0) goto on_error; host = ipv6.ptr; @@ -795,7 +795,7 @@ static int winhttp_connect( if (git_http__user_agent(&ua) < 0) goto on_error; - if (git__utf8_to_16_alloc(&wide_ua, git_buf_cstr(&ua)) < 0) { + if (git__utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) { git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters"); goto on_error; } @@ -863,8 +863,8 @@ on_error: if (error < 0) winhttp_close_connection(t); - git_buf_dispose(&ua); - git_buf_dispose(&ipv6); + git_str_dispose(&ua); + git_str_dispose(&ipv6); git__free(wide_host); git__free(wide_ua); diff --git a/src/tree-cache.c b/src/tree-cache.c index 04d86fd36..0977c92f3 100644 --- a/src/tree-cache.c +++ b/src/tree-cache.c @@ -256,22 +256,22 @@ int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool) return 0; } -static void write_tree(git_buf *out, git_tree_cache *tree) +static void write_tree(git_str *out, git_tree_cache *tree) { size_t i; - git_buf_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count); + git_str_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count); if (tree->entry_count != -1) - git_buf_put(out, (const char *) &tree->oid, GIT_OID_RAWSZ); + git_str_put(out, (const char *) &tree->oid, GIT_OID_RAWSZ); for (i = 0; i < tree->children_count; i++) write_tree(out, tree->children[i]); } -int git_tree_cache_write(git_buf *out, git_tree_cache *tree) +int git_tree_cache_write(git_str *out, git_tree_cache *tree) { write_tree(out, tree); - return git_buf_oom(out) ? -1 : 0; + return git_str_oom(out) ? -1 : 0; } diff --git a/src/tree-cache.h b/src/tree-cache.h index e02300e6e..a27e30466 100644 --- a/src/tree-cache.h +++ b/src/tree-cache.h @@ -11,7 +11,7 @@ #include "common.h" #include "pool.h" -#include "buffer.h" +#include "str.h" #include "git2/oid.h" typedef struct git_tree_cache { @@ -24,7 +24,7 @@ typedef struct git_tree_cache { char name[GIT_FLEX_ARRAY]; } git_tree_cache; -int git_tree_cache_write(git_buf *out, git_tree_cache *tree); +int git_tree_cache_write(git_str *out, git_tree_cache *tree); int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool); void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path); const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path); diff --git a/src/tree.c b/src/tree.c index b1df79eac..c1e39158d 100644 --- a/src/tree.c +++ b/src/tree.c @@ -495,7 +495,7 @@ static int check_entry(git_repository *repo, const char *filename, const git_oid static int git_treebuilder__write_with_buffer( git_oid *oid, git_treebuilder *bld, - git_buf *buf) + git_str *buf) { int error = 0; size_t i, entrycount; @@ -503,14 +503,14 @@ static int git_treebuilder__write_with_buffer( git_tree_entry *entry; git_vector entries = GIT_VECTOR_INIT; - git_buf_clear(buf); + git_str_clear(buf); entrycount = git_strmap_size(bld->map); if ((error = git_vector_init(&entries, entrycount, entry_sort_cmp)) < 0) goto out; if (buf->asize == 0 && - (error = git_buf_grow(buf, entrycount * 72)) < 0) + (error = git_str_grow(buf, entrycount * 72)) < 0) goto out; git_strmap_foreach_value(bld->map, entry, { @@ -523,11 +523,11 @@ static int git_treebuilder__write_with_buffer( for (i = 0; i < entries.length && !error; ++i) { entry = git_vector_get(&entries, i); - git_buf_printf(buf, "%o ", entry->attr); - git_buf_put(buf, entry->filename, entry->filename_len + 1); - git_buf_put(buf, (char *)entry->oid->id, GIT_OID_RAWSZ); + git_str_printf(buf, "%o ", entry->attr); + git_str_put(buf, entry->filename, entry->filename_len + 1); + git_str_put(buf, (char *)entry->oid->id, GIT_OID_RAWSZ); - if (git_buf_oom(buf)) { + if (git_str_oom(buf)) { error = -1; goto out; } @@ -575,7 +575,7 @@ static int write_tree( git_index *index, const char *dirname, size_t start, - git_buf *shared_buf) + git_str *shared_buf) { git_treebuilder *bld = NULL; size_t i, entries = git_index_entrycount(index); @@ -676,7 +676,7 @@ int git_tree__write_index( { int ret; git_tree *tree; - git_buf shared_buf = GIT_BUF_INIT; + git_str shared_buf = GIT_STR_INIT; bool old_ignore_case = false; GIT_ASSERT_ARG(oid); @@ -705,7 +705,7 @@ int git_tree__write_index( } ret = write_tree(oid, repo, index, "", 0, &shared_buf); - git_buf_dispose(&shared_buf); + git_str_dispose(&shared_buf); if (old_ignore_case) git_index__set_ignore_case(index, true); @@ -879,7 +879,7 @@ void git_treebuilder_free(git_treebuilder *bld) if (bld == NULL) return; - git_buf_dispose(&bld->write_cache); + git_str_dispose(&bld->write_cache); git_treebuilder_clear(bld); git_strmap_free(bld->map); git__free(bld); @@ -959,7 +959,7 @@ int git_tree_entry_bypath( static int tree_walk( const git_tree *tree, git_treewalk_cb callback, - git_buf *path, + git_str *path, void *payload, bool preorder) { @@ -982,17 +982,17 @@ static int tree_walk( if (git_tree_entry__is_tree(entry)) { git_tree *subtree; - size_t path_len = git_buf_len(path); + size_t path_len = git_str_len(path); error = git_tree_lookup(&subtree, tree->object.repo, entry->oid); if (error < 0) break; /* append the next entry to the path */ - git_buf_puts(path, entry->filename); - git_buf_putc(path, '/'); + git_str_puts(path, entry->filename); + git_str_putc(path, '/'); - if (git_buf_oom(path)) + if (git_str_oom(path)) error = -1; else error = tree_walk(subtree, callback, path, payload, preorder); @@ -1001,7 +1001,7 @@ static int tree_walk( if (error != 0) break; - git_buf_truncate(path, path_len); + git_str_truncate(path, path_len); } if (!preorder) { @@ -1024,7 +1024,7 @@ int git_tree_walk( void *payload) { int error = 0; - git_buf root_path = GIT_BUF_INIT; + git_str root_path = GIT_STR_INIT; if (mode != GIT_TREEWALK_POST && mode != GIT_TREEWALK_PRE) { git_error_set(GIT_ERROR_INVALID, "invalid walking mode for tree walk"); @@ -1034,7 +1034,7 @@ int git_tree_walk( error = tree_walk( tree, callback, &root_path, payload, (mode == GIT_TREEWALK_PRE)); - git_buf_dispose(&root_path); + git_str_dispose(&root_path); return error; } @@ -1080,19 +1080,19 @@ GIT_INLINE(size_t) count_slashes(const char *path) return count; } -static bool next_component(git_buf *out, const char *in) +static bool next_component(git_str *out, const char *in) { const char *slash = strchr(in, '/'); - git_buf_clear(out); + git_str_clear(out); if (slash) - git_buf_put(out, in, slash - in); + git_str_put(out, in, slash - in); return !!slash; } -static int create_popped_tree(tree_stack_entry *current, tree_stack_entry *popped, git_buf *component) +static int create_popped_tree(tree_stack_entry *current, tree_stack_entry *popped, git_str *component) { int error; git_oid new_tree; @@ -1116,8 +1116,8 @@ static int create_popped_tree(tree_stack_entry *current, tree_stack_entry *poppe } /* We've written out the tree, now we have to put the new value into its parent */ - git_buf_clear(component); - git_buf_puts(component, popped->name); + git_str_clear(component); + git_str_puts(component, popped->name); git__free(popped->name); GIT_ERROR_CHECK_ALLOC(component->ptr); @@ -1142,7 +1142,7 @@ int git_tree_create_updated(git_oid *out, git_repository *repo, git_tree *baseli git_vector entries; int error; size_t i; - git_buf component = GIT_BUF_INIT; + git_str component = GIT_STR_INIT; if ((error = git_vector_init(&entries, nupdates, compare_entries)) < 0) return error; @@ -1300,7 +1300,7 @@ cleanup: } } - git_buf_dispose(&component); + git_str_dispose(&component); git_array_clear(stack); git_vector_free(&entries); return error; diff --git a/src/tree.h b/src/tree.h index 2f3027b5a..6bd9ed652 100644 --- a/src/tree.h +++ b/src/tree.h @@ -32,7 +32,7 @@ struct git_tree { struct git_treebuilder { git_repository *repo; git_strmap *map; - git_buf write_cache; + git_str write_cache; }; GIT_INLINE(bool) git_tree_entry__is_tree(const struct git_tree_entry *e) diff --git a/src/util.c b/src/util.c index 9b0c45ce8..2b1dadfe8 100644 --- a/src/util.c +++ b/src/util.c @@ -735,13 +735,13 @@ void git__qsort_r( } #ifdef GIT_WIN32 -int git__getenv(git_buf *out, const char *name) +int git__getenv(git_str *out, const char *name) { wchar_t *wide_name = NULL, *wide_value = NULL; DWORD value_len; int error = -1; - git_buf_clear(out); + git_str_clear(out); if (git__utf8_to_16_alloc(&wide_name, name) < 0) return -1; @@ -754,7 +754,7 @@ int git__getenv(git_buf *out, const char *name) } if (value_len) - error = git_buf_put_w(out, wide_value, value_len); + error = git_str_put_w(out, wide_value, value_len); else if (GetLastError() == ERROR_SUCCESS || GetLastError() == ERROR_ENVVAR_NOT_FOUND) error = GIT_ENOTFOUND; else @@ -765,16 +765,16 @@ int git__getenv(git_buf *out, const char *name) return error; } #else -int git__getenv(git_buf *out, const char *name) +int git__getenv(git_str *out, const char *name) { const char *val = getenv(name); - git_buf_clear(out); + git_str_clear(out); if (!val) return GIT_ENOTFOUND; - return git_buf_puts(out, val); + return git_str_puts(out, val); } #endif diff --git a/src/util.h b/src/util.h index e8074fcb9..30cdd0ddf 100644 --- a/src/util.h +++ b/src/util.h @@ -7,15 +7,11 @@ #ifndef INCLUDE_util_h__ #define INCLUDE_util_h__ -#include "common.h" - #ifndef GIT_WIN32 # include <ctype.h> #endif -#include "git2/buffer.h" - -#include "buffer.h" +#include "str.h" #include "common.h" #include "strnlen.h" #include "thread.h" @@ -402,7 +398,7 @@ GIT_INLINE(double) git__timer(void) #endif -extern int git__getenv(git_buf *out, const char *name); +extern int git__getenv(git_str *out, const char *name); extern int git__online_cpus(void); diff --git a/src/win32/findfile.c b/src/win32/findfile.c index 40d2d518a..caa79398a 100644 --- a/src/win32/findfile.c +++ b/src/win32/findfile.c @@ -34,7 +34,7 @@ static int git_win32__expand_path(_findfile_path *dest, const wchar_t *src) return 0; } -static int win32_path_to_8(git_buf *dest, const wchar_t *src) +static int win32_path_to_8(git_str *dest, const wchar_t *src) { git_win32_utf8_path utf8_path; @@ -46,7 +46,7 @@ static int win32_path_to_8(git_buf *dest, const wchar_t *src) /* Convert backslashes to forward slashes */ git_path_mkposix(utf8_path); - return git_buf_sets(dest, utf8_path); + return git_str_sets(dest, utf8_path); } static wchar_t *win32_walkpath(wchar_t *path, wchar_t *buf, size_t buflen) @@ -70,7 +70,7 @@ static wchar_t *win32_walkpath(wchar_t *path, wchar_t *buf, size_t buflen) return (path != base) ? path : NULL; } -static int win32_find_git_in_path(git_buf *buf, const wchar_t *gitexe, const wchar_t *subdir) +static int win32_find_git_in_path(git_str *buf, const wchar_t *gitexe, const wchar_t *subdir) { wchar_t *env = _wgetenv(L"PATH"), lastch; _findfile_path root; @@ -106,7 +106,7 @@ static int win32_find_git_in_path(git_buf *buf, const wchar_t *gitexe, const wch } static int win32_find_git_in_registry( - git_buf *buf, const HKEY hive, const wchar_t *key, const wchar_t *subdir) + git_str *buf, const HKEY hive, const wchar_t *key, const wchar_t *subdir) { HKEY hKey; int error = GIT_ENOTFOUND; @@ -141,12 +141,12 @@ static int win32_find_git_in_registry( } static int win32_find_existing_dirs( - git_buf *out, const wchar_t *tmpl[]) + git_str *out, const wchar_t *tmpl[]) { _findfile_path path16; - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; - git_buf_clear(out); + git_str_clear(out); for (; *tmpl != NULL; tmpl++) { if (!git_win32__expand_path(&path16, *tmpl) && @@ -156,43 +156,43 @@ static int win32_find_existing_dirs( win32_path_to_8(&buf, path16.path); if (buf.size) - git_buf_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); } } - git_buf_dispose(&buf); + git_str_dispose(&buf); - return (git_buf_oom(out) ? -1 : 0); + return (git_str_oom(out) ? -1 : 0); } -int git_win32__find_system_dirs(git_buf *out, const wchar_t *subdir) +int git_win32__find_system_dirs(git_str *out, const wchar_t *subdir) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; /* directories where git.exe & git.cmd are found */ if (!win32_find_git_in_path(&buf, L"git.exe", subdir) && buf.size) - git_buf_set(out, buf.ptr, buf.size); + git_str_set(out, buf.ptr, buf.size); else - git_buf_clear(out); + git_str_clear(out); if (!win32_find_git_in_path(&buf, L"git.cmd", subdir) && buf.size) - git_buf_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); /* directories where git is installed according to registry */ if (!win32_find_git_in_registry( &buf, HKEY_CURRENT_USER, REG_MSYSGIT_INSTALL_LOCAL, subdir) && buf.size) - git_buf_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); if (!win32_find_git_in_registry( &buf, HKEY_LOCAL_MACHINE, REG_MSYSGIT_INSTALL, subdir) && buf.size) - git_buf_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); + git_str_join(out, GIT_PATH_LIST_SEPARATOR, out->ptr, buf.ptr); - git_buf_dispose(&buf); + git_str_dispose(&buf); - return (git_buf_oom(out) ? -1 : 0); + return (git_str_oom(out) ? -1 : 0); } -int git_win32__find_global_dirs(git_buf *out) +int git_win32__find_global_dirs(git_str *out) { static const wchar_t *global_tmpls[4] = { L"%HOME%\\", @@ -204,7 +204,7 @@ int git_win32__find_global_dirs(git_buf *out) return win32_find_existing_dirs(out, global_tmpls); } -int git_win32__find_xdg_dirs(git_buf *out) +int git_win32__find_xdg_dirs(git_str *out) { static const wchar_t *global_tmpls[7] = { L"%XDG_CONFIG_HOME%\\git", @@ -219,7 +219,7 @@ int git_win32__find_xdg_dirs(git_buf *out) return win32_find_existing_dirs(out, global_tmpls); } -int git_win32__find_programdata_dirs(git_buf *out) +int git_win32__find_programdata_dirs(git_str *out) { static const wchar_t *programdata_tmpls[2] = { L"%PROGRAMDATA%\\Git", diff --git a/src/win32/findfile.h b/src/win32/findfile.h index e7bcf948a..e11ccebc5 100644 --- a/src/win32/findfile.h +++ b/src/win32/findfile.h @@ -10,10 +10,10 @@ #include "common.h" -extern int git_win32__find_system_dirs(git_buf *out, const wchar_t *subpath); -extern int git_win32__find_global_dirs(git_buf *out); -extern int git_win32__find_xdg_dirs(git_buf *out); -extern int git_win32__find_programdata_dirs(git_buf *out); +extern int git_win32__find_system_dirs(git_str *out, const wchar_t *subpath); +extern int git_win32__find_global_dirs(git_str *out); +extern int git_win32__find_xdg_dirs(git_str *out); +extern int git_win32__find_programdata_dirs(git_str *out); #endif diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c index 8af07e6fa..f26983d97 100644 --- a/src/win32/posix_w32.c +++ b/src/win32/posix_w32.c @@ -14,7 +14,6 @@ #include "utf-conv.h" #include "repository.h" #include "reparse.h" -#include "buffer.h" #include <errno.h> #include <io.h> #include <fcntl.h> @@ -415,7 +414,7 @@ int p_readlink(const char *path, char *buf, size_t bufsiz) static bool target_is_dir(const char *target, const char *path) { - git_buf resolved = GIT_BUF_INIT; + git_str resolved = GIT_STR_INIT; git_win32_path resolved_w; bool isdir = true; @@ -429,7 +428,7 @@ static bool target_is_dir(const char *target, const char *path) isdir = GetFileAttributesW(resolved_w) & FILE_ATTRIBUTE_DIRECTORY; out: - git_buf_dispose(&resolved); + git_str_dispose(&resolved); return isdir; } @@ -1003,7 +1002,7 @@ ssize_t p_pread(int fd, void *data, size_t size, off64_t offset) /* Fail if the final offset would have overflowed to match POSIX semantics. */ if (!git__is_ssizet(size) || git__add_int64_overflow(&final_offset, offset, (int64_t)size)) { errno = EINVAL; - return -1; + return -1; } /* @@ -1038,7 +1037,7 @@ ssize_t p_pwrite(int fd, const void *data, size_t size, off64_t offset) /* Fail if the final offset would have overflowed to match POSIX semantics. */ if (!git__is_ssizet(size) || git__add_int64_overflow(&final_offset, offset, (int64_t)size)) { errno = EINVAL; - return -1; + return -1; } /* diff --git a/src/win32/w32_buffer.c b/src/win32/w32_buffer.c index f270a1e6a..6fee8203c 100644 --- a/src/win32/w32_buffer.c +++ b/src/win32/w32_buffer.c @@ -7,7 +7,6 @@ #include "w32_buffer.h" -#include "../buffer.h" #include "utf-conv.h" GIT_INLINE(int) handle_wc_error(void) @@ -20,7 +19,7 @@ GIT_INLINE(int) handle_wc_error(void) return -1; } -int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w) +int git_str_put_w(git_str *buf, const wchar_t *string_w, size_t len_w) { int utf8_len, utf8_write_len; size_t new_size; @@ -43,7 +42,7 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w) GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, (size_t)utf8_len); GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1); - if (git_buf_grow(buf, new_size) < 0) + if (git_str_grow(buf, new_size) < 0) return -1; if ((utf8_write_len = WideCharToMultiByte( diff --git a/src/win32/w32_buffer.h b/src/win32/w32_buffer.h index 43298e4a7..4227296d8 100644 --- a/src/win32/w32_buffer.h +++ b/src/win32/w32_buffer.h @@ -8,13 +8,12 @@ #define INCLUDE_win32_w32_buffer_h__ #include "common.h" - -#include "../buffer.h" +#include "str.h" /** * Convert a wide character string to UTF-8 and append the results to the * buffer. */ -int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w); +int git_str_put_w(git_str *buf, const wchar_t *string_w, size_t len_w); #endif diff --git a/src/worktree.c b/src/worktree.c index fe8db7743..92a0900b0 100644 --- a/src/worktree.c +++ b/src/worktree.c @@ -7,32 +7,33 @@ #include "worktree.h" +#include "buf.h" +#include "repository.h" + #include "git2/branch.h" #include "git2/commit.h" #include "git2/worktree.h" -#include "repository.h" - static bool is_worktree_dir(const char *dir) { - git_buf buf = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT; int error; - if (git_buf_sets(&buf, dir) < 0) + if (git_str_sets(&buf, dir) < 0) return -1; error = git_path_contains_file(&buf, "commondir") && git_path_contains_file(&buf, "gitdir") && git_path_contains_file(&buf, "HEAD"); - git_buf_dispose(&buf); + git_str_dispose(&buf); return error; } int git_worktree_list(git_strarray *wts, git_repository *repo) { git_vector worktrees = GIT_VECTOR_INIT; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; char *worktree; size_t i, len; int error; @@ -43,7 +44,7 @@ int git_worktree_list(git_strarray *wts, git_repository *repo) wts->count = 0; wts->strings = NULL; - if ((error = git_buf_joinpath(&path, repo->commondir, "worktrees/")) < 0) + if ((error = git_str_joinpath(&path, repo->commondir, "worktrees/")) < 0) goto exit; if (!git_path_exists(path.ptr) || git_path_is_empty_dir(path.ptr)) goto exit; @@ -53,8 +54,8 @@ int git_worktree_list(git_strarray *wts, git_repository *repo) len = path.size; git_vector_foreach(&worktrees, i, worktree) { - git_buf_truncate(&path, len); - git_buf_puts(&path, worktree); + git_str_truncate(&path, len); + git_str_puts(&path, worktree); if (!is_worktree_dir(path.ptr)) { git_vector_remove(&worktrees, i); @@ -65,68 +66,68 @@ int git_worktree_list(git_strarray *wts, git_repository *repo) wts->strings = (char **)git_vector_detach(&wts->count, NULL, &worktrees); exit: - git_buf_dispose(&path); + git_str_dispose(&path); return error; } char *git_worktree__read_link(const char *base, const char *file) { - git_buf path = GIT_BUF_INIT, buf = GIT_BUF_INIT; + git_str path = GIT_STR_INIT, buf = GIT_STR_INIT; GIT_ASSERT_ARG_WITH_RETVAL(base, NULL); GIT_ASSERT_ARG_WITH_RETVAL(file, NULL); - if (git_buf_joinpath(&path, base, file) < 0) + if (git_str_joinpath(&path, base, file) < 0) goto err; if (git_futils_readbuffer(&buf, path.ptr) < 0) goto err; - git_buf_dispose(&path); + git_str_dispose(&path); - git_buf_rtrim(&buf); + git_str_rtrim(&buf); if (!git_path_is_relative(buf.ptr)) - return git_buf_detach(&buf); + return git_str_detach(&buf); - if (git_buf_sets(&path, base) < 0) + if (git_str_sets(&path, base) < 0) goto err; if (git_path_apply_relative(&path, buf.ptr) < 0) goto err; - git_buf_dispose(&buf); + git_str_dispose(&buf); - return git_buf_detach(&path); + return git_str_detach(&path); err: - git_buf_dispose(&buf); - git_buf_dispose(&path); + git_str_dispose(&buf); + git_str_dispose(&path); return NULL; } -static int write_wtfile(const char *base, const char *file, const git_buf *buf) +static int write_wtfile(const char *base, const char *file, const git_str *buf) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int err; GIT_ASSERT_ARG(base); GIT_ASSERT_ARG(file); GIT_ASSERT_ARG(buf); - if ((err = git_buf_joinpath(&path, base, file)) < 0) + if ((err = git_str_joinpath(&path, base, file)) < 0) goto out; if ((err = git_futils_writebuffer(buf, path.ptr, O_CREAT|O_EXCL|O_WRONLY, 0644)) < 0) goto out; out: - git_buf_dispose(&path); + git_str_dispose(&path); return err; } static int open_worktree_dir(git_worktree **out, const char *parent, const char *dir, const char *name) { - git_buf gitdir = GIT_BUF_INIT; + git_str gitdir = GIT_STR_INIT; git_worktree *wt = NULL; int error = 0; @@ -154,7 +155,7 @@ static int open_worktree_dir(git_worktree **out, const char *parent, const char if ((error = git_path_prettify_dir(&gitdir, dir, NULL)) < 0) goto out; - wt->gitdir_path = git_buf_detach(&gitdir); + wt->gitdir_path = git_str_detach(&gitdir); if ((error = git_worktree_is_locked(NULL, wt)) < 0) goto out; @@ -166,14 +167,14 @@ static int open_worktree_dir(git_worktree **out, const char *parent, const char out: if (error) git_worktree_free(wt); - git_buf_dispose(&gitdir); + git_str_dispose(&gitdir); return error; } int git_worktree_lookup(git_worktree **out, git_repository *repo, const char *name) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; git_worktree *wt = NULL; int error; @@ -182,14 +183,14 @@ int git_worktree_lookup(git_worktree **out, git_repository *repo, const char *na *out = NULL; - if ((error = git_buf_join3(&path, '/', repo->commondir, "worktrees", name)) < 0) + if ((error = git_str_join3(&path, '/', repo->commondir, "worktrees", name)) < 0) goto out; if ((error = (open_worktree_dir(out, git_repository_workdir(repo), path.ptr, name))) < 0) goto out; out: - git_buf_dispose(&path); + git_str_dispose(&path); if (error) git_worktree_free(wt); @@ -199,7 +200,7 @@ out: int git_worktree_open_from_repository(git_worktree **out, git_repository *repo) { - git_buf parent = GIT_BUF_INIT; + git_str parent = GIT_STR_INIT; const char *gitdir, *commondir; char *name = NULL; int error = 0; @@ -224,7 +225,7 @@ int git_worktree_open_from_repository(git_worktree **out, git_repository *repo) out: git__free(name); - git_buf_dispose(&parent); + git_str_dispose(&parent); return error; } @@ -298,7 +299,7 @@ int git_worktree_add(git_worktree **out, git_repository *repo, const char *name, const char *worktree, const git_worktree_add_options *opts) { - git_buf gitdir = GIT_BUF_INIT, wddir = GIT_BUF_INIT, buf = GIT_BUF_INIT; + git_str gitdir = GIT_STR_INIT, wddir = GIT_STR_INIT, buf = GIT_STR_INIT; git_reference *ref = NULL, *head = NULL; git_commit *commit = NULL; git_repository *wt = NULL; @@ -334,12 +335,12 @@ int git_worktree_add(git_worktree **out, git_repository *repo, } /* Create gitdir directory ".git/worktrees/<name>" */ - if ((err = git_buf_joinpath(&gitdir, repo->commondir, "worktrees")) < 0) + if ((err = git_str_joinpath(&gitdir, repo->commondir, "worktrees")) < 0) goto out; if (!git_path_exists(gitdir.ptr)) if ((err = git_futils_mkdir(gitdir.ptr, 0755, GIT_MKDIR_EXCL)) < 0) goto out; - if ((err = git_buf_joinpath(&gitdir, gitdir.ptr, name)) < 0) + if ((err = git_str_joinpath(&gitdir, gitdir.ptr, name)) < 0) goto out; if ((err = git_futils_mkdir(gitdir.ptr, 0755, GIT_MKDIR_EXCL)) < 0) goto out; @@ -355,7 +356,7 @@ int git_worktree_add(git_worktree **out, git_repository *repo, if (wtopts.lock) { int fd; - if ((err = git_buf_joinpath(&buf, gitdir.ptr, "locked")) < 0) + if ((err = git_str_joinpath(&buf, gitdir.ptr, "locked")) < 0) goto out; if ((fd = p_creat(buf.ptr, 0644)) < 0) { @@ -364,22 +365,22 @@ int git_worktree_add(git_worktree **out, git_repository *repo, } p_close(fd); - git_buf_clear(&buf); + git_str_clear(&buf); } /* Create worktree .git file */ - if ((err = git_buf_printf(&buf, "gitdir: %s\n", gitdir.ptr)) < 0) + if ((err = git_str_printf(&buf, "gitdir: %s\n", gitdir.ptr)) < 0) goto out; if ((err = write_wtfile(wddir.ptr, ".git", &buf)) < 0) goto out; /* Create gitdir files */ if ((err = git_path_prettify_dir(&buf, repo->commondir, NULL) < 0) - || (err = git_buf_putc(&buf, '\n')) < 0 + || (err = git_str_putc(&buf, '\n')) < 0 || (err = write_wtfile(gitdir.ptr, "commondir", &buf)) < 0) goto out; - if ((err = git_buf_joinpath(&buf, wddir.ptr, ".git")) < 0 - || (err = git_buf_putc(&buf, '\n')) < 0 + if ((err = git_str_joinpath(&buf, wddir.ptr, ".git")) < 0 + || (err = git_str_putc(&buf, '\n')) < 0 || (err = write_wtfile(gitdir.ptr, "gitdir", &buf)) < 0) goto out; @@ -412,9 +413,9 @@ int git_worktree_add(git_worktree **out, git_repository *repo, goto out; out: - git_buf_dispose(&gitdir); - git_buf_dispose(&wddir); - git_buf_dispose(&buf); + git_str_dispose(&gitdir); + git_str_dispose(&wddir); + git_str_dispose(&buf); git_reference_free(ref); git_reference_free(head); git_commit_free(commit); @@ -425,7 +426,7 @@ out: int git_worktree_lock(git_worktree *wt, const char *reason) { - git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT; + git_str buf = GIT_STR_INIT, path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(wt); @@ -437,11 +438,11 @@ int git_worktree_lock(git_worktree *wt, const char *reason) goto out; } - if ((error = git_buf_joinpath(&path, wt->gitdir_path, "locked")) < 0) + if ((error = git_str_joinpath(&path, wt->gitdir_path, "locked")) < 0) goto out; if (reason) - git_buf_attach_notowned(&buf, reason, strlen(reason)); + git_str_attach_notowned(&buf, reason, strlen(reason)); if ((error = git_futils_writebuffer(&buf, path.ptr, O_CREAT|O_EXCL|O_WRONLY, 0644)) < 0) goto out; @@ -449,14 +450,14 @@ int git_worktree_lock(git_worktree *wt, const char *reason) wt->locked = 1; out: - git_buf_dispose(&path); + git_str_dispose(&path); return error; } int git_worktree_unlock(git_worktree *wt) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error; GIT_ASSERT_ARG(wt); @@ -466,32 +467,32 @@ int git_worktree_unlock(git_worktree *wt) if (!error) return 1; - if (git_buf_joinpath(&path, wt->gitdir_path, "locked") < 0) + if (git_str_joinpath(&path, wt->gitdir_path, "locked") < 0) return -1; if (p_unlink(path.ptr) != 0) { - git_buf_dispose(&path); + git_str_dispose(&path); return -1; } wt->locked = 0; - git_buf_dispose(&path); + git_str_dispose(&path); return 0; } -int git_worktree_is_locked(git_buf *reason, const git_worktree *wt) +static int git_worktree__is_locked(git_str *reason, const git_worktree *wt) { - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; int error, locked; GIT_ASSERT_ARG(wt); if (reason) - git_buf_clear(reason); + git_str_clear(reason); - if ((error = git_buf_joinpath(&path, wt->gitdir_path, "locked")) < 0) + if ((error = git_str_joinpath(&path, wt->gitdir_path, "locked")) < 0) goto out; locked = git_path_exists(path.ptr); if (locked && reason && @@ -500,8 +501,27 @@ int git_worktree_is_locked(git_buf *reason, const git_worktree *wt) error = locked; out: - git_buf_dispose(&path); + git_str_dispose(&path); + + return error; +} + +int git_worktree_is_locked(git_buf *reason, const git_worktree *wt) +{ + git_str str = GIT_STR_INIT; + int error = 0; + + if (reason && (error = git_buf_tostr(&str, reason)) < 0) + return error; + + error = git_worktree__is_locked(reason ? &str : NULL, wt); + + if (error >= 0 && reason) { + if (git_buf_fromstr(reason, &str) < 0) + error = -1; + } + git_str_dispose(&str); return error; } @@ -547,17 +567,17 @@ int git_worktree_is_prunable(git_worktree *wt, memcpy(&popts, opts, sizeof(popts)); if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) { - git_buf reason = GIT_BUF_INIT; + git_str reason = GIT_STR_INIT; int error; - if ((error = git_worktree_is_locked(&reason, wt)) < 0) + if ((error = git_worktree__is_locked(&reason, wt)) < 0) return error; if (error) { if (!reason.size) - git_buf_attach_notowned(&reason, "no reason given", 15); + git_str_attach_notowned(&reason, "no reason given", 15); git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr); - git_buf_dispose(&reason); + git_str_dispose(&reason); return 0; } } @@ -575,7 +595,7 @@ int git_worktree_prune(git_worktree *wt, git_worktree_prune_options *opts) { git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT; - git_buf path = GIT_BUF_INIT; + git_str path = GIT_STR_INIT; char *wtpath; int err; @@ -592,7 +612,7 @@ int git_worktree_prune(git_worktree *wt, } /* Delete gitdir in parent repository */ - if ((err = git_buf_join3(&path, '/', wt->commondir_path, "worktrees", wt->name)) < 0) + if ((err = git_str_join3(&path, '/', wt->commondir_path, "worktrees", wt->name)) < 0) goto out; if (!git_path_exists(path.ptr)) { @@ -613,7 +633,7 @@ int git_worktree_prune(git_worktree *wt, if ((wtpath = git_path_dirname(wt->gitlink_path)) == NULL) goto out; - git_buf_attach(&path, wtpath, 0); + git_str_attach(&path, wtpath, 0); if (!git_path_exists(path.ptr)) { git_error_set(GIT_ERROR_WORKTREE, "working tree '%s' does not exist", path.ptr); @@ -624,7 +644,7 @@ int git_worktree_prune(git_worktree *wt, goto out; out: - git_buf_dispose(&path); + git_str_dispose(&path); return err; } diff --git a/src/zstream.c b/src/zstream.c index a5675676e..cb8b125ed 100644 --- a/src/zstream.c +++ b/src/zstream.c @@ -9,7 +9,7 @@ #include <zlib.h> -#include "buffer.h" +#include "str.h" #define ZSTREAM_BUFFER_SIZE (1024 * 1024) #define ZSTREAM_BUFFER_MIN_EXTRA 8 @@ -164,7 +164,7 @@ int git_zstream_get_output(void *out, size_t *out_len, git_zstream *zstream) return 0; } -static int zstream_buf(git_buf *out, const void *in, size_t in_len, git_zstream_t type) +static int zstream_buf(git_str *out, const void *in, size_t in_len, git_zstream_t type) { git_zstream zs = GIT_ZSTREAM_INIT; int error = 0; @@ -178,7 +178,7 @@ static int zstream_buf(git_buf *out, const void *in, size_t in_len, git_zstream_ while (!git_zstream_done(&zs)) { size_t step = git_zstream_suggest_output_len(&zs), written; - if ((error = git_buf_grow_by(out, step)) < 0) + if ((error = git_str_grow_by(out, step)) < 0) goto done; written = out->asize - out->size; @@ -199,12 +199,12 @@ done: return error; } -int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len) +int git_zstream_deflatebuf(git_str *out, const void *in, size_t in_len) { return zstream_buf(out, in, in_len, GIT_ZSTREAM_DEFLATE); } -int git_zstream_inflatebuf(git_buf *out, const void *in, size_t in_len) +int git_zstream_inflatebuf(git_str *out, const void *in, size_t in_len) { return zstream_buf(out, in, in_len, GIT_ZSTREAM_INFLATE); } diff --git a/src/zstream.h b/src/zstream.h index db0cc477c..3a59d9a36 100644 --- a/src/zstream.h +++ b/src/zstream.h @@ -11,7 +11,7 @@ #include <zlib.h> -#include "buffer.h" +#include "str.h" typedef enum { GIT_ZSTREAM_INFLATE, @@ -48,7 +48,7 @@ bool git_zstream_eos(git_zstream *zstream); void git_zstream_reset(git_zstream *zstream); -int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len); -int git_zstream_inflatebuf(git_buf *out, const void *in, size_t in_len); +int git_zstream_deflatebuf(git_str *out, const void *in, size_t in_len); +int git_zstream_inflatebuf(git_str *out, const void *in, size_t in_len); #endif |