mirror of
https://github.com/git/git
synced 2024-10-02 14:45:21 +00:00
reftable/stack: use size_t
to track stack length
While the stack length is already stored as `size_t`, we frequently use `int`s to refer to those stacks throughout the reftable library. Convert those cases to use `size_t` instead to make things consistent. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
parent
47616c4399
commit
81879123c3
|
@ -64,12 +64,11 @@ void free_names(char **a)
|
|||
reftable_free(a);
|
||||
}
|
||||
|
||||
int names_length(char **names)
|
||||
size_t names_length(char **names)
|
||||
{
|
||||
char **p = names;
|
||||
for (; *p; p++) {
|
||||
/* empty */
|
||||
}
|
||||
while (*p)
|
||||
p++;
|
||||
return p - names;
|
||||
}
|
||||
|
||||
|
|
|
@ -44,7 +44,7 @@ void parse_names(char *buf, int size, char ***namesp);
|
|||
int names_equal(char **a, char **b);
|
||||
|
||||
/* returns the array size of a NULL-terminated array of strings. */
|
||||
int names_length(char **names);
|
||||
size_t names_length(char **names);
|
||||
|
||||
/* Allocation routines; they invoke the functions set through
|
||||
* reftable_set_alloc() */
|
||||
|
|
|
@ -45,11 +45,10 @@ static int merged_iter_init(struct merged_iter *mi)
|
|||
static void merged_iter_close(void *p)
|
||||
{
|
||||
struct merged_iter *mi = p;
|
||||
int i = 0;
|
||||
|
||||
merged_iter_pqueue_release(&mi->pq);
|
||||
for (i = 0; i < mi->stack_len; i++) {
|
||||
for (size_t i = 0; i < mi->stack_len; i++)
|
||||
reftable_iterator_destroy(&mi->stack[i]);
|
||||
}
|
||||
reftable_free(mi->stack);
|
||||
strbuf_release(&mi->key);
|
||||
strbuf_release(&mi->entry_key);
|
||||
|
@ -168,14 +167,14 @@ static void iterator_from_merged_iter(struct reftable_iterator *it,
|
|||
}
|
||||
|
||||
int reftable_new_merged_table(struct reftable_merged_table **dest,
|
||||
struct reftable_table *stack, int n,
|
||||
struct reftable_table *stack, size_t n,
|
||||
uint32_t hash_id)
|
||||
{
|
||||
struct reftable_merged_table *m = NULL;
|
||||
uint64_t last_max = 0;
|
||||
uint64_t first_min = 0;
|
||||
int i = 0;
|
||||
for (i = 0; i < n; i++) {
|
||||
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
uint64_t min = reftable_table_min_update_index(&stack[i]);
|
||||
uint64_t max = reftable_table_max_update_index(&stack[i]);
|
||||
|
||||
|
|
|
@ -88,18 +88,17 @@ static struct reftable_merged_table *
|
|||
merged_table_from_records(struct reftable_ref_record **refs,
|
||||
struct reftable_block_source **source,
|
||||
struct reftable_reader ***readers, int *sizes,
|
||||
struct strbuf *buf, int n)
|
||||
struct strbuf *buf, size_t n)
|
||||
{
|
||||
int i = 0;
|
||||
struct reftable_merged_table *mt = NULL;
|
||||
int err;
|
||||
struct reftable_table *tabs;
|
||||
int err;
|
||||
|
||||
REFTABLE_CALLOC_ARRAY(tabs, n);
|
||||
REFTABLE_CALLOC_ARRAY(*readers, n);
|
||||
REFTABLE_CALLOC_ARRAY(*source, n);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
write_test_table(&buf[i], refs[i], sizes[i]);
|
||||
block_source_from_strbuf(&(*source)[i], &buf[i]);
|
||||
|
||||
|
@ -263,18 +262,17 @@ static struct reftable_merged_table *
|
|||
merged_table_from_log_records(struct reftable_log_record **logs,
|
||||
struct reftable_block_source **source,
|
||||
struct reftable_reader ***readers, int *sizes,
|
||||
struct strbuf *buf, int n)
|
||||
struct strbuf *buf, size_t n)
|
||||
{
|
||||
int i = 0;
|
||||
struct reftable_merged_table *mt = NULL;
|
||||
int err;
|
||||
struct reftable_table *tabs;
|
||||
int err;
|
||||
|
||||
REFTABLE_CALLOC_ARRAY(tabs, n);
|
||||
REFTABLE_CALLOC_ARRAY(*readers, n);
|
||||
REFTABLE_CALLOC_ARRAY(*source, n);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
write_test_log_table(&buf[i], logs[i], sizes[i], i + 1);
|
||||
block_source_from_strbuf(&(*source)[i], &buf[i]);
|
||||
|
||||
|
|
|
@ -33,7 +33,7 @@ struct reftable_table;
|
|||
the stack array.
|
||||
*/
|
||||
int reftable_new_merged_table(struct reftable_merged_table **dest,
|
||||
struct reftable_table *stack, int n,
|
||||
struct reftable_table *stack, size_t n,
|
||||
uint32_t hash_id);
|
||||
|
||||
/* returns an iterator positioned just before 'name' */
|
||||
|
|
|
@ -202,18 +202,18 @@ static struct reftable_reader **stack_copy_readers(struct reftable_stack *st,
|
|||
static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
|
||||
int reuse_open)
|
||||
{
|
||||
int cur_len = !st->merged ? 0 : st->merged->stack_len;
|
||||
size_t cur_len = !st->merged ? 0 : st->merged->stack_len;
|
||||
struct reftable_reader **cur = stack_copy_readers(st, cur_len);
|
||||
int err = 0;
|
||||
int names_len = names_length(names);
|
||||
size_t names_len = names_length(names);
|
||||
struct reftable_reader **new_readers =
|
||||
reftable_calloc(names_len, sizeof(*new_readers));
|
||||
struct reftable_table *new_tables =
|
||||
reftable_calloc(names_len, sizeof(*new_tables));
|
||||
int new_readers_len = 0;
|
||||
size_t new_readers_len = 0;
|
||||
struct reftable_merged_table *new_merged = NULL;
|
||||
struct strbuf table_path = STRBUF_INIT;
|
||||
int i;
|
||||
int err = 0;
|
||||
size_t i;
|
||||
|
||||
while (*names) {
|
||||
struct reftable_reader *rd = NULL;
|
||||
|
@ -221,11 +221,10 @@ static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
|
|||
|
||||
/* this is linear; we assume compaction keeps the number of
|
||||
tables under control so this is not quadratic. */
|
||||
int j = 0;
|
||||
for (j = 0; reuse_open && j < cur_len; j++) {
|
||||
if (cur[j] && 0 == strcmp(cur[j]->name, name)) {
|
||||
rd = cur[j];
|
||||
cur[j] = NULL;
|
||||
for (i = 0; reuse_open && i < cur_len; i++) {
|
||||
if (cur[i] && 0 == strcmp(cur[i]->name, name)) {
|
||||
rd = cur[i];
|
||||
cur[i] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -870,7 +869,7 @@ static int stack_write_compact(struct reftable_stack *st,
|
|||
size_t first, size_t last,
|
||||
struct reftable_log_expiry_config *config)
|
||||
{
|
||||
int subtabs_len = last - first + 1;
|
||||
size_t subtabs_len = last - first + 1;
|
||||
struct reftable_table *subtabs = reftable_calloc(
|
||||
last - first + 1, sizeof(*subtabs));
|
||||
struct reftable_merged_table *mt = NULL;
|
||||
|
|
Loading…
Reference in a new issue