Add support for explicit length string duplication (#1450)

* add `string_dup_n` to C generator

* c: add `string_dup_n` runtime tests and docs

Author: surajk-m

crates/c/README.md

@@ -195,11 +195,30 @@ void my_world_string_set(my_world_string_t *ret, const char8_t*s);
 // stores it into the component model string `ret`.
 void my_world_string_dup(my_world_string_t *ret, const char8_t*s);
 
+// Creates a copy of the input string `s` with explicit length `len` and
+// stores it into the component model string `ret`.
+// The length is specified in code units (bytes for UTF-8, 16-bit values for UTF-16).
+void my_world_string_dup_n(my_world_string_t *ret, const char8_t*s, size_t len);
+
 // Deallocates the string pointed to by `ret`, deallocating
 // the memory behind the string.
 void my_world_string_free(my_world_string_t *ret);
 ```
 
+The `string_dup_n` function is useful when working with strings that include embedded null characters or when handling substrings without first copying them into a null terminated buffer. It’s also helpful for length prefixed data or binary formats, and in general anytime the string length is already known, avoiding the cost of scanning for a terminator
+
+```c
+// Extract a substring from a larger string
+const char *full_string = "Hello, World!";
+my_world_string_t substring;
+my_world_string_dup_n(&substring, full_string, 5);  // Creates "Hello"
+
+// Work with strings containing embedded nulls
+const char data_with_nulls[] = {'H', 'i', '\0', '!'};
+my_world_string_t binary_string;
+my_world_string_dup_n(&binary_string, data_with_nulls, 4);  // Copies all 4 bytes
+```
+
 For UTF-16 strings, those `char8_t*`s become `char16_t*`s and the following function is also supplied:
 
 ```c

crates/c/src/lib.rs

@@ -368,6 +368,11 @@ impl WorldGenerator for C {
                    // stores it into the component model string `ret`.
                    void {snake}_string_dup({snake}_string_t *ret, const {c_string_ty} *s);
 
+                   // Creates a copy of the input string `s` with length `len` and
+                   // stores it into the component model string `ret`.
+                   // The length is specified in code units (bytes for UTF-8, 16-bit values for UTF-16).
+                   void {snake}_string_dup_n({snake}_string_t *ret, const {c_string_ty} *s, size_t len);
+
                    // Deallocates the string pointed to by `ret`, deallocating
                    // the memory behind the string.
                    void {snake}_string_free({snake}_string_t *ret);\
@@ -387,6 +392,12 @@ impl WorldGenerator for C {
                        memcpy(ret->ptr, s, ret->len * {size});
                    }}
 
+                   void {snake}_string_dup_n({snake}_string_t *ret, const {c_string_ty} *s, size_t len) {{
+                       ret->len = len;
+                       ret->ptr = ({ty}*) cabi_realloc(NULL, 0, {size}, ret->len * {size});
+                       memcpy(ret->ptr, s, ret->len * {size});
+                   }}
+
                    void {snake}_string_free({snake}_string_t *ret) {{
                        if (ret->len > 0) {{
                            free(ret->ptr);

tests/runtime/strings/runner.c

@@ -1,6 +1,6 @@
 //@ args = '--string-encoding utf16'
 //@ [lang]
-//@ cflags = '-Wno-c++-keyword'
+//@ cflags = '-Wno-c++-compat'
 
 #include <assert.h>
 #include <stdlib.h>
@@ -40,4 +40,60 @@ void exports_runner_run() {
     test_strings_to_test_roundtrip(&str4, &str5);
     assert_str(&str5, u"🚀🚀🚀 𠈄𓀀");
     runner_string_free(&str5);
+
+    // Basic substring extraction
+    runner_string_t str6;
+    const char16_t *source = u"hello world";
+    runner_string_dup_n(&str6, source, 5);
+    assert(str6.len == 5);
+    assert(memcmp(str6.ptr, u"hello", 5 * 2) == 0);
+    runner_string_free(&str6);
+
+    // Zero length (edge case - boundary condition)
+    runner_string_t str7;
+    runner_string_dup_n(&str7, u"test", 0);
+    assert(str7.len == 0);
+    runner_string_free(&str7);
+
+    // Full string length
+    runner_string_t str8;
+    const char16_t *full_str = u"complete";
+    size_t full_len = 8;
+    runner_string_dup_n(&str8, full_str, full_len);
+    assert(str8.len == full_len);
+    assert(memcmp(str8.ptr, full_str, full_len * 2) == 0);
+    runner_string_free(&str8);
+
+    // Substring from middle (pointer offset)
+    runner_string_t str9;
+    const char16_t *middle_source = u"prefix_target_suffix";
+    runner_string_dup_n(&str9, middle_source + 7, 6);
+    assert(str9.len == 6);
+    assert(memcmp(str9.ptr, u"target", 6 * 2) == 0);
+    runner_string_free(&str9);
+
+    // Unicode content with explicit length
+    runner_string_t str10;
+    const char16_t *unicode_src = u"🚀🚀🚀 test";
+    // Each rocket emoji is 2 UTF-16 code units (surrogate pair), space is 1, "test" is 4
+    // Total: 6 + 1 + 4 = 11 code units, extract first 7 (3 rockets + space)
+    runner_string_dup_n(&str10, unicode_src, 7);
+    assert(str10.len == 7);
+    assert(memcmp(str10.ptr, u"🚀🚀🚀 ", 7 * 2) == 0);
+    runner_string_free(&str10);
+
+    // Single character
+    runner_string_t str11;
+    runner_string_dup_n(&str11, u"x", 1);
+    assert(str11.len == 1);
+    assert(str11.ptr[0] == u'x');
+    runner_string_free(&str11);
+
+    // Verify data independence (modification doesn't affect original)
+    runner_string_t str12;
+    char16_t mutable_src[] = u"original";
+    runner_string_dup_n(&str12, mutable_src, 8);
+    mutable_src[0] = u'X';
+    assert(str12.ptr[0] == u'o');
+    runner_string_free(&str12);
 }

tests/runtime/strings/test.c

@@ -1,6 +1,6 @@
 //@ args = '--string-encoding utf16'
 //@ [lang]
-//@ cflags = '-Wno-c++-keyword'
+//@ cflags = '-Wno-c++-compat'
 
 #include <assert.h>
 #include <stdlib.h>