Skip to content

Commit 4074945

Browse files
GioeeGioee
committed
fix(src): rename dbmem function to dbmemory to avoid compilation conflicts with sqlite-sync
1 parent 359e768 commit 4074945

File tree

9 files changed

+101
-101
lines changed

9 files changed

+101
-101
lines changed

‎src/dbmem-lembed.c‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ void dbmem_logger (enum ggml_log_level level, const char *text, void *user_data)
101101
// MARK: -
102102

103103
dbmem_local_engine_t *dbmem_local_engine_init (void *ctx, const char *model_path, char err_msg[DBMEM_ERRBUF_SIZE]) {
104-
dbmem_local_engine_t *engine = (dbmem_local_engine_t *)dbmem_zeroalloc(sizeof(dbmem_local_engine_t));
104+
dbmem_local_engine_t *engine = (dbmem_local_engine_t *)dbmemory_zeroalloc(sizeof(dbmem_local_engine_t));
105105
if (!engine) return NULL;
106106

107107
// set logger
@@ -153,14 +153,14 @@ dbmem_local_engine_t *dbmem_local_engine_init (void *ctx, const char *model_path
153153

154154
// Allocate token buffer
155155
engine->tokens_capacity = engine->n_ctx;
156-
engine->tokens = (llama_token *)dbmem_alloc(sizeof(llama_token) * engine->tokens_capacity);
156+
engine->tokens = (llama_token *)dbmemory_alloc(sizeof(llama_token) * engine->tokens_capacity);
157157
if (!engine->tokens) {
158158
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Failed to allocate token buffer");
159159
goto cleanup;
160160
}
161161

162162
// Allocate single embedding buffer
163-
engine->embedding = (float *)dbmem_alloc(sizeof(float) * engine->n_embd);
163+
engine->embedding = (float *)dbmemory_alloc(sizeof(float) * engine->n_embd);
164164
if (!engine->embedding) {
165165
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Failed to allocate embedding buffer");
166166
goto cleanup;
@@ -284,11 +284,11 @@ void dbmem_local_engine_free (dbmem_local_engine_t *engine) {
284284
if (!engine) return;
285285

286286
if (engine->embedding) {
287-
dbmem_free(engine->embedding);
287+
dbmemory_free(engine->embedding);
288288
engine->embedding = NULL;
289289
}
290290
if (engine->tokens) {
291-
dbmem_free(engine->tokens);
291+
dbmemory_free(engine->tokens);
292292
engine->tokens = NULL;
293293
}
294294
if (engine->ctx) {

‎src/dbmem-parser.c‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ static int section_push (parse_ctx_t *ctx, size_t start, size_t end, int is_head
117117

118118
if (ctx->sec_count >= ctx->sec_cap) {
119119
size_t new_cap = ctx->sec_cap ? ctx->sec_cap * 2 : 16;
120-
section_t *tmp = (section_t *)dbmem_realloc(ctx->sections, new_cap * sizeof(section_t));
120+
section_t *tmp = (section_t *)dbmemory_realloc(ctx->sections, new_cap * sizeof(section_t));
121121
if (!tmp) return -1;
122122
ctx->sections = tmp;
123123
ctx->sec_cap = new_cap;
@@ -388,7 +388,7 @@ static void process_inline (strip_ctx_t *ctx, const char *start, const char *end
388388

389389
// Main markdown stripping function
390390
static char *strip_markdown (const char *src, size_t len, size_t *out_len, bool skip_html) {
391-
char *buf = (char *)dbmem_alloc(len + 1);
391+
char *buf = (char *)dbmemory_alloc(len + 1);
392392
if (!buf) return NULL;
393393

394394
strip_ctx_t ctx = {
@@ -592,7 +592,7 @@ static int parse_sections (const char *buffer, size_t buffer_size, bool skip_sem
592592
parser.text = cb_text;
593593

594594
if (md_parse(buffer, (MD_SIZE)buffer_size, &parser, ctx) != 0) {
595-
dbmem_free(ctx->sections);
595+
dbmemory_free(ctx->sections);
596596
ctx->sections = NULL;
597597
return -1;
598598
}
@@ -637,7 +637,7 @@ static int strip_sections (parse_ctx_t *ctx, const char *buffer, bool skip_html)
637637
if (!s->text) {
638638
// Free previously allocated texts and set to NULL to avoid double-free
639639
for (size_t j = 0; j < i; j++) {
640-
dbmem_free(ctx->sections[j].text);
640+
dbmemory_free(ctx->sections[j].text);
641641
ctx->sections[j].text = NULL;
642642
}
643643
return -1;
@@ -650,9 +650,9 @@ static int strip_sections (parse_ctx_t *ctx, const char *buffer, bool skip_html)
650650
static void free_sections (parse_ctx_t *ctx) {
651651
if (ctx->sections) {
652652
for (size_t i = 0; i < ctx->sec_count; i++) {
653-
dbmem_free(ctx->sections[i].text);
653+
dbmemory_free(ctx->sections[i].text);
654654
}
655-
dbmem_free(ctx->sections);
655+
dbmemory_free(ctx->sections);
656656
ctx->sections = NULL;
657657
}
658658
ctx->sec_count = ctx->sec_cap = 0;
@@ -663,7 +663,7 @@ static void free_sections (parse_ctx_t *ctx) {
663663
// Build raw chunks by splitting sections that exceed max_chars
664664
static int build_raw_chunks (parse_ctx_t *ctx, size_t max_chars, raw_chunk_t **out_chunks, size_t *out_count) {
665665
size_t cap = 16, count = 0;
666-
raw_chunk_t *chunks = (raw_chunk_t *)dbmem_alloc(cap * sizeof(raw_chunk_t));
666+
raw_chunk_t *chunks = (raw_chunk_t *)dbmemory_alloc(cap * sizeof(raw_chunk_t));
667667
if (!chunks) return -1;
668668

669669
for (size_t i = 0; i < ctx->sec_count; i++) {
@@ -673,8 +673,8 @@ static int build_raw_chunks (parse_ctx_t *ctx, size_t max_chars, raw_chunk_t **o
673673
// Fits in one chunk
674674
if (count >= cap) {
675675
cap *= 2;
676-
raw_chunk_t *tmp = (raw_chunk_t *)dbmem_realloc(chunks, cap * sizeof(raw_chunk_t));
677-
if (!tmp) { dbmem_free(chunks); return -1; }
676+
raw_chunk_t *tmp = (raw_chunk_t *)dbmemory_realloc(chunks, cap * sizeof(raw_chunk_t));
677+
if (!tmp) { dbmemory_free(chunks); return -1; }
678678
chunks = tmp;
679679
}
680680
chunks[count++] = (raw_chunk_t){ i, 0, tlen };
@@ -686,8 +686,8 @@ static int build_raw_chunks (parse_ctx_t *ctx, size_t max_chars, raw_chunk_t **o
686686
size_t split = find_split(ctx->sections[i].text + pos, remaining, max_chars);
687687
if (count >= cap) {
688688
cap *= 2;
689-
raw_chunk_t *tmp = (raw_chunk_t *)dbmem_realloc(chunks, cap * sizeof(raw_chunk_t));
690-
if (!tmp) { dbmem_free(chunks); return -1; }
689+
raw_chunk_t *tmp = (raw_chunk_t *)dbmemory_realloc(chunks, cap * sizeof(raw_chunk_t));
690+
if (!tmp) { dbmemory_free(chunks); return -1; }
691691
chunks = tmp;
692692
}
693693
chunks[count++] = (raw_chunk_t){ i, pos, split };
@@ -708,7 +708,7 @@ static char *build_chunk_text (parse_ctx_t *ctx, raw_chunk_t *raw, char *prev_te
708708

709709
if (prev_text == NULL || overlay_chars == 0) {
710710
// No overlay
711-
char *text = (char *)dbmem_alloc(src_len + 1);
711+
char *text = (char *)dbmemory_alloc(src_len + 1);
712712
if (!text) return NULL;
713713
memcpy(text, src_text, src_len);
714714
text[src_len] = '\0';
@@ -728,7 +728,7 @@ static char *build_chunk_text (parse_ctx_t *ctx, raw_chunk_t *raw, char *prev_te
728728
size_t ov_len = prev_len - ov_start;
729729
size_t total = ov_len + (ov_len > 0 ? 1 : 0) + src_len;
730730

731-
char *text = (char *)dbmem_alloc(total + 1);
731+
char *text = (char *)dbmemory_alloc(total + 1);
732732
if (!text) return NULL;
733733

734734
size_t wp = 0;
@@ -787,8 +787,8 @@ int dbmem_parse (const char *md, size_t md_len, dbmem_parse_settings *settings)
787787
size_t chunk_len;
788788
char *chunk_text = build_chunk_text(&ctx, raw, prev_text, prev_len, overlay_chars, &chunk_len);
789789
if (!chunk_text) {
790-
dbmem_free(prev_text);
791-
dbmem_free(raw_chunks);
790+
dbmemory_free(prev_text);
791+
dbmemory_free(raw_chunks);
792792
free_sections(&ctx);
793793
return -1;
794794
}
@@ -815,14 +815,14 @@ int dbmem_parse (const char *md, size_t md_len, dbmem_parse_settings *settings)
815815
}
816816

817817
// Keep this chunk's text for next iteration's overlay
818-
dbmem_free(prev_text);
818+
dbmemory_free(prev_text);
819819
prev_text = chunk_text;
820820
prev_len = chunk_len;
821821
}
822822

823823
// Cleanup
824-
dbmem_free(prev_text);
825-
dbmem_free(raw_chunks);
824+
dbmemory_free(prev_text);
825+
dbmemory_free(raw_chunks);
826826
free_sections(&ctx);
827827

828828
return rc;

‎src/dbmem-rembed.c‎

Lines changed: 39 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -197,25 +197,25 @@ dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider
197197
return NULL;
198198
}
199199

200-
dbmem_remote_engine_t *engine = (dbmem_remote_engine_t *)dbmem_zeroalloc(sizeof(dbmem_remote_engine_t));
200+
dbmem_remote_engine_t *engine = (dbmem_remote_engine_t *)dbmemory_zeroalloc(sizeof(dbmem_remote_engine_t));
201201
if (!engine) {
202202
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to allocate memory for the remote embedding engine");
203203
return NULL;
204204
}
205205

206206
// init internal buffers (data and request)
207-
char *data = dbmem_alloc(DEFAULT_BUFFER_SIZE);
207+
char *data = dbmemory_alloc(DEFAULT_BUFFER_SIZE);
208208
if (!data) {
209209
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to allocate memory for the default buffer (1)");
210210
dbmem_remote_engine_free(engine);
211211
return NULL;
212212
}
213213

214-
char *request = dbmem_alloc(DEFAULT_BUFFER_SIZE);
214+
char *request = dbmemory_alloc(DEFAULT_BUFFER_SIZE);
215215
if (!request) {
216216
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to allocate memory for the default buffer (2)");
217217
dbmem_remote_engine_free(engine);
218-
dbmem_free(data);
218+
dbmemory_free(data);
219219
return NULL;
220220
}
221221

@@ -224,18 +224,18 @@ dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider
224224
if (!_provider) {
225225
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to duplicate provider name (insufficient memory)");
226226
dbmem_remote_engine_free(engine);
227-
dbmem_free(request);
228-
dbmem_free(data);
227+
dbmemory_free(request);
228+
dbmemory_free(data);
229229
return NULL;
230230
}
231231

232232
char *_model = dbmem_strdup(model);
233233
if (!_model) {
234234
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to duplicate model name (insufficient memory)");
235235
dbmem_remote_engine_free(engine);
236-
dbmem_free(request);
237-
dbmem_free(data);
238-
dbmem_free(_provider);
236+
dbmemory_free(request);
237+
dbmemory_free(data);
238+
dbmemory_free(_provider);
239239
return NULL;
240240
}
241241

@@ -244,10 +244,10 @@ dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider
244244
CURL *curl = curl_easy_init();
245245
if (!curl) {
246246
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Failed to initialize curl");
247-
dbmem_free(data);
248-
dbmem_free(request);
249-
dbmem_free(_provider);
250-
dbmem_free(_model);
247+
dbmemory_free(data);
248+
dbmemory_free(request);
249+
dbmemory_free(_provider);
250+
dbmemory_free(_model);
251251
dbmem_remote_engine_free(engine);
252252
return NULL;
253253
}
@@ -271,10 +271,10 @@ dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider
271271
if (!headers) {
272272
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Failed to allocate HTTP headers");
273273
curl_easy_cleanup(curl);
274-
dbmem_free(data);
275-
dbmem_free(request);
276-
dbmem_free(_provider);
277-
dbmem_free(_model);
274+
dbmemory_free(data);
275+
dbmemory_free(request);
276+
dbmemory_free(_provider);
277+
dbmemory_free(_model);
278278
dbmem_remote_engine_free(engine);
279279
return NULL;
280280
}
@@ -286,10 +286,10 @@ dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider
286286
char *_api_key = dbmem_strdup(api_key);
287287
if (!_api_key) {
288288
snprintf(err_msg, DBMEM_ERRBUF_SIZE, "Unable to duplicate API key (insufficient memory)");
289-
dbmem_free(data);
290-
dbmem_free(request);
291-
dbmem_free(_provider);
292-
dbmem_free(_model);
289+
dbmemory_free(data);
290+
dbmemory_free(request);
291+
dbmemory_free(_provider);
292+
dbmemory_free(_model);
293293
dbmem_remote_engine_free(engine);
294294
return NULL;
295295
}
@@ -326,10 +326,10 @@ static size_t dbmem_remote_receive_data (void *contents, size_t size, size_t nme
326326
size_t required = engine->data_size + real_size + 1;
327327
if (required > engine->data_capacity) {
328328
size_t new_capacity = required * 2;
329-
char *new_data = dbmem_alloc(new_capacity);
329+
char *new_data = dbmemory_alloc(new_capacity);
330330
if (!new_data) return 0;
331331
memcpy(new_data, engine->data, engine->data_size);
332-
dbmem_free(engine->data);
332+
dbmemory_free(engine->data);
333333
engine->data = new_data;
334334
engine->data_capacity = new_capacity;
335335
}
@@ -355,13 +355,13 @@ int dbmem_remote_compute_embedding (dbmem_remote_engine_t *engine, const char *t
355355
size_t model_len = strlen(engine->model);
356356
if (engine->request_capacity < len + provider_len + model_len + 128) {
357357
size_t new_size = len + provider_len + model_len + 1024;
358-
char *new_request = dbmem_alloc(new_size);
358+
char *new_request = dbmemory_alloc(new_size);
359359
if (!new_request) {
360360
dbmem_context_set_error(engine->context, "Unable to allocate request buffer");
361361
return -1;
362362
}
363363

364-
dbmem_free(engine->request);
364+
dbmemory_free(engine->request);
365365
engine->request = new_request;
366366
engine->request_capacity = new_size;
367367
}
@@ -412,13 +412,13 @@ int dbmem_remote_compute_embedding (dbmem_remote_engine_t *engine, const char *t
412412
// copy response into engine's data buffer
413413
if (response_size + 1 > engine->data_capacity) {
414414
size_t new_capacity = (response_size + 1) * 2;
415-
char *new_data = dbmem_alloc(new_capacity);
415+
char *new_data = dbmemory_alloc(new_capacity);
416416
if (!new_data) {
417417
free(response_data);
418418
dbmem_context_set_error(engine->context, "Unable to allocate response buffer");
419419
return -1;
420420
}
421-
dbmem_free(engine->data);
421+
dbmemory_free(engine->data);
422422
engine->data = new_data;
423423
engine->data_capacity = new_capacity;
424424
}
@@ -443,8 +443,8 @@ int dbmem_remote_compute_embedding (dbmem_remote_engine_t *engine, const char *t
443443

444444
// grow tokens buffer if needed
445445
if (engine->tokens_capacity < ntokens) {
446-
if (engine->tokens) dbmem_free(engine->tokens);
447-
engine->tokens = (jsmntok_t *)dbmem_alloc(sizeof(jsmntok_t) * ntokens);
446+
if (engine->tokens) dbmemory_free(engine->tokens);
447+
engine->tokens = (jsmntok_t *)dbmemory_alloc(sizeof(jsmntok_t) * ntokens);
448448
if (!engine->tokens) {
449449
dbmem_context_set_error(engine->context, "Unable to allocate JSON tokens");
450450
return -1;
@@ -487,8 +487,8 @@ int dbmem_remote_compute_embedding (dbmem_remote_engine_t *engine, const char *t
487487

488488
// allocate/grow embedding buffer
489489
if (engine->embedding_capacity < (size_t)emb_count) {
490-
if (engine->embedding) dbmem_free(engine->embedding);
491-
engine->embedding = (float *)dbmem_alloc(sizeof(float) * emb_count);
490+
if (engine->embedding) dbmemory_free(engine->embedding);
491+
engine->embedding = (float *)dbmemory_alloc(sizeof(float) * emb_count);
492492
if (!engine->embedding) {
493493
dbmem_context_set_error(engine->context, "Unable to allocate embedding buffer");
494494
return -1;
@@ -521,13 +521,13 @@ void dbmem_remote_engine_free (dbmem_remote_engine_t *engine) {
521521
if (engine->headers) curl_slist_free_all(engine->headers);
522522
if (engine->curl) curl_easy_cleanup(engine->curl);
523523
#else
524-
if (engine->api_key) dbmem_free(engine->api_key);
524+
if (engine->api_key) dbmemory_free(engine->api_key);
525525
#endif
526-
if (engine->provider) dbmem_free(engine->provider);
527-
if (engine->model) dbmem_free(engine->model);
528-
if (engine->data) dbmem_free(engine->data);
529-
if (engine->request) dbmem_free(engine->request);
530-
if (engine->embedding) dbmem_free(engine->embedding);
531-
if (engine->tokens) dbmem_free(engine->tokens);
532-
dbmem_free(engine);
526+
if (engine->provider) dbmemory_free(engine->provider);
527+
if (engine->model) dbmemory_free(engine->model);
528+
if (engine->data) dbmemory_free(engine->data);
529+
if (engine->request) dbmemory_free(engine->request);
530+
if (engine->embedding) dbmemory_free(engine->embedding);
531+
if (engine->tokens) dbmemory_free(engine->tokens);
532+
dbmemory_free(engine);
533533
}

0 commit comments

Comments
 (0)