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>
Patrick Steinhardt committed
Feb 6, 2024 at 07:35 UTC
81879123c32d06406de5bfaf68baf6029660ca2a
6 files changed
+26
-31
reftable/basics.c
+3
-4
@@ -64,12 +64,11 @@ void free_names(char **a)
64
reftable_free(a);
65
}
66
67
-int names_length(char **names)
67
+size_t names_length(char **names)
68
{
69
char **p = names;
70
- for (; *p; p++) {
71
- /* empty */
72
- }
70
+ while (*p)
71
+ p++;
72
return p - names;
73
}
74
reftable/basics.h
+1
-1
@@ -44,7 +44,7 @@ void parse_names(char *buf, int size, char ***namesp);
44
int names_equal(char **a, char **b);
45
46
/* returns the array size of a NULL-terminated array of strings. */
47
-int names_length(char **names);
47
+size_t names_length(char **names);
48
49
/* Allocation routines; they invoke the functions set through
50
* reftable_set_alloc() */
reftable/merged.c
+5
-6
@@ -45,11 +45,10 @@ static int merged_iter_init(struct merged_iter *mi)
45
static void merged_iter_close(void *p)
46
{
47
struct merged_iter *mi = p;
48
- int i = 0;
48
+
49
merged_iter_pqueue_release(&mi->pq);
50
- for (i = 0; i < mi->stack_len; i++) {
50
+ for (size_t i = 0; i < mi->stack_len; i++)
51
reftable_iterator_destroy(&mi->stack[i]);
52
- }
52
reftable_free(mi->stack);
53
strbuf_release(&mi->key);
54
strbuf_release(&mi->entry_key);
@@ -168,14 +167,14 @@ static void iterator_from_merged_iter(struct reftable_iterator *it,
167
}
168
169
int reftable_new_merged_table(struct reftable_merged_table **dest,
171
- struct reftable_table *stack, int n,
170
+ struct reftable_table *stack, size_t n,
171
uint32_t hash_id)
172
{
173
struct reftable_merged_table *m = NULL;
174
uint64_t last_max = 0;
175
uint64_t first_min = 0;
177
- int i = 0;
178
- for (i = 0; i < n; i++) {
176
+
177
+ for (size_t i = 0; i < n; i++) {
178
uint64_t min = reftable_table_min_update_index(&stack[i]);
179
uint64_t max = reftable_table_max_update_index(&stack[i]);
180
reftable/merged_test.c
+6
-8
@@ -88,18 +88,17 @@ static struct reftable_merged_table *
88
merged_table_from_records(struct reftable_ref_record **refs,
89
struct reftable_block_source **source,
90
struct reftable_reader ***readers, int *sizes,
91
- struct strbuf *buf, int n)
91
+ struct strbuf *buf, size_t n)
92
{
93
- int i = 0;
93
struct reftable_merged_table *mt = NULL;
95
- int err;
94
struct reftable_table *tabs;
95
+ int err;
96
97
REFTABLE_CALLOC_ARRAY(tabs, n);
98
REFTABLE_CALLOC_ARRAY(*readers, n);
99
REFTABLE_CALLOC_ARRAY(*source, n);
100
102
- for (i = 0; i < n; i++) {
101
+ for (size_t i = 0; i < n; i++) {
102
write_test_table(&buf[i], refs[i], sizes[i]);
103
block_source_from_strbuf(&(*source)[i], &buf[i]);
104
@@ -263,18 +262,17 @@ static struct reftable_merged_table *
262
merged_table_from_log_records(struct reftable_log_record **logs,
263
struct reftable_block_source **source,
264
struct reftable_reader ***readers, int *sizes,
266
- struct strbuf *buf, int n)
265
+ struct strbuf *buf, size_t n)
266
{
268
- int i = 0;
267
struct reftable_merged_table *mt = NULL;
270
- int err;
268
struct reftable_table *tabs;
269
+ int err;
270
271
REFTABLE_CALLOC_ARRAY(tabs, n);
272
REFTABLE_CALLOC_ARRAY(*readers, n);
273
REFTABLE_CALLOC_ARRAY(*source, n);
274
277
- for (i = 0; i < n; i++) {
275
+ for (size_t i = 0; i < n; i++) {
276
write_test_log_table(&buf[i], logs[i], sizes[i], i + 1);
277
block_source_from_strbuf(&(*source)[i], &buf[i]);
278
reftable/reftable-merged.h
+1
-1
@@ -33,7 +33,7 @@ struct reftable_table;
33
the stack array.
34
*/
35
int reftable_new_merged_table(struct reftable_merged_table **dest,
36
- struct reftable_table *stack, int n,
36
+ struct reftable_table *stack, size_t n,
37
uint32_t hash_id);
38
39
/* returns an iterator positioned just before 'name' */
reftable/stack.c
+10
-11
@@ -202,18 +202,18 @@ static struct reftable_reader **stack_copy_readers(struct reftable_stack *st,
202
static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
203
int reuse_open)
204
{
205
- int cur_len = !st->merged ? 0 : st->merged->stack_len;
205
+ size_t cur_len = !st->merged ? 0 : st->merged->stack_len;
206
struct reftable_reader **cur = stack_copy_readers(st, cur_len);
207
- int err = 0;
208
- int names_len = names_length(names);
207
+ size_t names_len = names_length(names);
208
struct reftable_reader **new_readers =
209
reftable_calloc(names_len, sizeof(*new_readers));
210
struct reftable_table *new_tables =
211
reftable_calloc(names_len, sizeof(*new_tables));
213
- int new_readers_len = 0;
212
+ size_t new_readers_len = 0;
213
struct reftable_merged_table *new_merged = NULL;
214
struct strbuf table_path = STRBUF_INIT;
216
- int i;
215
+ int err = 0;
216
+ size_t i;
217
218
while (*names) {
219
struct reftable_reader *rd = NULL;
@@ -221,11 +221,10 @@ static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
221
222
/* this is linear; we assume compaction keeps the number of
223
tables under control so this is not quadratic. */
224
- int j = 0;
225
- for (j = 0; reuse_open && j < cur_len; j++) {
226
- if (cur[j] && 0 == strcmp(cur[j]->name, name)) {
227
- rd = cur[j];
228
- cur[j] = NULL;
224
+ for (i = 0; reuse_open && i < cur_len; i++) {
225
+ if (cur[i] && 0 == strcmp(cur[i]->name, name)) {
226
+ rd = cur[i];
227
+ cur[i] = NULL;
228
break;
229
}
230
}
@@ -870,7 +869,7 @@ static int stack_write_compact(struct reftable_stack *st,
869
size_t first, size_t last,
870
struct reftable_log_expiry_config *config)
871
{
873
- int subtabs_len = last - first + 1;
872
+ size_t subtabs_len = last - first + 1;
873
struct reftable_table *subtabs = reftable_calloc(
874
last - first + 1, sizeof(*subtabs));
875
struct reftable_merged_table *mt = NULL;