feat: allow customizable string terminators

Author: Dax89

include/redasm/context.h

@@ -120,7 +120,6 @@ RD_API bool rd_export(RDContext* self, const char* filepath, RDExportFormat f);
 RD_API bool rd_project_save(RDContext* self, const char* filepath);
 RD_API bool rd_reanalyze(RDContext* self);
 RD_API void rd_disassemble(RDContext* self);
-RD_API void rd_set_scan_char16(RDContext* self, bool b);
 RD_API const char* rd_get_working_dir(const RDContext* self);
 RD_API const char* rd_get_file_name(const RDContext* self);
 RD_API const char* rd_str_intern(RDContext* self, const char* s);
@@ -142,7 +141,9 @@ RD_API RDSegmentSlice rd_get_all_segments(const RDContext* self);
 RD_API RDAddressSpace rd_get_address_space(const RDContext* ctx);
 RD_API RDInputMappingSlice rd_get_all_mappings(const RDContext* self);
 RD_API RDLoadAddressing rd_get_load_addressing(const RDContext* self);
+RD_API void rd_set_scan_char16(RDContext* self, bool b);
 RD_API void rd_set_min_string(RDContext* self, int l);
+RD_API void rd_set_string_terminators(RDContext* ctx, const u8* terms, usize n);
 RD_API const RDSegment* rd_find_segment(const RDContext* self, RDAddress addr);
 RD_API const RDFunction* rd_find_function(const RDContext* self, RDAddress address);
 RD_API const RDLoaderPlugin* rd_get_loader_plugin(const RDContext* self);

src/core/context.c

@@ -142,6 +142,8 @@ RDContext* rd_i_context_create(const RDLoaderPlugin* lplugin,
     self->db = rd_i_db_create(dbpath);
     self->kb = rd_i_kb_create();
 
+    vect_push(&self->string_terminators, 0); // default string terminator
+
     assert(self->working_dir);
     assert(self->file_name);
 
@@ -692,6 +694,7 @@ void rd_destroy(RDContext* self) {
     vect_destroy(&self->lift_buf);
     vect_destroy(&self->chunk_buf);
     vect_destroy(&self->externals);
+    vect_destroy(&self->string_terminators);
     vect_destroy(&self->hooks);
     hmap_destroy(&self->engine.current.registers);
     rd_i_analyzeritemvect_destroy(&self->analyzerplugins);
@@ -1403,6 +1406,16 @@ RDLoadAddressing rd_get_load_addressing(const RDContext* self) {
 
 void rd_set_min_string(RDContext* self, int l) { self->min_string = l; }
 
+void rd_set_string_terminators(RDContext* ctx, const u8* terms, usize n) {
+    if(!terms || !n) return;
+
+    vect_reserve(&ctx->string_terminators, n);
+    vect_clear(&ctx->string_terminators);
+
+    for(usize i = 0; i < n; i++)
+        vect_push(&ctx->string_terminators, terms[i]);
+}
+
 bool rd_operand_as_address(RDContext* self, RDAddress address, int index) {
     if(index >= RD_MAX_OPERANDS) return false;
 

src/core/context.h

@@ -33,6 +33,12 @@ typedef struct RDPendingRenameVect {
     usize capacity;
 } RDPendingRenameVect;
 
+typedef struct RDStringTerminatorVect {
+    u8* data;
+    usize length;
+    usize capacity;
+} RDStringTerminatorVect;
+
 typedef struct RDContext {
     const RDLoaderPlugin* loaderplugin;
     const RDProcessorPlugin* processorplugin;
@@ -82,6 +88,7 @@ typedef struct RDContext {
 
     RDTypeDefVect typedefs;
     RDPendingRenameVect pending_renames;
+    RDStringTerminatorVect string_terminators;
 
     struct {
         RDAddress value;

src/core/stringfinder.c

@@ -43,6 +43,15 @@ static void _rd_i_strings_init(void) {
     }
 }
 
+static bool _rd_is_string_terminator(const RDContext* ctx, u8 v) {
+    u8* it;
+    vect_each(it, &ctx->string_terminators) {
+        if(*it == v) return true;
+    }
+
+    return false;
+}
+
 static bool _rd_strings_check_format(const char* s, int len) {
     assert(len > 0);
 
@@ -81,6 +90,12 @@ static void _rd_strings_try_classify(RDContext* ctx, const RDSegmentFull* seg,
 
 static void _rd_find_char_strings(RDContext* ctx, RDCharVect* str,
                                   RDCharVect* fmt_buf) {
+    if(vect_is_empty(&ctx->string_terminators)) {
+        RD_LOG_WARN(
+            "no string terminator(s) provided, skipping string detection...");
+        return;
+    }
+
     const RDSegmentFullVect* segments = rd_i_db_get_segments(ctx);
 
     RDSegmentFull** it;
@@ -104,7 +119,7 @@ static void _rd_find_char_strings(RDContext* ctx, RDCharVect* str,
                 continue;
             }
 
-            if(v == 0) {
+            if(_rd_is_string_terminator(ctx, v)) {
                 vect_push(str, 0); // add null terminator
                 _rd_strings_try_classify(ctx, seg, startidx, "char", str,
                                          fmt_buf);

src/project/load.c

@@ -24,6 +24,7 @@ typedef struct RDProjectManifest {
         bool has_value;
     } entry_point;
 
+    RDStringTerminatorVect string_terminators;
     RDAnalyzerItemVect analyzers;
 
     toml_result_t toml;
@@ -54,6 +55,7 @@ static const RDTomlSchema MANIFEST_SCHEMA[] = {
     {.key = "format.file_name", .type = TOML_STRING},
 
     {.key = "analysis.min_string", .type = TOML_INT64},
+    {.key = "analysis.string_terminators", .type = TOML_ARRAY, .array_type = &(RDTomlSchema){.type = TOML_INT64}},
     {.key = "analysis.loader", .type = TOML_STRING},
     {.key = "analysis.processor", .type = TOML_STRING},
     {.key = "analysis.analyzers", .type = TOML_ARRAY, .array_type = ANALYZER_SCHEMA},
@@ -65,6 +67,7 @@ static const RDTomlSchema MANIFEST_SCHEMA[] = {
 
 static void _rd_project_manifest_destroy(RDProjectManifest* m) {
     rd_i_analyzeritemvect_destroy(&m->analyzers);
+    vect_destroy(&m->string_terminators);
     toml_free(m->toml);
     rd_free(m->raw);
 }
@@ -158,6 +161,17 @@ static bool _rd_project_read_manifest(mz_zip_archive* zip,
     out->min_string =
         (int)toml_seek(out->toml.toptab, "analysis.min_string").u.int64;
 
+    toml_datum_t string_terminators =
+        toml_seek(out->toml.toptab, "analysis.string_terminators");
+
+    vect_reserve(&out->string_terminators,
+                 (usize)string_terminators.u.arr.size);
+
+    for(int i = 0; i < string_terminators.u.arr.size; i++) {
+        toml_datum_t elem = string_terminators.u.arr.elem[i];
+        vect_push(&out->string_terminators, (u8)elem.u.int64);
+    }
+
     const char* loader_id = toml_seek(out->toml.toptab, "analysis.loader").u.s;
     assert(loader_id);
 
@@ -274,6 +288,9 @@ static RDContext* _rd_project_create_context(mz_zip_archive* zip,
 
     ctx->entry_point.has_value = manifest->entry_point.has_value;
     ctx->entry_point.value = manifest->entry_point.value;
+
+    mem_swap(RDStringTerminatorVect, &ctx->string_terminators,
+             &manifest->string_terminators);
     mem_swap(RDAnalyzerItemVect, &ctx->analyzerplugins, &manifest->analyzers);
 
     ctx->engine.step = RD_WS_DONE;

src/project/save.c

@@ -22,6 +22,18 @@ static const char* _rd_project_write_manifest(const RDContext* ctx,
 
     str_append(v, "\n[analysis]\n");
     str_append(v, rd_i_format(&buf, "min_string = %d\n", ctx->min_string));
+
+    str_append(v, "string_terminators = [");
+
+    for(usize i = 0; i < vect_length(&ctx->string_terminators); i++) {
+        if(i) str_push(v, ',');
+
+        const u8* t = vect_at(&ctx->string_terminators, i);
+        str_append(v, rd_i_format(&buf, "%" PRIu8, t));
+    }
+
+    str_append(v, "]\n");
+
     str_append(v, rd_i_format(&buf, "loader = \"%s\"\n", ctx->loaderplugin->id));
     str_append(v, rd_i_format(&buf, "processor = \"%s\"\n", ctx->processorplugin->id));
     str_append(v, "analyzers = [");