. since late 2023 with 8277dbe987 we have been using the bool type

from <stdbool.h>.

New C99 features that we cannot use yet:

. %z and %zu as a printf() argument for a size_t (the %z being for

* Clean up the way how signature on commit objects are exported to

and imported from fast-import stream.

Performance, Internal Implementation, Development Support etc.

--------------------------------------------------------------

* GIT_TEST_INSTALLED was not honored in the recent topic related to

SHA256 hashes, which has been corrected.

Fixes since v2.50

-----------------

patches off.

(merge 1f0fed312a bc/contribution-under-non-real-names later to maint).

* Other code cleanup, docfix, build fix, etc.

(merge b257adb571 lo/my-first-ow-doc-update later to maint).

(merge 8b34b6a220 ly/sequencer-update-squash-is-fixup-only later to maint).

(merge f4fa8a3687 rh/doc-glob-pathspec-fix later to maint).

(merge b27be108c8 ja/doc-git-log-markup later to maint).

(merge 14d7583beb pw/config-kvi-remove-path later to maint).

The default merge strategy to use when pulling multiple branches

at once.

pull.twohead::

The default merge strategy to use when pulling a single branch.

[--points-at=<object>]

[--merged[=<object>]] [--no-merged[=<object>]]

[--contains[=<object>]] [--no-contains[=<object>]]

DESCRIPTION

-----------

--include-root-refs::

List root refs (HEAD and pseudorefs) apart from regular refs.

FIELD NAMES

-----------

include::config/imap.adoc[]

EXAMPLES

--------

Using tunnel mode:

CLAR_TEST_SUITES += u-oidmap

CLAR_TEST_SUITES += u-oidtree

CLAR_TEST_SUITES += u-prio-queue

CLAR_TEST_SUITES += u-reftable-tree

CLAR_TEST_SUITES += u-strbuf

CLAR_TEST_SUITES += u-strcmp-offset

CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)

CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))

CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o

CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o

UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o

# xdiff and reftable libs may in turn depend on what is in libgit.a

GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)

#define FIND_BISECTION_ALL (1u<<0)

#define FIND_BISECTION_FIRST_PARENT_ONLY (1u<<1)

/*

* enum bisect_error represents the following return codes:

* BISECT_OK: success code. Internally, it means that next

char candidates[] = "#;@!$%^&|:";

char *candidate;

const char *p;

if (!memchr(sb->buf, candidates[0], sb->len)) {

free(comment_line_str_to_free);

candidate = strchr(candidates, *p);

if (candidate)

*candidate = ' ';

if ((p[0] == '\n' || p[0] == '\r') && p[1]) {

candidate = strchr(candidates, p[1]);

if (candidate)

N_("git for-each-ref [--points-at <object>]"),

N_("git for-each-ref [--merged [<commit>]] [--no-merged [<commit>]]"),

N_("git for-each-ref [--contains [<commit>]] [--no-contains [<commit>]]"),

NULL

};

OPT_GROUP(""),

OPT_INTEGER( 0 , "count", &format.array_opts.max_count, N_("show only <n> matched refs")),

OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")),

OPT__COLOR(&format.use_color, N_("respect format colors")),

OPT_REF_FILTER_EXCLUDE(&filter),

OPT_REF_SORT(&sorting_options),

if (verify_ref_format(&format))

usage_with_options(for_each_ref_usage, opts);

sorting = ref_sorting_options(&sorting_options);

ref_sorting_set_sort_flags_all(sorting, REF_SORTING_ICASE, icase);

filter.ignore_case = icase;

filter.name_patterns = argv;

}

if (include_root_refs)

flags |= FILTER_REFS_ROOT_REFS | FILTER_REFS_DETACHED_HEAD;

count_reflog_entries, &data);

reflog_expiry_cleanup(&data.policy);

return data.count >= data.limit;

}

cmd_log_init_finish(argc, argv, prefix, rev, opt, cfg);

}

static int cmd_log_walk_no_free(struct rev_info *rev)

{

struct commit *commit;

int saved_dcctc = 0;

int result;

if (prepare_revision_walk(rev))

die(_("revision walk setup failed"));

/*

* For --check and --exit-code, the exit code is based on CHECK_FAILED

* and HAS_CHANGES being accumulated in rev->diffopt, so be careful to

uint32_t found_mtime)

{

int want;

struct list_head *pos;

if (!exclude && local && has_loose_object_nonlocal(oid))

return 0;

*found_offset = 0;

}

struct pack_entry e;

want = want_object_in_pack_one(e.p, oid, exclude, found_pack, found_offset, found_mtime);

if (want != -1)

return want;

static const char *opt_verify_signatures;

static const char *opt_verify;

static int opt_autostash = -1;

static int check_trust_level = 1;

static struct strvec opt_strategies = STRVEC_INIT;

static struct strvec opt_strategy_opts = STRVEC_INIT;

const struct config_context *ctx, void *cb)

{

if (!strcmp(var, "rebase.autostash")) {

return 0;

} else if (!strcmp(var, "submodule.recurse")) {

recurse_submodules = git_config_bool(var, value) ?

}

argc = parse_options(argc, argv, prefix, pull_options, pull_usage, 0);

if (recurse_submodules_cli != RECURSE_SUBMODULES_DEFAULT)

recurse_submodules = recurse_submodules_cli;

if (opt_rebase) {

if (opt_autostash == -1)

if (is_null_oid(&orig_head) && !is_index_unborn(the_repository->index))

die(_("Updating an unborn branch with changes added to the index."));

&revisions, &shortrevisions))

goto cleanup;

strvec_pushl(&make_script_args, "", revisions, NULL);

if (opts->restrict_revision)

strvec_pushf(&make_script_args, "^%s",

ret = sequencer_make_script(the_repository, &todo_list.buf,

make_script_args.nr, make_script_args.v,

flags);

error(_("could not generate todo list"));

}

cleanup:

replay_opts_release(&replay);

free(revisions);

&cb);

free(ref);

}

return status;

}

static void remove_redundant_pack(const char *dir_name, const char *base_name)

{

struct strbuf buf = STRBUF_INIT;

strbuf_addf(&buf, "%s.pack", base_name);

clear_midx_file(the_repository);

strbuf_insertf(&buf, 0, "%s/", dir_name);

unlink_pack_path(buf.buf, 1);

* midx_has_unknown_packs() will make the decision for

* us.

*/

midx_must_contain_cruft = 1;

}

string_list_sort(&names);

struct multi_pack_index *m =

ALLOC_ARRAY(midx_pack_names,

m->num_packs + m->num_packs_in_base);

#include "quote.h"

#include "strbuf.h"

static const char rev_list_usage[] =

"git rev-list [<options>] <commit>... [--] [<path>...]\n"

"\n"

*

* Let "--missing" to conditionally set fetch_if_missing.

*/

/*

* --exclude-promisor-objects" is not triggering

*/

for (i = 1; i < argc; i++) {

const char *arg = argv[i];

case "$CI_TYPE" in

github-actions)

mkdir -p failed-test-artifacts

cp "${TEST_EXIT%.exit}.out" failed-test-artifacts/

tar czf failed-test-artifacts/"$test_name".trash.tar.gz "$trash_dir"

continue

#include "parse.h"

#include "object-file.h"

#include "object-file-convert.h"

static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);

commit_list_sort(list, commit_list_compare_by_date);

}

unsigned int mark)

{

struct commit_list *parents = ret->parents;

while (parents) {

struct commit *commit = parents->item;

if (!repo_parse_commit(the_repository, commit) && !(commit->object.flags & mark)) {

commit->object.flags |= mark;

}

parents = parents->next;

}

return ret;

}

const char *skip_blank_lines(const char *msg);

unsigned int mark);

struct commit *pop_commit(struct commit_list **stack);

!strcmp(var, "core.commentstring")) {

if (!value)

return config_error_nonbool(var);

auto_comment_line_char = 1;

if (strchr(value, '\n'))

return error(_("%s cannot contain newline"), var);

comment_line_str = value;

#include "commit-graph.h"

#include "sigchain.h"

#include "mergesort.h"

static int transfer_unpack_limit = -1;

static int fetch_unpack_limit = -1;

return count ? retval : 0;

}

static int mark_complete(const struct object_id *oid)

{

if (commit && !(commit->object.flags & COMPLETE)) {

commit->object.flags |= COMPLETE;

}

return 0;

}

static void mark_recent_complete_commits(struct fetch_pack_args *args,

timestamp_t cutoff)

{

print_verbose(args, _("Marking %s as complete"),

pop_most_recent_commit(&complete, COMPLETE);

}

}

refs_for_each_rawref(get_main_ref_store(the_repository),

mark_complete_oid, NULL);

for_each_cached_alternate(NULL, mark_alternate_complete);

if (cutoff)

mark_recent_complete_commits(args, cutoff);

}

build_options_config.set('NO_ICONV', '1')

endif

if pcre2.found()

libgit_dependencies += pcre2

libgit_c_args += '-DUSE_LIBPCRE2'

description: 'Build Git web interface. Requires Perl.')

option('iconv', type: 'feature', value: 'auto',

description: 'Support reencoding strings with different encodings.')

description: 'Support Perl-compatible regular expressions in e.g. git-grep(1).')

option('perl', type: 'feature', value: 'auto',

description: 'Build tools written in Perl.')

static struct multi_pack_index *lookup_multi_pack_index(struct repository *r,

const char *object_dir)

{

}

static int fill_packs_from_midx(struct write_midx_context *ctx,

if (!m)

return;

close_midx(m->base_midx);

munmap((unsigned char *)m->data, m->data_len);

return 0;

}

{

prepare_repo_settings(r);

if (!r->settings.core_multi_pack_index)

return 0;

return 1;

}

int midx_checksum_valid(struct multi_pack_index *m)

get_midx_filename(r->hash_algo, &midx, r->objects->sources->path);

}

if (remove_path(midx.buf))

struct repository;

struct bitmapped_pack;

struct git_hash_algo;

#define MIDX_SIGNATURE 0x4d494458 /* "MIDX" */

#define MIDX_VERSION 1

"GIT_TEST_MULTI_PACK_INDEX_WRITE_INCREMENTAL"

struct multi_pack_index {

const unsigned char *data;

size_t data_len;

int midx_contains_pack(struct multi_pack_index *m,

const char *idx_or_pack_name);

int midx_preferred_pack(struct multi_pack_index *m, uint32_t *pack_int_id);

/*

* Variant of write_midx_file which writes a MIDX containing only the packs

#include "commit-reach.h"

#include "date.h"

#include "object-file-convert.h"

static int get_oid_oneline(struct repository *r, const char *, struct object_id *,

const struct commit_list *);

static void find_short_packed_object(struct disambiguate_state *ds)

{

struct packed_git *p;

/* Skip, unless oids from the storage hash algorithm are wanted */

if (ds->bin_pfx.algo && (&hash_algos[ds->bin_pfx.algo] != ds->repo->hash_algo))

return;

for (p = get_packed_git(ds->repo); p && !ds->ambiguous;

p = p->next)

unique_in_pack(p, ds);

static void find_abbrev_len_packed(struct min_abbrev_data *mad)

{

struct packed_git *p;

for (p = get_packed_git(mad->repo); p; p = p->next)

find_abbrev_len_for_pack(p, mad);

}

const char *prefix, struct object_id *oid,

const struct commit_list *list)

{

const struct commit_list *l;

int found = 0;

int negative = 0;

for (l = list; l; l = l->next) {

l->item->object.flags |= ONELINE_SEEN;

}

const char *p, *buf;

struct commit *commit;

int matches;

regfree(&regex);

for (l = list; l; l = l->next)

clear_commit_marks(l->item, ONELINE_SEEN);

return found ? 0 : -1;

}

cb.list = &list;

refs_for_each_ref(get_main_ref_store(repo), handle_one_ref, &cb);

refs_head_ref(get_main_ref_store(repo), handle_one_ref, &cb);

ret = get_oid_oneline(repo, name + 2, oid, list);

free_commit_list(list);

struct oidtree;

struct strbuf;

struct repository;

/*

* Compute the exact path an alternate is at and returns it. In case of

struct loose_object_map *loose_map;

/*

* This is a temporary object store created by the tmp_objdir

* facility. Disable ref updates since the objects in the store

* might be discarded on rollback.

};

struct packed_git;

struct cached_object_entry;

/*

/*

* private data

*

* should only be accessed directly by packfile.c

*/

static int open_midx_bitmap(struct repository *r,

struct bitmap_index *bitmap_git)

{

int ret = -1;

assert(!bitmap_git->map);

ret = 0;

}

return ret;

int verify_bitmap_files(struct repository *r)

{

int res = 0;

res |= verify_bitmap_file(r->hash_algo, midx_bitmap_name);

free(midx_bitmap_name);

}

void close_object_store(struct object_database *o)

{

struct packed_git *p;

for (p = o->packed_git; p; p = p->next)

else

close_pack(p);

}

close_commit_graph(o);

report_garbage(PACKDIR_FILE_GARBAGE, full_name);

}

{

struct string_list garbage = STRING_LIST_INIT_DUP;

report_pack_garbage(data.garbage);

string_list_clear(data.garbage, 0);

unsigned long repo_approximate_object_count(struct repository *r)

{

if (!r->objects->approximate_object_count_valid) {

struct packed_git *p;

prepare_packed_git(r);

for (p = r->objects->packed_git; p; p = p->next) {

if (open_pack_index(p))

continue;

odb_prepare_alternates(r->objects);

for (source = r->objects->sources; source; source = source->next) {

int local = (source == r->objects->sources);

}

rearrange_packed_git(r);

return r->objects->packed_git;

}

{

}

struct packed_git *get_all_packs(struct repository *r)

{

prepare_packed_git(r);

prepare_midx_pack(r, m, i);

}

int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e)

{

struct list_head *pos;

prepare_packed_git(r);

return 1;

list_for_each(pos, &r->objects->packed_git_mru) {

struct packed_git *p = list_entry(pos, struct packed_git, mru);

struct packed_git *get_packed_git(struct repository *r);

struct list_head *get_packed_git_mru(struct repository *r);

struct packed_git *get_all_packs(struct repository *r);

/*

}

}

{

size_t ix, child;

/* Push down the one at the root */

for (ix = 0; ix * 2 + 1 < queue->nr; ix = child) {

child = ix * 2 + 1; /* left */

swap(queue, child, ix);

}

return result;

}

return queue->array[queue->nr - 1].data;

return queue->array[0].data;

}

*/

void *prio_queue_peek(struct prio_queue *);

void clear_prio_queue(struct prio_queue *);

/* Reverse the LIFO elements */

}

/*

* This is the same as for_each_fullref_in(), but it tries to iterate

* only over the patterns we'll care about. Note that it _doesn't_ do a full

* pattern match, so the callback still has to match each ref individually.

{

if (filter->kind & FILTER_REFS_ROOT_REFS) {

/* In this case, we want to print all refs including root refs. */

}

if (!filter->match_as_path) {

* prefixes like "refs/heads/" etc. are stripped off,

* so we have to look at everything:

*/

}

if (filter->ignore_case) {

* so just return everything and let the caller

* sort it out.

*/

}

if (!filter->name_patterns[0]) {

/* no patterns; we have to look at everything */

}

return refs_for_each_fullref_in_prefixes(get_main_ref_store(the_repository),

static int do_filter_refs(struct ref_filter *filter, unsigned int type, each_ref_fn fn, void *cb_data)

{

int ret = 0;

filter->kind = type & FILTER_REFS_KIND_MASK;

/* Simple per-ref filtering */

if (!filter->kind)

die("filter_refs: invalid type");

}

clear_contains_cache(&filter->internal.contains_cache);

clear_contains_cache(&filter->internal.no_contains_cache);

struct ref_filter {

const char **name_patterns;

struct strvec exclude;

struct oid_array points_at;

struct commit_list *with_commit;

return 0;

}

void reflog_expire_options_set_refname(struct reflog_expire_options *cb,

const char *ref)

{

int reflog_expire_config(const char *var, const char *value,

const struct config_context *ctx, void *cb);

/*

* Adapt the options so that they apply to the given refname. This applies any

* per-reference reflog expiry configuration that may exist to the options.

if (!initial_transaction) {

int ok;

iter = refs_ref_iterator_begin(refs, dirname.buf, NULL, 0,

DO_FOR_EACH_INCLUDE_BROKEN);

goto cleanup;

while ((ok = ref_iterator_advance(iter)) == ITER_OK) {

if (skip &&

unsigned int flags,

struct strbuf *err);

#endif /* REFS_H */

}

static int debug_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct debug_ref_iterator *diter =

(struct debug_ref_iterator *)ref_iterator;

return res;

}

}

static int files_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct files_ref_iterator *iter =

(struct files_ref_iterator *)ref_iterator;

}

static int files_ref_iterator_peel(struct ref_iterator *ref_iterator,

}

static int files_reflog_iterator_seek(struct ref_iterator *ref_iterator UNUSED,

{

BUG("ref_iterator_seek() called for reflog_iterator");

}

return ref_iterator->vtable->advance(ref_iterator);

}

{

}

int ref_iterator_peel(struct ref_iterator *ref_iterator,

}

static int empty_ref_iterator_seek(struct ref_iterator *ref_iterator UNUSED,

{

return 0;

}

}

static int merge_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct merge_ref_iterator *iter =

(struct merge_ref_iterator *)ref_iterator;

iter->iter0 = iter->iter0_owned;

iter->iter1 = iter->iter1_owned;

if (ret < 0)

return ret;

if (ret < 0)

return ret;

}

static int prefix_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct prefix_ref_iterator *iter =

(struct prefix_ref_iterator *)ref_iterator;

}

static int prefix_ref_iterator_peel(struct ref_iterator *ref_iterator,

}

static int packed_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct packed_ref_iterator *iter =

(struct packed_ref_iterator *)ref_iterator;

const char *start;

else

start = iter->snapshot->start;

iter->pos = start;

iter->eof = iter->snapshot->eof;

iter->repo = ref_store->repo;

iter->flags = flags;

ref_iterator_free(&iter->base);

return NULL;

}

return dir;

}

/*

* Emit a warning and return true iff ref1 and ref2 have the same name

* and the same oid. Die if they have the same name but different

}

}

{

struct cache_ref_iterator_level *level;

struct ref_dir *dir;

return 0;

}

static int cache_ref_iterator_peel(struct ref_iterator *ref_iterator,

struct object_id *peeled)

{

iter->cache = cache;

iter->prime_dir = prime_dir;

ref_iterator_free(&iter->base);

return NULL;

}

void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry);

/*

* Start iterating over references in `cache`. If `prefix` is

* specified, only include references whose names start with that

* prefix. If `prime_dir` is true, then fill any incomplete

#define SYMREF_MAXDEPTH 5

/*

*/

struct ref_iterator {

struct ref_iterator_vtable *vtable;

};

/*

* An iterator over nothing (its first ref_iterator_advance() call

* returns ITER_DONE).

*/

int is_empty_ref_iterator(struct ref_iterator *ref_iterator);

/*

* A callback function used to instruct merge_ref_iterator how to

* interleave the entries from iter0 and iter1. The function should

* return one of the constants defined in enum iterator_selection. It

typedef int ref_iterator_advance_fn(struct ref_iterator *ref_iterator);

/*

*/

typedef int ref_iterator_seek_fn(struct ref_iterator *ref_iterator,

/*

* Peels the current ref, returning 0 for success or -1 for failure.

*/

extern struct ref_iterator *current_ref_iter;

struct ref_store;

/* refs backends */

}

static int reftable_ref_iterator_seek(struct ref_iterator *ref_iterator,

{

struct reftable_ref_iterator *iter =

(struct reftable_ref_iterator *)ref_iterator;

return iter->err;

}

if (ret)

goto done;

if (ret)

goto done;

}

static int reftable_reflog_iterator_seek(struct ref_iterator *ref_iterator UNUSED,

{

BUG("reftable reflog iterator cannot be seeked");

return -1;

#include "parse-options.h"

#include "wildmatch.h"

static char *term_bad;

static char *term_good;

while (original_list) {

struct commit *commit = pop_commit(&original_list);

struct object *obj = &commit->object;

if (commit == interesting_cache)

interesting_cache = NULL;

continue;

date = commit->date;

p = &commit_list_insert(commit, p)->next;

}

if (revs->cherry_pick || revs->cherry_mark)

cherry_pick_list(newlist, revs);

} else if (!strcmp(arg, "--author-date-order")) {

revs->sort_order = REV_SORT_BY_AUTHOR_DATE;

revs->topo_order = 1;

} else if (!strcmp(arg, "--parents")) {

revs->rewrite_parents = 1;

revs->print_parents = 1;

/* topo-sort */

enum rev_sort_order sort_order;

unsigned int ignore_missing:1,

ignore_missing_links:1;

*/

struct commit_list *get_saved_parents(struct rev_info *revs, const struct commit *commit);

#endif

@mkdir -p mesontmp && \

printf "%s\n" \

"integration_tests t[0-9][0-9][0-9][0-9]-*.sh" \

"clar_test_suites unit-tests/u-*.c" | \

while read -r variable pattern; do \

awk "/^$$variable = \[\$$/ {flag=1 ; next } /^]$$/ { flag=0 } flag { gsub(/^ \047/, \"\"); gsub(/\047,\$$/, \"\"); print }" meson.build >mesontmp/meson.txt && \

#include "test-tool.h"

#include "git-compat-util.h"

#include "delta.h"

static const char usage_str[] =

"test-tool delta (-d|-p) <from_file> <data_file> <out_file>";

int cmd__delta(int argc, const char **argv)

{

int fd;

if (argv[1][1] == 'd')

&out_size, 0);

else

&out_size);

free(out_buf);

}

if (ftruncate(fd, (off_t) sz) < 0)

die_errno("failed to truncate file");

return 0;

}

'unit-tests/u-oidmap.c',

'unit-tests/u-oidtree.c',

'unit-tests/u-prio-queue.c',

'unit-tests/u-reftable-tree.c',

'unit-tests/u-strbuf.c',

'unit-tests/u-strcmp-offset.c',

clar_sources = [

'unit-tests/clar/clar.c',

'unit-tests/unit-test.c',

]

clar_decls_h = custom_target(

)

test('unit-tests', clar_unit_tests, kwargs: test_kwargs)

subdir('helper')

integration_tests = [

'perf/p1450-fsck.sh',

'perf/p1451-fsck-skip-list.sh',

'perf/p1500-graph-walks.sh',

'perf/p2000-sparse-operations.sh',

'perf/p3400-rebase.sh',

'perf/p3404-rebase-interactive.sh',

# sufficient to catch missing test suites in our CI though.

foreach glob, tests : {

't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,

'unit-tests/u-*.c': clar_test_suites,

}

actual_tests = run_command(shell, '-c', 'ls ' + glob,

timeout: 0,

)

endforeach

)

'

test_done

)

'

set_backup_editor () {

write_script backup-editor.sh <<-\EOF

cp "$1" .git/backup-"$(basename "$1")"

test_expect_code 129 git rebase --edit-todo --no-reschedule-failed-exec

'

test_orig_head_helper () {

test_when_finished 'git rebase --abort &&

git checkout topic &&

test_pull_autostash_fail --no-autostash --no-rebase

'

test_expect_success 'pull.rebase' '

git reset --hard before-rebase &&

test_config pull.rebase true &&

test_cmp expect actual

'

test_done

#include "lib-reftable.h"

#include "reftable/constants.h"

#include "reftable/writer.h"

#include "strbuf.h"

{

memset(p, (uint8_t)i, hash_size(id));

}

return 0;

}

struct reftable_write_options *opts)

{

struct reftable_writer *writer;

int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,

buf, opts);

return writer;

}

struct reftable_ref_record *refs,

size_t nrefs,

struct reftable_log_record *logs,

min = ui;

}

if (nrefs) {

ret = reftable_writer_add_refs(writer, refs, nrefs);

}

if (nlogs) {

ret = reftable_writer_add_logs(writer, logs, nlogs);

}

ret = reftable_writer_close(writer);

stats = reftable_writer_stats(writer);

size_t off = i * (opts.block_size ? opts.block_size

: DEFAULT_BLOCK_SIZE);

if (!off)

off = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);

}

if (nrefs)

if (nlogs)

reftable_writer_free(writer);

}

#include "git-compat-util.h"

#include "reftable/reftable-writer.h"

struct reftable_buf;

struct reftable_write_options *opts);

struct reftable_ref_record *refs,

size_t nrecords,

struct reftable_log_record *logs,

size_t nlogs,

struct reftable_write_options *opts);

#define STACK -3

#define GET -4

#define REVERSE -5

static int show(int *v)

{

case REVERSE:

prio_queue_reverse(&pq);

break;

default:

prio_queue_put(&pq, &input[i]);

break;

((int []){ 1, 2, MISSING, 1, 2, MISSING }));

}

void test_prio_queue__stack(void)

{

TEST_INPUT(((int []){ STACK, 8, 1, 5, 4, 6, 2, 3, DUMP }),

TEST_INPUT(((int []){ STACK, 1, 2, 3, 4, 5, 6, REVERSE, DUMP }),

((int []){ 1, 2, 3, 4, 5, 6 }));

}

https://developers.google.com/open-source/licenses/bsd

*/

#include "reftable/block.h"

#include "reftable/blocksource.h"

#include "reftable/constants.h"

#include "reftable/reftable-error.h"

#include "strbuf.h"

{

const int header_off = 21; /* random */

struct reftable_record recs[30];

struct reftable_buf block_data = REFTABLE_BUF_INIT;

REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

block_data.len = block_size;

header_off, hash_size(REFTABLE_HASH_SHA1));

rec.u.ref.refname = (char *) "";

rec.u.ref.value_type = REFTABLE_REF_DELETION;

ret = block_writer_add(&bw, &rec);

for (i = 0; i < N; i++) {

rec.u.ref.refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);

ret = block_writer_add(&bw, &rec);

rec.u.ref.refname = NULL;

rec.u.ref.value_type = REFTABLE_REF_DELETION;

}

ret = block_writer_finish(&bw);

block_writer_release(&bw);

for (i = 0; ; i++) {

ret = block_iter_next(&it, &rec);

if (ret > 0) {

break;

}

}

for (i = 0; i < N; i++) {

reftable_record_key(&recs[i], &want);

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

want.len--;

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

}

reftable_block_release(&block);

reftable_record_release(&recs[i]);

}

{

const int header_off = 21;

struct reftable_record recs[30];

struct reftable_buf block_data = REFTABLE_BUF_INIT;

REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

block_data.len = block_size;

ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,

header_off, hash_size(REFTABLE_HASH_SHA1));

for (i = 0; i < N; i++) {

rec.u.log.refname = xstrfmt("branch%02"PRIuMAX , (uintmax_t)i);

ret = block_writer_add(&bw, &rec);

rec.u.log.refname = NULL;

rec.u.log.value_type = REFTABLE_LOG_DELETION;

}

ret = block_writer_finish(&bw);

block_writer_release(&bw);

for (i = 0; ; i++) {

ret = block_iter_next(&it, &rec);

if (ret > 0) {

break;

}

}

for (i = 0; i < N; i++) {

reftable_buf_reset(&want);

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

want.len--;

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

}

reftable_block_release(&block);

reftable_record_release(&recs[i]);

}

{

const int header_off = 21;

struct reftable_record recs[30];

struct reftable_buf block_data = REFTABLE_BUF_INIT;

REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

block_data.len = block_size;

ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,

header_off, hash_size(REFTABLE_HASH_SHA1));

for (i = 0; i < N; i++) {

uint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;

ret = block_writer_add(&bw, &rec);

rec.u.obj.hash_prefix = NULL;

rec.u.obj.hash_prefix_len = 0;

}

ret = block_writer_finish(&bw);

block_writer_release(&bw);

for (i = 0; ; i++) {

ret = block_iter_next(&it, &rec);

if (ret > 0) {

break;

}

}

for (i = 0; i < N; i++) {

reftable_record_key(&recs[i], &want);

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

}

reftable_block_release(&block);

reftable_record_release(&recs[i]);

}

{

const int header_off = 21;

struct reftable_record recs[30];

struct reftable_buf block_data = REFTABLE_BUF_INIT;

REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);

block_data.len = block_size;

ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,

header_off, hash_size(REFTABLE_HASH_SHA1));

for (i = 0; i < N; i++) {

char buf[128];

reftable_buf_init(&recs[i].u.idx.last_key);

recs[i].type = REFTABLE_BLOCK_TYPE_INDEX;

recs[i].u.idx.offset = i;

ret = block_writer_add(&bw, &recs[i]);

}

ret = block_writer_finish(&bw);

block_writer_release(&bw);

for (i = 0; ; i++) {

ret = block_iter_next(&it, &rec);

if (ret > 0) {

break;

}

}

for (i = 0; i < N; i++) {

reftable_record_key(&recs[i], &want);

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

want.len--;

ret = block_iter_seek_key(&it, &want);

ret = block_iter_next(&it, &rec);

}

reftable_block_release(&block);

reftable_record_release(&recs[i]);

}

{

struct reftable_block_source source = { 0 };

struct block_writer writer = {

data.len = 1024;

REFTABLE_CALLOC_ARRAY(data.buf, data.len);

0, hash_size(REFTABLE_HASH_SHA1));

for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {

expected_refs[i] = (struct reftable_record) {

memset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);

err = block_writer_add(&writer, &expected_refs[i]);

}

err = block_writer_finish(&writer);

block_source_from_buf(&source, &data);

reftable_block_init(&block, &source, 0, 0, data.len,

REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);

err = reftable_block_init_iterator(&block, &it);

for (size_t i = 0; ; i++) {

err = reftable_iterator_next_ref(&it, &ref);

if (err > 0) {

break;

}

}

err = reftable_iterator_seek_ref(&it, "refs/heads/does-not-exist");

err = reftable_iterator_next_ref(&it, &ref);

err = reftable_iterator_seek_ref(&it, "refs/heads/branch-13");

err = reftable_iterator_next_ref(&it, &ref);

for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)

reftable_free(expected_refs[i].u.ref.refname);

block_writer_release(&writer);

reftable_buf_release(&data);

}

https://developers.google.com/open-source/licenses/bsd

*/

#include "lib-reftable.h"

#include "reftable/blocksource.h"

#include "reftable/constants.h"

int err;

REFTABLE_CALLOC_ARRAY(*tables, n);

REFTABLE_CALLOC_ARRAY(*source, n);

for (size_t i = 0; i < n; i++) {

block_source_from_buf(&(*source)[i], &buf[i]);

err = reftable_table_new(&(*tables)[i], &(*source)[i],

"name");

}

err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);

return mt;

}

reftable_free(tables);

}

{

struct reftable_ref_record r1[] = { {

.refname = (char *) "b",

int err;

err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

err = reftable_iterator_seek_ref(&it, "a");

err = reftable_iterator_next_ref(&it, &ref);

reftable_ref_record_release(&ref);

reftable_iterator_destroy(&it);

tables_destroy(tables, 3);

reftable_free(bs);

}

{

struct reftable_ref_record r1[] = {

{

size_t i;

err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

err = reftable_iterator_seek_ref(&it, "a");

while (len < 100) { /* cap loops/recursion. */

struct reftable_ref_record ref = { 0 };

if (err > 0)

break;

out[len++] = ref;

}

reftable_iterator_destroy(&it);

for (i = 0; i < len; i++)

for (i = 0; i < len; i++)

reftable_ref_record_release(&out[i]);

reftable_free(out);

reftable_free(bs);

}

{

struct reftable_ref_record r1[] = {

{

for (size_t i = 0; i < 5; i++) {

int err = reftable_iterator_seek_ref(&it, "c");

}

for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)

reftable_free(sources);

}

{

struct reftable_ref_record r1[] = {

{

struct reftable_ref_record rec = { 0 };

struct reftable_iterator it = { 0 };

struct reftable_merged_table *mt;

mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);

merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);

for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)

reftable_buf_release(&bufs[i]);

int err;

REFTABLE_CALLOC_ARRAY(*tables, n);

REFTABLE_CALLOC_ARRAY(*source, n);

for (size_t i = 0; i < n; i++) {

block_source_from_buf(&(*source)[i], &buf[i]);

err = reftable_table_new(&(*tables)[i], &(*source)[i],

"name");

}

err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);

return mt;

}

{

struct reftable_log_record r1[] = {

{

struct reftable_merged_table *mt = merged_table_from_log_records(

logs, &bs, &tables, sizes, bufs, 3);

struct reftable_iterator it = { 0 };

struct reftable_log_record *out = NULL;

size_t len = 0;

size_t cap = 0;

size_t i;

err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);

err = reftable_iterator_seek_log(&it, "a");

while (len < 100) { /* cap loops/recursion. */

struct reftable_log_record log = { 0 };

if (err > 0)

break;

out[len++] = log;

}

reftable_iterator_destroy(&it);

for (i = 0; i < len; i++)

err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);

err = reftable_iterator_seek_log_at(&it, "a", 2);

reftable_log_record_release(&out[0]);

reftable_iterator_destroy(&it);

for (i = 0; i < len; i++)

reftable_free(bs);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_ref_record rec = {

.refname = (char *) "master",

.update_index = 1,

reftable_writer_set_limits(w, 1, 1);

reftable_writer_free(w);

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "filename");

hash_id = reftable_table_hash_id(table);

err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);

err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);

reftable_table_decref(table);

reftable_merged_table_free(merged);

reftable_buf_release(&buf);

}

https://developers.google.com/open-source/licenses/bsd

*/

#include "reftable/constants.h"

#include "reftable/pq.h"

#include "strbuf.h"

{

for (size_t i = 1; i < pq->len; i++) {

size_t parent = (i - 1) / 2;

}

}

static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)

{

int cmp;

return !cmp && (a->index == b->index);

}

{

struct merged_iter_pqueue pq = { 0 };

struct reftable_record recs[54];

char *last = NULL;

for (i = 0; i < N; i++) {

recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);

}

struct pq_entry top = merged_iter_pqueue_top(pq);

struct pq_entry e;

merged_iter_pqueue_check(&pq);

if (last)

last = e.rec->u.ref.refname;

}

merged_iter_pqueue_release(&pq);

}

{

struct merged_iter_pqueue pq = { 0 };

struct reftable_record recs[13];

size_t N = ARRAY_SIZE(recs), i;

for (i = 0; i < N; i++) {

recs[i].u.ref.refname = (char *) "refs/heads/master";

}

struct pq_entry top = merged_iter_pqueue_top(pq);

struct pq_entry e;

merged_iter_pqueue_check(&pq);

if (last)

last = e.rec->u.ref.refname;

}

merged_iter_pqueue_release(&pq);

}

{

struct merged_iter_pqueue pq = { 0 };

struct reftable_record recs[13];

size_t N = ARRAY_SIZE(recs), i;

for (i = 0; i < N; i++) {

recs[i].u.ref.refname = (char *) "refs/heads/master";

}

struct pq_entry top = merged_iter_pqueue_top(pq);

struct pq_entry e;

merged_iter_pqueue_check(&pq);

for (size_t j = 0; i < pq.len; j++) {

}

}

merged_iter_pqueue_release(&pq);

}

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "lib-reftable.h"

#include "reftable/basics.h"

#include "reftable/blocksource.h"

static const int update_index = 5;

{

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_block_source source = { 0 };

struct reftable_block_data out = { 0 };

int n;

uint8_t in[] = "hello";

block_source_from_buf(&source, &buf);

n = block_source_read_data(&source, &out, 0, sizeof(in));

block_source_release_data(&out);

n = block_source_read_data(&source, &out, 1, 2);

block_source_release_data(&out);

block_source_close(&source);

int i;

REFTABLE_CALLOC_ARRAY(*names, N + 1);

REFTABLE_CALLOC_ARRAY(refs, N);

REFTABLE_CALLOC_ARRAY(logs, N);

for (i = 0; i < N; i++) {

refs[i].refname = (*names)[i] = xstrfmt("refs/heads/branch%02d", i);

refs[i].update_index = update_index;

refs[i].value_type = REFTABLE_REF_VAL1;

}

for (i = 0; i < N; i++) {

logs[i].refname = (*names)[i];

logs[i].update_index = update_index;

logs[i].value_type = REFTABLE_LOG_UPDATE;

logs[i].value.update.message = (char *) "message";

}

reftable_free(refs);

reftable_free(logs);

}

{

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_write_options opts = {

.block_size = 4096,

};

int i;

struct reftable_log_record

log = { .refname = (char *) "refs/heads/master",

.time = 0x5e430672,

.message = (char *) "commit: 9\n",

} } };

/* This tests buffer extension for log compression. Must use a random

hash, to ensure that the compressed part is larger than the original.

log.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);

}

reftable_writer_set_limits(w, update_index, update_index);

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_buf buf = REFTABLE_BUF_INIT;

char msg[256] = { 0 };

struct reftable_write_options opts = {

.block_size = ARRAY_SIZE(msg),

};

struct reftable_log_record log = {

.refname = (char *) "refs/heads/master",

.update_index = update_index,

},

},

};

memset(msg, 'x', sizeof(msg) - 1);

reftable_writer_set_limits(w, update_index, update_index);

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_log_record log = {

.refname = (char *)"refs/head/master",

.update_index = 0,

},

},

};

reftable_writer_set_limits(w, 1, 1);

/* write with update_index (0) below set limits (1, 1) */

/* write with update_index (1) in the set limits (1, 1) */

log.update_index = 1;

/* write with update_index (3) above set limits (1, 1) */

log.update_index = 3;

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = {

.block_size = 256,

struct reftable_table *table;

struct reftable_block_source source = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

const struct reftable_stats *stats = NULL;

char **names;

names = reftable_calloc(N + 1, sizeof(*names));

reftable_writer_set_limits(w, 0, N);

ref.refname = name;

ref.update_index = i;

}

for (i = 0; i < N; i++) {

log.refname = names[i];

log.update_index = i;

log.value_type = REFTABLE_LOG_UPDATE;

}

stats = reftable_writer_stats(w);

reftable_writer_free(w);

w = NULL;

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.log");

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, names[N - 1]);

err = reftable_iterator_next_ref(&it, &ref);

/* end of iteration. */

reftable_iterator_destroy(&it);

reftable_ref_record_release(&ref);

err = reftable_table_init_log_iterator(table, &it);

err = reftable_iterator_seek_log(&it, "");

for (i = 0; ; i++) {

int err = reftable_iterator_next_log(&it, &log);

if (err > 0)

break;

reftable_log_record_release(&log);

}

reftable_iterator_destroy(&it);

/* cleanup. */

reftable_table_decref(table);

}

{

struct reftable_write_options opts = {

.block_size = 256,

struct reftable_table *table;

struct reftable_block_source source = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

const struct reftable_stats *stats = NULL;

char message[100] = { 0 };

struct reftable_log_record log = {

.refname = (char *) "refname",

.value_type = REFTABLE_LOG_UPDATE,

reftable_writer_set_limits(w, 1, 1);

stats = reftable_writer_stats(w);

reftable_writer_free(w);

w = NULL;

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.log");

err = reftable_table_init_log_iterator(table, &it);

err = reftable_iterator_seek_log(&it, "refname");

reftable_iterator_destroy(&it);

reftable_buf_release(&buf);

}

{

char **names;

struct reftable_buf buf = REFTABLE_BUF_INIT;

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.ref");

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, "");

for (j = 0; ; j++) {

struct reftable_ref_record ref = { 0 };

int r = reftable_iterator_next_ref(&it, &ref);

if (r > 0)

break;

reftable_ref_record_release(&ref);

}

reftable_iterator_destroy(&it);

reftable_table_decref(table);

free_names(names);

}

{

char **names;

struct reftable_buf buf = REFTABLE_BUF_INIT;

int N = 1;

write_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);

reftable_buf_release(&buf);

free_names(names);

}

{

char **names;

struct reftable_buf buf = REFTABLE_BUF_INIT;

int N = 50;

struct reftable_table *table;

struct reftable_block_source source = { 0 };

struct reftable_log_record log = { 0 };

struct reftable_iterator it = { 0 };

write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.ref");

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, names[0]);

err = reftable_iterator_next_log(&it, &log);

reftable_buf_release(&buf);

free_names(names);

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.ref");

if (!index) {

table->ref_offsets.index_offset = 0;

} else {

}

for (i = 1; i < N; i++) {

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, names[i]);

err = reftable_iterator_next_ref(&it, &ref);

reftable_ref_record_release(&ref);

reftable_iterator_destroy(&it);

}

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, pastLast.buf);

if (err == 0) {

struct reftable_ref_record ref = { 0 };

int err = reftable_iterator_next_ref(&it, &ref);

} else {

}

reftable_buf_release(&pastLast);

reftable_table_decref(table);

}

{

t_table_read_write_seek(0, REFTABLE_HASH_SHA1);

}

{

t_table_read_write_seek(0, REFTABLE_HASH_SHA256);

}

{

t_table_read_write_seek(1, REFTABLE_HASH_SHA1);

}

struct reftable_table *table;

struct reftable_block_source source = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_iterator it = { 0 };

want_names = reftable_calloc(N + 1, sizeof(*want_names));

for (i = 0; i < N; i++) {

uint8_t hash[REFTABLE_HASH_SIZE_SHA1];

ref.refname = name;

ref.value_type = REFTABLE_REF_VAL2;

/* 80 bytes / entry, so 3 entries per block. Yields 17

*/

/* blocks. */

if (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||

!memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))

want_names[want_names_len++] = xstrdup(name);

}

reftable_writer_free(w);

w = NULL;

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.ref");

if (!indexed)

table->obj_offsets.is_present = 0;

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, "");

reftable_iterator_destroy(&it);

err = reftable_table_refs_for(table, &it, want_hash);

for (j = 0; ; j++) {

int err = reftable_iterator_next_ref(&it, &ref);

if (err > 0)

break;

reftable_ref_record_release(&ref);

}

reftable_buf_release(&buf);

free_names(want_names);

reftable_table_decref(table);

}

{

t_table_refs_for(0);

}

{

t_table_refs_for(1);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_block_source source = { 0 };

struct reftable_table *table = NULL;

struct reftable_ref_record rec = { 0 };

reftable_writer_set_limits(w, 1, 1);

reftable_writer_free(w);

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "filename");

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, "");

err = reftable_iterator_next_ref(&it, &rec);

reftable_iterator_destroy(&it);

reftable_table_decref(table);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = {

.block_size = 75,

};

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_ref_record ref = {

.update_index = 1,

.value_type = REFTABLE_REF_VAL1,

.value.val1 = {42},

};

int i;

reftable_writer_set_limits(w, 1, 1);

char name[256];

snprintf(name, sizeof(name), "ref%05d", i);

ref.refname = name;

}

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = {

.block_size = 75,

};

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_ref_record ref = {

.update_index = 1,

.value_type = REFTABLE_REF_VAL1,

.value.val1 = {42},

};

int i;

reftable_writer_set_limits(w, 1, 1);

snprintf(name, sizeof(name), "ref%05d", i);

ref.refname = name;

ref.value.val1[15] = i;

}

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_ref_record ref = {

.refname = (char *) "",

.update_index = 1,

.value_type = REFTABLE_REF_DELETION,

};

reftable_writer_set_limits(w, 1, 1);

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_ref_record refs[2] = {

{

.refname = (char *) "b",

},

}

};

reftable_writer_set_limits(w, 1, 1);

refs[0].update_index = 2;

reftable_writer_close(w);

reftable_writer_free(w);

reftable_buf_release(&buf);

}

{

struct reftable_write_options opts = {

.block_size = 100,

struct reftable_writer *writer;

struct reftable_table *table;

char buf[128];

reftable_writer_set_limits(writer, 1, 1);

for (i = 0; i < 100; i++) {

struct reftable_ref_record ref = {

snprintf(buf, sizeof(buf), "refs/heads/%04d", i);

ref.refname = buf;

}

for (i = 0; i < 100; i++) {

snprintf(buf, sizeof(buf), "refs/heads/%04d", i);

log.refname = buf;

}

reftable_writer_close(writer);

* for each of the block types.

*/

stats = reftable_writer_stats(writer);

block_source_from_buf(&source, &writer_buf);

err = reftable_table_new(&table, &source, "filename");

/*

* Seeking the log uses the log index now. In case there is any

* confusion regarding indices we would notice here.

*/

err = reftable_table_init_log_iterator(table, &it);

err = reftable_iterator_seek_log(&it, "");

reftable_iterator_destroy(&it);

reftable_writer_free(writer);

reftable_buf_release(&writer_buf);

}

{

struct reftable_write_options opts = {

.block_size = 100,

struct reftable_table *table;

int err;

reftable_writer_set_limits(writer, 1, 1);

for (size_t i = 0; i < 200; i++) {

struct reftable_ref_record ref = {

snprintf(buf, sizeof(buf), "refs/heads/%03" PRIuMAX, (uintmax_t)i);

ref.refname = buf;

}

reftable_writer_close(writer);

* multi-level index.

*/

stats = reftable_writer_stats(writer);

block_source_from_buf(&source, &writer_buf);

err = reftable_table_new(&table, &source, "filename");

/*

* Seeking the last ref should work as expected.

*/

err = reftable_table_init_ref_iterator(table, &it);

err = reftable_iterator_seek_ref(&it, "refs/heads/199");

reftable_iterator_destroy(&it);

reftable_writer_free(writer);

reftable_buf_release(&buf);

}

{

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_block_source source = { 0 };

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.log");

}

{

uint8_t zeros[1024] = { 0 };

struct reftable_buf buf = REFTABLE_BUF_INIT;

struct reftable_block_source source = { 0 };

struct reftable_table *table;

int err;

block_source_from_buf(&source, &buf);

err = reftable_table_new(&table, &source, "file.log");

reftable_buf_release(&buf);

}

https://developers.google.com/open-source/licenses/bsd

*/

#include "reftable/basics.h"

#include "reftable/constants.h"

#include "reftable/record.h"

uint8_t typ;

typ = reftable_record_type(rec);

reftable_record_copy_from(&copy, rec, REFTABLE_HASH_SIZE_SHA1);

/* do it twice to catch memory leaks */

reftable_record_copy_from(&copy, rec, REFTABLE_HASH_SIZE_SHA1);

reftable_record_release(&copy);

}

{

uint64_t inputs[] = { 0,

1,

int n = put_var_int(&out, in);

uint64_t got = 0;

out.len = n;

n = get_var_int(&got, &out);

}

}

{

unsigned char buf[] = {

0xFF, 0xFF, 0xFF, 0xFF,

.len = sizeof(buf),

};

uint64_t value;

}

static void set_hash(uint8_t *h, int j)

h[i] = (j >> i) & 0xff;

}

{

struct reftable_record in[3] = {

{

};

int cmp;

in[1].u.ref.value_type = in[0].u.ref.value_type;

}

{

struct reftable_ref_record recs[3] = {

{

},

};

}

{

struct reftable_buf scratch = REFTABLE_BUF_INIT;

t_copy(&in);

reftable_record_key(&in, &key);

n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);

/* decode into a non-zero reftable_record to test for leaks. */

m = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);

reftable_record_release(&in);

reftable_buf_release(&key);

reftable_buf_release(&scratch);

}

{

struct reftable_record in[3] = {

{

};

int cmp;

/* comparison should be reversed for equal keys, because

* comparison is now performed on the basis of update indices */

in[1].u.log.update_index = in[0].u.log.update_index;

}

{

struct reftable_log_record logs[3] = {

{

},

};

logs[1].update_index = logs[0].update_index;

logs[2].update_index = logs[0].update_index;

}

{

struct reftable_log_record in[] = {

{

set_hash(in[2].value.update.new_hash, 3);

set_hash(in[2].value.update.old_hash, 4);

for (size_t i = 0; i < ARRAY_SIZE(in); i++) {

struct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };

reftable_record_key(&rec, &key);

n = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);

valtype = reftable_record_val_type(&rec);

m = reftable_record_decode(&out, key, valtype, dest,

REFTABLE_HASH_SIZE_SHA1, &scratch);

reftable_log_record_release(&in[i]);

reftable_buf_release(&key);

reftable_record_release(&out);

reftable_buf_release(&scratch);

}

{

uint8_t buffer[1024] = { 0 };

struct string_view dest = {

int n, m;

uint8_t rt_extra;

extra = 6;

n = reftable_encode_key(&restart, dest, last_key, key, extra);

m = reftable_decode_key(&roundtrip, &rt_extra, dest);

reftable_buf_release(&last_key);

reftable_buf_release(&key);

reftable_buf_release(&roundtrip);

}

{

uint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };

};

int cmp;

in[1].u.obj.offset_len = in[0].u.obj.offset_len;

}

{

uint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };

uint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };

int n, m;

uint8_t extra;

t_copy(&in);

reftable_record_key(&in, &key);

n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);

extra = reftable_record_val_type(&in);

m = reftable_record_decode(&out, key, extra, dest,

REFTABLE_HASH_SIZE_SHA1, &scratch);

reftable_buf_release(&key);

reftable_record_release(&out);

}

reftable_buf_release(&scratch);

}

{

struct reftable_record in[3] = {

{

};

int cmp;

in[1].u.idx.offset = in[0].u.idx.offset;

for (size_t i = 0; i < ARRAY_SIZE(in); i++)

reftable_record_release(&in[i]);

}

{

struct reftable_record in = {

.type = REFTABLE_BLOCK_TYPE_INDEX,

int n, m;

uint8_t extra;

reftable_record_key(&in, &key);

t_copy(&in);

n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);

extra = reftable_record_val_type(&in);

reftable_record_release(&out);

reftable_buf_release(&key);

reftable_buf_release(&scratch);

reftable_buf_release(&in.u.idx.last_key);

}

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "dir.h"

#include "reftable/merged.h"

#include "reftable/reftable-error.h"

#include "reftable/stack.h"

static char *get_tmp_dir(int linenumber)

{

char *dir = get_tmp_template(linenumber);

return dir;

}

{

char *fn = get_tmp_template(__LINE__);

struct tempfile *tmp = mks_tempfile(fn);

char **names = NULL;

const char *want[] = { "line1", "line2", "line3" };

n = write_in_full(fd, out, strlen(out));

err = close(fd);

err = read_lines(fn, &names);

for (size_t i = 0; names[i]; i++)

free_names(names);

(void) remove(fn);

delete_tempfile(&tmp);

static int write_test_ref(struct reftable_writer *wr, void *arg)

{

struct reftable_ref_record *ref = arg;

return reftable_writer_add_ref(wr, ref);

}

size_t n)

{

int disable_auto_compact;

disable_auto_compact = st->opts.disable_auto_compact;

st->opts.disable_auto_compact = 1;

snprintf(buf, sizeof(buf), "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i);

ref.refname = buf;

}

st->opts.disable_auto_compact = disable_auto_compact;

{

struct write_log_arg *wla = arg;

return reftable_writer_add_log(wr, wla->log);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_buf scratch = REFTABLE_BUF_INIT;

.default_permissions = 0660,

};

struct reftable_stack *st = NULL;

struct reftable_ref_record ref = {

.refname = (char *) "HEAD",

.update_index = 1,

};

struct reftable_ref_record dest = { 0 };

struct stat stat_result = { 0 };

err = reftable_new_stack(&st, dir, &opts);

err = reftable_stack_add(st, write_test_ref, &ref);

err = reftable_stack_read_ref(st, ref.refname, &dest);

#ifndef GIT_WINDOWS_NATIVE

reftable_buf_reset(&scratch);

/* do not try at home; not an external API for reftable. */

err = stat(scratch.buf, &stat_result);

#else

(void) stat_result;

#endif

umask(mask);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_stack *st1 = NULL;

struct reftable_stack *st2 = NULL;

char *dir = get_tmp_dir(__LINE__);

struct reftable_ref_record ref1 = {

.refname = (char *) "HEAD",

.update_index = 1,

/* simulate multi-process access to the same stack

by creating two stacks for the same directory.

*/

reftable_stack_destroy(st1);

reftable_stack_destroy(st2);

clear_dir(dir);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_write_options opts = { 0 };

struct reftable_stack *st = NULL;

struct reftable_addition *add = NULL;

struct reftable_ref_record ref = {

};

struct reftable_ref_record dest = { 0 };

reftable_addition_destroy(add);

reftable_addition_destroy(add);

reftable_ref_record_release(&dest);

reftable_stack_destroy(st);

clear_dir(dir);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_stack *st1 = NULL, *st2 = NULL;

struct reftable_addition *add = NULL;

struct reftable_ref_record refs[2] = {

{

};

struct reftable_ref_record ref = { 0 };

reftable_addition_destroy(add);

/*

* create the addition and lock the stack by default, but allow the

* reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set.

*/

reftable_addition_destroy(add);

for (size_t i = 0; i < ARRAY_SIZE(refs); i++) {

}

reftable_ref_record_release(&ref);

clear_dir(dir);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_write_options opts = {0};

struct reftable_addition *add = NULL;

struct reftable_stack *st = NULL;

size_t n = 20;

for (size_t i = 0; i <= n; i++) {

struct reftable_ref_record ref = {

*/

st->opts.disable_auto_compact = i != n;

reftable_addition_destroy(add);

* all tables in the stack.

*/

if (i != n)

else

}

reftable_stack_destroy(st);

clear_dir(dir);

}

{

struct reftable_ref_record ref = {

.refname = (char *) "refs/heads/master",

char *dir = get_tmp_dir(__LINE__);

int err;

/*

* Lock the newly written table such that it cannot be compacted.

* Adding a new table to the stack should not be impacted by this, even

* though auto-compaction will now fail.

*/

write_file_buf(table_path.buf, "", 0);

ref.update_index = 2;

err = reftable_stack_add(st, write_test_ref, &ref);

reftable_stack_destroy(st);

reftable_buf_release(&table_path);

return *((int *)arg);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_write_options opts = { 0 };

struct reftable_stack *st = NULL;

struct reftable_ref_record ref1 = {

.refname = (char *) "name1",

.update_index = 1,

.value.symref = (char *) "master",

};

reftable_stack_destroy(st);

clear_dir(dir);

}

{

char *dir = get_tmp_dir(__LINE__);

struct reftable_write_options opts = { 0 };

struct reftable_stack *st = NULL;

reftable_stack_destroy(st);

clear_dir(dir);

}

{

struct reftable_write_options opts = {

.exact_log_message = 1,

.default_permissions = 0660,

struct reftable_buf path = REFTABLE_BUF_INIT;

struct stat stat_result;

size_t i, N = ARRAY_SIZE(refs);

err = reftable_new_stack(&st, dir, &opts);

for (i = 0; i < N; i++) {

char buf[256];

refs[i].refname = xstrdup(buf);

refs[i].update_index = i + 1;

refs[i].value_type = REFTABLE_REF_VAL1;

logs[i].refname = xstrdup(buf);

logs[i].update_index = N + i + 1;

logs[i].value_type = REFTABLE_LOG_UPDATE;

logs[i].value.update.email = xstrdup("identity@invalid");

}

for (i = 0; i < N; i++) {

struct write_log_arg arg = {

.log = &logs[i],

.update_index = reftable_stack_next_update_index(st),

};

}

for (i = 0; i < N; i++) {

struct reftable_ref_record dest = { 0 };

reftable_ref_record_release(&dest);

}

for (i = 0; i < N; i++) {

struct reftable_log_record dest = { 0 };

reftable_log_record_release(&dest);

}

#ifndef GIT_WINDOWS_NATIVE

reftable_buf_reset(&path);

/* do not try at home; not an external API for reftable. */

err = stat(path.buf, &stat_result);

#else

(void) stat_result;

#endif

clear_dir(dir);

}

{

struct reftable_write_options opts = { 0 };

struct reftable_stack *st = NULL;

size_t N = ARRAY_SIZE(refs), i;

int err;

for (i = 0; i < N; i++) {

refs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);

refs[i].update_index = i + 1;

refs[i].value_type = REFTABLE_REF_VAL1;

logs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);

logs[i].update_index = i + 1;

logs[i].value_type = REFTABLE_LOG_UPDATE;

logs[i].value.update.email = xstrdup("johndoe@invalid");

logs[i].value.update.message = xstrdup("commit\n");

}

for (i = 0; i < N; i++) {

struct write_log_arg arg = {

.update_index = reftable_stack_next_update_index(st),

};