Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

fix(mcp,cypher): allocate the new query-path memory through the memory core

Martin Vogel7729a8ee9fc3
diff --git a/scripts/memory-core-baseline.txt b/scripts/memory-core-baseline.txt
index b52f1d30a..3112becc0 100644
--- a/scripts/memory-core-baseline.txt
+++ b/scripts/memory-core-baseline.txt
@@ -24,7 +24,7 @@ src/cli/config_text_edit.c 72
src/cli/config_toml_edit.c 73
src/cli/config_yaml_edit.c 117
src/cli/hook_augment.c 31
-src/cypher/cypher.c 132
+src/cypher/cypher.c 128
src/daemon/application.c 107
src/daemon/bootstrap.c 13
src/daemon/daemon.c 31
diff --git a/src/cypher/cypher.c b/src/cypher/cypher.c
index b37ef6c0d..b0a74c29b 100644
--- a/src/cypher/cypher.c
+++ b/src/cypher/cypher.c
@@ -3733,7 +3733,7 @@ static void cypher_stable_sort(int *idx, int n, cypher_index_cmp_fn cmp, const v
if (n < PAIR_LEN) {
return;
}
- int *tmp = malloc((size_t)n * sizeof(int));
+ int *tmp = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)n * sizeof(int));
if (!tmp) {
for (int i = SKIP_ONE; i < n; i++) {
for (int j = i; j > 0 && cmp(ctx, idx[j - SKIP_ONE], idx[j]) > 0; j--) {
@@ -3763,7 +3763,7 @@ static void cypher_stable_sort(int *idx, int n, cypher_index_cmp_fn cmp, const v
}
memcpy(idx, tmp, (size_t)n * sizeof(int));
}
- free(tmp);
+ cbm_free(CBM_MEM_CLASS_OTHER, tmp);
}
/* String key → the index it was first recorded with. Keys are copied: the
@@ -3797,13 +3797,13 @@ static void key_index_add(cypher_key_index_t *ix, const char *key, int index) {
}
if (ix->table && ix->count >= ix->cap) {
int cap = ix->cap ? ix->cap * PAIR_LEN : CBM_SZ_256;
- char **keys = realloc(ix->keys, (size_t)cap * sizeof(char *));
+ char **keys = cbm_realloc(CBM_MEM_CLASS_OTHER, ix->keys, (size_t)cap * sizeof(char *));
if (keys) {
ix->keys = keys;
ix->cap = cap;
}
}
- char *copy = ix->table && ix->count < ix->cap ? heap_strdup(key) : NULL;
+ char *copy = ix->table && ix->count < ix->cap ? cbm_mem_strdup(CBM_MEM_CLASS_OTHER, key) : NULL;
if (!copy) {
ix->failed = true;
return;
@@ -3817,9 +3817,9 @@ static void key_index_free(cypher_key_index_t *ix) {
cbm_ht_free(ix->table);
}
for (int i = 0; i < ix->count; i++) {
- free(ix->keys[i]);
+ cbm_free(CBM_MEM_CLASS_OTHER, ix->keys[i]);
}
- free(ix->keys);
+ cbm_free(CBM_MEM_CLASS_OTHER, ix->keys);
memset(ix, 0, sizeof(*ix));
}
@@ -3925,12 +3925,12 @@ static void rb_apply_order_by(result_builder_t *rb, const cbm_return_clause_t *r
}
int n = rb->row_count;
rb_order_ctx_t ctx = {.cols = cols, .numeric = numeric, .descs = descs, .keys = keys};
- int *idx = malloc((size_t)n * sizeof(int));
- const char ***rows = malloc((size_t)n * sizeof(const char **));
+ int *idx = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)n * sizeof(int));
+ const char ***rows = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)n * sizeof(const char **));
if (!idx || !rows) {
/* No scratch memory: insertion sort in place, same comparisons. */
- free(idx);
- free(rows);
+ cbm_free(CBM_MEM_CLASS_OTHER, idx);
+ cbm_free(CBM_MEM_CLASS_OTHER, rows);
for (int i = SKIP_ONE; i < n; i++) {
for (int j = i; j > 0 && rb_order_compare_rows(&ctx, rb->rows[j - SKIP_ONE],
rb->rows[j], NULL, NULL) > 0;
@@ -3942,7 +3942,7 @@ static void rb_apply_order_by(result_builder_t *rb, const cbm_return_clause_t *r
}
return;
}
- int *values = malloc((size_t)n * (size_t)keys * sizeof(int));
+ int *values = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)n * (size_t)keys * sizeof(int));
for (int r = 0; r < n; r++) {
idx[r] = r;
rows[r] = rb->rows[r];
@@ -3957,9 +3957,9 @@ static void rb_apply_order_by(result_builder_t *rb, const cbm_return_clause_t *r
for (int r = 0; r < n; r++) {
rb->rows[r] = rows[idx[r]];
}
- free(values);
- free(rows);
- free(idx);
+ cbm_free(CBM_MEM_CLASS_OTHER, values);
+ cbm_free(CBM_MEM_CLASS_OTHER, rows);
+ cbm_free(CBM_MEM_CLASS_OTHER, idx);
}
static void rb_apply_skip_limit(result_builder_t *rb, int skip_n, int limit,
@@ -4008,7 +4008,7 @@ static const char *rb_row_key(const result_builder_t *rb, const char **row, char
need += strlen(row[c]) + CBM_SZ_32;
}
if (need > *cap) {
- char *grown = realloc(*buf, need);
+ char *grown = cbm_realloc(CBM_MEM_CLASS_OTHER, *buf, need);
if (!grown) {
return NULL;
}
@@ -4075,7 +4075,7 @@ static void rb_apply_distinct(result_builder_t *rb) {
}
rb->row_count = kept;
key_index_free(&seen);
- free(key_buf);
+ cbm_free(CBM_MEM_CLASS_OTHER, key_buf);
}
static void rb_free(result_builder_t *rb) {
@@ -4457,17 +4457,18 @@ static void sort_bindings(binding_t *vbindings, int count, const cbm_return_clau
size_t keys = (size_t)wc->order_key_count;
size_t cells = (size_t)count * keys;
with_order_ctx_t ctx = {.wc = wc,
- .values = calloc(cells, sizeof(char *)),
- .numbered = calloc(cells, sizeof(bool)),
- .numbers = calloc(cells, sizeof(double))};
- int *idx = malloc((size_t)count * sizeof(int));
- binding_t *sorted = malloc((size_t)count * sizeof(binding_t));
+ .values = cbm_calloc(CBM_MEM_CLASS_OTHER, cells * sizeof(char *)),
+ .numbered = cbm_calloc(CBM_MEM_CLASS_OTHER, cells * sizeof(bool)),
+ .numbers = cbm_calloc(CBM_MEM_CLASS_OTHER, cells * sizeof(double))};
+ int *idx = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)count * sizeof(int));
+ binding_t *sorted = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)count * sizeof(binding_t));
bool ready = ctx.values && ctx.numbered && ctx.numbers && idx && sorted;
for (int i = 0; ready && i < count; i++) {
idx[i] = i;
for (size_t k = 0; ready && k < keys; k++) {
size_t cell = (size_t)i * keys + k;
- ctx.values[cell] = heap_strdup(order_key_value(&vbindings[i], wc->order_keys[k]));
+ ctx.values[cell] = cbm_mem_strdup(CBM_MEM_CLASS_OTHER,
+ order_key_value(&vbindings[i], wc->order_keys[k]));
ready = ctx.values[cell] != NULL;
char *end = NULL;
ctx.numbers[cell] = ready ? strtod(ctx.values[cell], &end) : 0;
@@ -4493,13 +4494,13 @@ static void sort_bindings(binding_t *vbindings, int count, const cbm_return_clau
}
}
for (size_t c = 0; ctx.values && c < cells; c++) {
- free(ctx.values[c]);
+ cbm_free(CBM_MEM_CLASS_OTHER, ctx.values[c]);
}
- free(ctx.values);
- free(ctx.numbered);
- free(ctx.numbers);
- free(idx);
- free(sorted);
+ cbm_free(CBM_MEM_CLASS_OTHER, ctx.values);
+ cbm_free(CBM_MEM_CLASS_OTHER, ctx.numbered);
+ cbm_free(CBM_MEM_CLASS_OTHER, ctx.numbers);
+ cbm_free(CBM_MEM_CLASS_OTHER, idx);
+ cbm_free(CBM_MEM_CLASS_OTHER, sorted);
}
/* Apply skip and limit to a binding array, freeing discarded entries */
@@ -4629,7 +4630,8 @@ static int with_agg_find_or_create(with_agg_t **aggs, int *agg_cnt, int *agg_cap
(*aggs)[found].maxs = calloc(wc->count, sizeof(double));
(*aggs)[found].distinct_lists = calloc(wc->count, sizeof(char **));
(*aggs)[found].distinct_n = calloc(wc->count, sizeof(int));
- (*aggs)[found].distinct_sets = calloc(wc->count, sizeof(CBMHashTable *));
+ (*aggs)[found].distinct_sets =
+ cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)wc->count * sizeof(CBMHashTable *));
(*aggs)[found].group_nodes = calloc(wc->count, sizeof(cbm_node_t));
for (int ci = 0; ci < wc->count; ci++) {
(*aggs)[found].mins[ci] = CYP_DBL_MAX;
@@ -4724,7 +4726,7 @@ static void with_agg_free(with_agg_t *aggs, int agg_cnt, int item_count) {
free(aggs[a].maxs);
free(aggs[a].distinct_lists);
free(aggs[a].distinct_n);
- free(aggs[a].distinct_sets);
+ cbm_free(CBM_MEM_CLASS_OTHER, aggs[a].distinct_sets);
if (aggs[a].group_nodes) {
for (int ci = 0; ci < item_count; ci++) {
node_fields_free(&aggs[a].group_nodes[ci]);
@@ -5134,7 +5136,8 @@ static void ret_agg_init_group(ret_agg_entry_t *entry, const char *key, int item
entry->maxs = calloc(item_count, sizeof(double));
entry->collect_lists = calloc(item_count, sizeof(char **));
entry->collect_counts = calloc(item_count, sizeof(int));
- entry->distinct_sets = calloc(item_count, sizeof(CBMHashTable *));
+ entry->distinct_sets =
+ cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)item_count * sizeof(CBMHashTable *));
for (int ci = 0; ci < item_count; ci++) {
entry->mins[ci] = CYP_DBL_MAX;
entry->maxs[ci] = -CYP_DBL_MAX;
@@ -5217,7 +5220,7 @@ static void ret_agg_free(ret_agg_entry_t *aggs, int agg_count, int item_count) {
free(aggs[a].maxs);
free(aggs[a].collect_lists);
free(aggs[a].collect_counts);
- free(aggs[a].distinct_sets);
+ cbm_free(CBM_MEM_CLASS_OTHER, aggs[a].distinct_sets);
}
free(aggs);
}
diff --git a/src/git/git_context.c b/src/git/git_context.c
index 2bd8cf564..66431333b 100644
--- a/src/git/git_context.c
+++ b/src/git/git_context.c
@@ -44,11 +44,14 @@ static bool git_validate_repo_path(const char *repo_path) {
return cbm_validate_shell_path_arg(repo_path);
}
-static int git_capture(const char *repo_path, const char *git_args, char **out) {
- if (!out) {
+/* Run `git -C repo_path git_args` and copy the first output line (newlines
+ * trimmed) into buf. Returns 0 only when git exited 0 with a non-empty line. */
+static int git_capture_into(const char *repo_path, const char *git_args, char *buf,
+ size_t buf_size) {
+ if (!buf || buf_size == 0) {
return CBM_NOT_FOUND;
}
- *out = NULL;
+ buf[0] = '\0';
if (!repo_path || !git_args || !git_validate_repo_path(repo_path)) {
return CBM_NOT_FOUND;
}
@@ -76,8 +79,8 @@ static int git_capture(const char *repo_path, const char *git_args, char **out)
}
cbm_log_debug("git.capture", "stage", "read", "args", git_args);
- char buf[GIT_OUTPUT_MAX];
- if (!fgets(buf, sizeof(buf), fp)) {
+ if (!fgets(buf, (int)buf_size, fp)) {
+ buf[0] = '\0';
cbm_log_debug("git.capture", "stage", "close", "args", git_args, "output", "none");
cbm_pclose(fp);
cbm_log_debug("git.capture", "stage", "done", "args", git_args);
@@ -89,9 +92,21 @@ static int git_capture(const char *repo_path, const char *git_args, char **out)
int rc = cbm_pclose(fp);
cbm_log_debug("git.capture", "stage", "done", "args", git_args);
if (rc != 0 || buf[0] == '\0') {
+ buf[0] = '\0';
return CBM_NOT_FOUND;
}
+ return 0;
+}
+static int git_capture(const char *repo_path, const char *git_args, char **out) {
+ if (!out) {
+ return CBM_NOT_FOUND;
+ }
+ *out = NULL;
+ char buf[GIT_OUTPUT_MAX];
+ if (git_capture_into(repo_path, git_args, buf, sizeof(buf)) != 0) {
+ return CBM_NOT_FOUND;
+ }
*out = git_strdup(buf);
return *out ? 0 : CBM_NOT_FOUND;
}
@@ -313,28 +328,28 @@ int cbm_git_context_resolve(const char *path, cbm_git_context_t *out) {
return 0;
}
-int cbm_git_branch_resolve(const char *path, bool *is_git, char **branch) {
- if (!is_git || !branch) {
+int cbm_git_branch_resolve(const char *path, bool *is_git, char *branch, size_t branch_size) {
+ if (!is_git || !branch || branch_size == 0) {
return CBM_NOT_FOUND;
}
*is_git = false;
- *branch = NULL;
+ branch[0] = '\0';
if (!path || !path[0]) {
return CBM_NOT_FOUND;
}
if (!cbm_is_dir(path)) {
return 0;
}
- char *worktree_root = NULL;
- if (git_capture(path, "rev-parse --show-toplevel", &worktree_root) != 0) {
+ char worktree_root[GIT_OUTPUT_MAX];
+ if (git_capture_into(path, "rev-parse --show-toplevel", worktree_root, sizeof(worktree_root)) !=
+ 0) {
return 0;
}
- free(worktree_root);
*is_git = true;
- if (git_capture(path, "symbolic-ref --quiet --short HEAD", branch) != 0) {
- *branch = git_strdup("DETACHED");
+ if (git_capture_into(path, "symbolic-ref --quiet --short HEAD", branch, branch_size) != 0) {
+ snprintf(branch, branch_size, "%s", "DETACHED");
}
- return *branch ? 0 : CBM_NOT_FOUND;
+ return 0;
}
char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx) {
diff --git a/src/git/git_context.h b/src/git/git_context.h
index 31dd4babf..2ac419522 100644
--- a/src/git/git_context.h
+++ b/src/git/git_context.h
@@ -2,6 +2,7 @@
#define CBM_GIT_CONTEXT_H
#include <stdbool.h>
+#include <stddef.h>
typedef struct {
bool is_git;
@@ -21,9 +22,11 @@ typedef struct {
int cbm_git_context_resolve(const char *path, cbm_git_context_t *out);
/* Only the is_git and branch fields of cbm_git_context_resolve, from the same
- * two git commands it uses for them (2 git processes instead of 7). *branch
- * is heap-owned, NULL when path is not in a git work tree. */
-int cbm_git_branch_resolve(const char *path, bool *is_git, char **branch);
+ * two git commands it uses for them (2 git processes instead of 7). branch
+ * gets "" when path is not in a git work tree; pass CBM_GIT_BRANCH_MAX bytes
+ * to read exactly what cbm_git_context_resolve reads. */
+#define CBM_GIT_BRANCH_MAX 4096
+int cbm_git_branch_resolve(const char *path, bool *is_git, char *branch, size_t branch_size);
void cbm_git_context_free(cbm_git_context_t *ctx);
char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx);
int cbm_git_context_props_json(const cbm_git_context_t *ctx, char *buf, int buf_size);
diff --git a/src/mcp/mcp.c b/src/mcp/mcp.c
index f94c04e26..e67846453 100644
--- a/src/mcp/mcp.c
+++ b/src/mcp/mcp.c
@@ -3025,16 +3025,14 @@ static bool populate_project_record(const char *dir_path, bool include_stats,
* index_status call away for the project you actually care about. */
if (record->root_path[0]) {
bool is_git = false;
- char *branch = NULL;
- (void)cbm_git_branch_resolve(record->root_path, &is_git, &branch);
- if (is_git && branch) {
+ char branch[CBM_GIT_BRANCH_MAX];
+ (void)cbm_git_branch_resolve(record->root_path, &is_git, branch, sizeof(branch));
+ if (is_git && branch[0]) {
record->branch = heap_strdup(branch);
if (!record->branch) {
- free(branch);
return false;
}
}
- free(branch);
}
record->populated = true;
return true;
@@ -12782,7 +12780,7 @@ static void root_containment_init(root_containment_t *containment, const char *r
static void root_containment_free_key(const char *key, void *value, void *userdata) {
(void)value;
(void)userdata;
- free((void *)key);
+ cbm_free(CBM_MEM_CLASS_OTHER, (void *)key);
}
static void root_containment_free(root_containment_t *containment) {
@@ -12807,7 +12805,7 @@ static bool root_containment_check(root_containment_t *containment, const char *
if (!containment->verdicts) {
containment->verdicts = cbm_ht_create(0);
}
- char *key = containment->verdicts ? heap_strdup(abs_path) : NULL;
+ char *key = containment->verdicts ? cbm_mem_strdup(CBM_MEM_CLASS_OTHER, abs_path) : NULL;
if (key) {
(void)cbm_ht_set(
containment->verdicts, key,
@@ -15433,8 +15431,8 @@ static uint32_t search_result_index_hash(int64_t id, int capacity) {
}
static void search_result_index_free(search_result_index_t *index) {
- free(index->ids);
- free(index->slots);
+ cbm_free(CBM_MEM_CLASS_OTHER, index->ids);
+ cbm_free(CBM_MEM_CLASS_OTHER, index->slots);
memset(index, 0, sizeof(*index));
}
@@ -15452,13 +15450,26 @@ static int search_result_index_find(const search_result_index_t *index, int64_t
return CBM_NOT_FOUND;
}
-static bool search_result_index_put(search_result_index_t *index, int64_t id, int value);
+/* Insert into a table with room (search_result_index_reserve succeeded). */
+static void search_result_index_insert(search_result_index_t *index, int64_t id, int value) {
+ uint32_t at = search_result_index_hash(id, index->capacity);
+ while (index->slots[at] != 0) {
+ at = (at + SKIP_ONE) & (uint32_t)(index->capacity - 1);
+ }
+ index->ids[at] = id;
+ index->slots[at] = value + SKIP_ONE;
+ index->count++;
+}
-static bool search_result_index_grow(search_result_index_t *index) {
+/* Make room for one more entry (at most half full), growing the table. */
+static bool search_result_index_reserve(search_result_index_t *index) {
+ if ((index->count + SKIP_ONE) * PAIR_LEN <= index->capacity) {
+ return true;
+ }
int capacity = index->capacity ? index->capacity * PAIR_LEN : SEARCH_RESULT_INDEX_MIN_CAPACITY;
search_result_index_t grown = {
- .ids = calloc((size_t)capacity, sizeof(int64_t)),
- .slots = calloc((size_t)capacity, sizeof(int)),
+ .ids = cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)capacity * sizeof(int64_t)),
+ .slots = cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)capacity * sizeof(int)),
.capacity = capacity,
};
if (!grown.ids || !grown.slots) {
@@ -15467,7 +15478,7 @@ static bool search_result_index_grow(search_result_index_t *index) {
}
for (int i = 0; i < index->capacity; i++) {
if (index->slots[i] != 0) {
- (void)search_result_index_put(&grown, index->ids[i], index->slots[i] - SKIP_ONE);
+ search_result_index_insert(&grown, index->ids[i], index->slots[i] - SKIP_ONE);
}
}
search_result_index_free(index);
@@ -15475,21 +15486,6 @@ static bool search_result_index_grow(search_result_index_t *index) {
return true;
}
-static bool search_result_index_put(search_result_index_t *index, int64_t id, int value) {
- if ((index->count + SKIP_ONE) * PAIR_LEN > index->capacity &&
- !search_result_index_grow(index)) {
- return false;
- }
- uint32_t at = search_result_index_hash(id, index->capacity);
- while (index->slots[at] != 0) {
- at = (at + SKIP_ONE) & (uint32_t)(index->capacity - 1);
- }
- index->ids[at] = id;
- index->slots[at] = value + SKIP_ONE;
- index->count++;
- return true;
-}
-
/* Add a grep hit to the search result set (merge into existing or create new). */
static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_cap,
search_result_index_t *index, cbm_node_t *n, int line) {
@@ -15507,6 +15503,11 @@ static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_c
*sr = grown;
*sr_cap = next_capacity;
}
+ /* Room in the index first, so nothing below can fail after the result's
+ * strings exist. */
+ if (!search_result_index_reserve(index)) {
+ return false;
+ }
search_result_t *r = &(*sr)[*sr_count];
if (!set_search_result_identity(r, n)) {
return false;
@@ -15518,13 +15519,7 @@ static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_c
r->file = NULL;
return false;
}
- if (!search_result_index_put(index, n->id, *sr_count)) {
- free(r->qualified_name);
- free(r->file);
- free(r->match_lines);
- memset(r, 0, sizeof(*r));
- return false;
- }
+ search_result_index_insert(index, n->id, *sr_count);
(*sr_count)++;
return true;
}
@@ -15624,11 +15619,12 @@ static bool scan_and_classify_grep_matches(
root_containment_init(&containment, root_path);
search_result_index_t sr_index = {0};
for (int i = 0; i < *sr_count; i++) {
- if (!search_result_index_put(&sr_index, (*sr)[i].node_id, i)) {
+ if (!search_result_index_reserve(&sr_index)) {
search_result_index_free(&sr_index);
root_containment_free(&containment);
return false;
}
+ search_result_index_insert(&sr_index, (*sr)[i].node_id, i);
}
cbm_regex_t content_regex;
bool content_regex_ready = use_regex && pattern &&
@@ -16054,16 +16050,16 @@ typedef struct {
static void search_scan_patterns_free(search_scan_patterns_t *patterns) {
for (int i = 0; i < patterns->count; i++) {
- free(patterns->items[i]);
+ cbm_free(CBM_MEM_CLASS_OTHER, patterns->items[i]);
}
for (int i = 0; patterns->regexes && i < patterns->count; i++) {
if (i < patterns->compiled && patterns->lengths[i] > 0) {
cbm_regfree(&patterns->regexes[i]);
}
}
- free(patterns->items);
- free(patterns->lengths);
- free(patterns->regexes);
+ cbm_free(CBM_MEM_CLASS_OTHER, patterns->items);
+ cbm_free(CBM_MEM_CLASS_OTHER, patterns->lengths);
+ cbm_free(CBM_MEM_CLASS_OTHER, patterns->regexes);
memset(patterns, 0, sizeof(*patterns));
}
@@ -16074,9 +16070,10 @@ static bool search_scan_patterns_parse(search_scan_patterns_t *patterns, const c
for (const char *p = pattern; *p; p++) {
count += *p == '\n' ? SKIP_ONE : 0;
}
- patterns->items = calloc((size_t)count, sizeof(char *));
- patterns->lengths = calloc((size_t)count, sizeof(size_t));
- patterns->regexes = use_regex ? calloc((size_t)count, sizeof(cbm_regex_t)) : NULL;
+ patterns->items = cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)count * sizeof(char *));
+ patterns->lengths = cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)count * sizeof(size_t));
+ patterns->regexes =
+ use_regex ? cbm_calloc(CBM_MEM_CLASS_OTHER, (size_t)count * sizeof(cbm_regex_t)) : NULL;
if (!patterns->items || !patterns->lengths || (use_regex && !patterns->regexes)) {
search_scan_patterns_free(patterns);
return false;
@@ -16085,7 +16082,7 @@ static bool search_scan_patterns_parse(search_scan_patterns_t *patterns, const c
for (int i = 0; i < count; i++) {
const char *end = strchr(start, '\n');
size_t length = end ? (size_t)(end - start) : strlen(start);
- patterns->items[i] = malloc(length + SKIP_ONE);
+ patterns->items[i] = cbm_alloc(CBM_MEM_CLASS_OTHER, length + SKIP_ONE);
if (!patterns->items[i]) {
patterns->count = i;
search_scan_patterns_free(patterns);
@@ -16272,7 +16269,8 @@ static mcp_scan_cause_t search_scan_buffer(cbm_mcp_server_t *srv, search_scan_si
return MCP_SCAN_SUCCESS;
}
-/* Read a whole file into *buffer (grown as needed), leaving one spare byte. */
+/* Read a whole file into *buffer (grown as needed, CBM_MEM_CLASS_EXTRACT),
+ * leaving one spare byte. */
static bool search_scan_read_file(const char *path, char **buffer, size_t *capacity,
size_t *length) {
FILE *fp = cbm_fopen(path, "rb");
@@ -16288,7 +16286,7 @@ static bool search_scan_read_file(const char *path, char **buffer, size_t *capac
ok = false;
break;
}
- char *next = realloc(*buffer, grown);
+ char *next = cbm_realloc(CBM_MEM_CLASS_EXTRACT, *buffer, grown);
if (!next) {
ok = false;
break;
@@ -16327,7 +16325,7 @@ static mcp_scan_cause_t search_scan_in_process(cbm_mcp_server_t *srv, const char
size_t list_capacity = 0;
size_t list_length = 0;
if (!search_scan_read_file(filelist_path, &list, &list_capacity, &list_length)) {
- free(list);
+ cbm_free(CBM_MEM_CLASS_EXTRACT, list);
search_scan_patterns_free(&patterns);
return MCP_SCAN_COMMAND_FAILURE;
}
@@ -16363,8 +16361,8 @@ static mcp_scan_cause_t search_scan_in_process(cbm_mcp_server_t *srv, const char
cause = search_scan_buffer(srv, &sink, &patterns, use_regex, path, path_length, buffer,
length, deadline_ms);
}
- free(buffer);
- free(list);
+ cbm_free(CBM_MEM_CLASS_EXTRACT, buffer);
+ cbm_free(CBM_MEM_CLASS_EXTRACT, list);
search_scan_patterns_free(&patterns);
return cause;
}
diff --git a/tests/test_git_context.c b/tests/test_git_context.c
index e21c10c8a..c508e25f3 100644
--- a/tests/test_git_context.c
+++ b/tests/test_git_context.c
@@ -450,12 +450,11 @@ static bool branch_resolve_agrees(const char *path, const char *want) {
cbm_git_context_t ctx = {0};
(void)cbm_git_context_resolve(path, &ctx);
bool is_git = false;
- char *branch = NULL;
- (void)cbm_git_branch_resolve(path, &is_git, &branch);
+ char branch[CBM_GIT_BRANCH_MAX];
+ (void)cbm_git_branch_resolve(path, &is_git, branch, sizeof(branch));
bool agrees = is_git == ctx.is_git && is_git == (want != NULL) &&
- (!want || (branch && ctx.branch && strcmp(branch, want) == 0 &&
- strcmp(ctx.branch, want) == 0));
- free(branch);
+ (want ? (ctx.branch && strcmp(branch, want) == 0 && strcmp(ctx.branch, want) == 0)
+ : branch[0] == '\0');
cbm_git_context_free(&ctx);
return agrees;
}