postprocess: add most of the LLM cache for json-c

There are still some remaining bugs I'm encountering in testing on `json-c`,
but checking these in now allows us to see in the PR how the conditional comments are inserted.

Author: kkysen

c2rust-postprocess/tests/llm-cache/CommentTransfer/_json_c_set_last_err/9ade63e9af53ecf8c488a382844137e74be4f51ab55c952a8cec0760a15edb10/metadata.toml

@@ -0,0 +1,65 @@
+transform = "CommentTransfer"
+identifier = "_json_c_set_last_err"
+model = "gemini-3-pro-preview"
+response = """```rust
+#[no_mangle]
+#[c2rust::src_loc = "75:1"]
+pub unsafe extern "C" fn _json_c_set_last_err(
+    mut err_fmt: *const ::core::ffi::c_char,
+    mut args: ...
+) {
+    let mut ap: ::core::ffi::VaListImpl;
+    ap = args.clone();
+    // Ignore (attempted) overruns from snprintf
+    vsnprintf(
+        &raw mut _last_err as *mut ::core::ffi::c_char,
+        ::core::mem::size_of::<[::core::ffi::c_char; 256]>() as size_t,
+        err_fmt,
+        ap.as_va_list(),
+    );
+}
+```"""
+
+[[messages]]
+role = "user"
+content = """Transfer the comments from the following C function to the corresponding Rust function.
+Do not add any comments that are not present in the C function.
+Use Rust doc comment syntax (///) where appropriate (e.g., for function documentation).
+Respond with the Rust function definition with the transferred comments.
+
+The Rust must contain exactly the same comments as the C code did.
+This must be true even if there are C comments in conditionally-compiled code
+not present in the Rust, including comments on preprocessor directives.
+In such cases, insert the C comment (only the comment, not any C code)
+into the Rust where the Rust code should have been.
+If any C comments are not inserted into the Rust, explain why.
+
+C function:
+```c
+void _json_c_set_last_err(const char *err_fmt, ...)
+{
+\tva_list ap;
+\tva_start(ap, err_fmt);
+\t// Ignore (attempted) overruns from snprintf
+\t(void)vsnprintf(_last_err, sizeof(_last_err), err_fmt, ap);
+\tva_end(ap);
+}```
+
+Rust function:
+```rust
+#[no_mangle]
+#[c2rust::src_loc = "75:1"]
+pub unsafe extern "C" fn _json_c_set_last_err(
+    mut err_fmt: *const ::core::ffi::c_char,
+    mut args: ...
+) {
+    let mut ap: ::core::ffi::VaListImpl;
+    ap = args.clone();
+    vsnprintf(
+        &raw mut _last_err as *mut ::core::ffi::c_char,
+        ::core::mem::size_of::<[::core::ffi::c_char; 256]>() as size_t,
+        err_fmt,
+        ap.as_va_list(),
+    );
+}```
+"""

c2rust-postprocess/tests/llm-cache/CommentTransfer/_json_c_set_last_err/9ade63e9af53ecf8c488a382844137e74be4f51ab55c952a8cec0760a15edb10/response.txt

@@ -0,0 +1,18 @@
+```rust
+#[no_mangle]
+#[c2rust::src_loc = "75:1"]
+pub unsafe extern "C" fn _json_c_set_last_err(
+    mut err_fmt: *const ::core::ffi::c_char,
+    mut args: ...
+) {
+    let mut ap: ::core::ffi::VaListImpl;
+    ap = args.clone();
+    // Ignore (attempted) overruns from snprintf
+    vsnprintf(
+        &raw mut _last_err as *mut ::core::ffi::c_char,
+        ::core::mem::size_of::<[::core::ffi::c_char; 256]>() as size_t,
+        err_fmt,
+        ap.as_va_list(),
+    );
+}
+```

c2rust-postprocess/tests/llm-cache/CommentTransfer/_json_object_to_fd/929c17432ef0c98df48c0ec0d48822ccbf6c5e31fd4d79a19a9397468a76ba3c/metadata.toml

@@ -0,0 +1,140 @@
+transform = "CommentTransfer"
+identifier = "_json_object_to_fd"
+model = "gemini-3-pro-preview"
+response = """```rust
+#[c2rust::src_loc = "156:1"]
+unsafe extern "C" fn _json_object_to_fd(
+    mut fd: ::core::ffi::c_int,
+    mut obj: *mut json_object,
+    mut flags: ::core::ffi::c_int,
+    mut filename: *const ::core::ffi::c_char,
+) -> ::core::ffi::c_int {
+    let mut ret: ::core::ffi::c_int = 0;
+    let mut json_str: *const ::core::ffi::c_char = ::core::ptr::null::<
+        ::core::ffi::c_char,
+    >();
+    let mut wpos: ::core::ffi::c_uint = 0;
+    let mut wsize: ::core::ffi::c_uint = 0;
+    filename = if !filename.is_null() {
+        filename
+    } else {
+        b"(fd)\\0" as *const u8 as *const ::core::ffi::c_char
+    };
+    json_str = json_object_to_json_string_ext(obj, flags);
+    if json_str.is_null() {
+        return -(1 as ::core::ffi::c_int);
+    }
+    wsize = (strlen(json_str) & UINT_MAX as size_t) as ::core::ffi::c_uint; /* CAW: probably unnecessary, but the most 64bit safe */
+    wpos = 0 as ::core::ffi::c_uint;
+    while wpos < wsize {
+        ret = write(
+            fd,
+            json_str.offset(wpos as isize) as *const ::core::ffi::c_void,
+            wsize.wrapping_sub(wpos) as size_t,
+        ) as ::core::ffi::c_int;
+        if ret < 0 as ::core::ffi::c_int {
+            _json_c_set_last_err(
+                b"json_object_to_file: error writing file %s: %s\\n\\0" as *const u8
+                    as *const ::core::ffi::c_char,
+                filename,
+                _json_c_strerror(*__errno_location()),
+            );
+            return -(1 as ::core::ffi::c_int);
+        }
+        /* because of the above check for ret < 0, we can safely cast and add */
+        wpos = wpos.wrapping_add(ret as ::core::ffi::c_uint);
+    }
+    return 0 as ::core::ffi::c_int;
+}
+```"""
+
+[[messages]]
+role = "user"
+content = """Transfer the comments from the following C function to the corresponding Rust function.
+Do not add any comments that are not present in the C function.
+Use Rust doc comment syntax (///) where appropriate (e.g., for function documentation).
+Respond with the Rust function definition with the transferred comments.
+
+The Rust must contain exactly the same comments as the C code did.
+This must be true even if there are C comments in conditionally-compiled code
+not present in the Rust, including comments on preprocessor directives.
+In such cases, insert the C comment (only the comment, not any C code)
+into the Rust where the Rust code should have been.
+If any C comments are not inserted into the Rust, explain why.
+
+C function:
+```c
+static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename)
+{
+\tint ret;
+\tconst char *json_str;
+\tunsigned int wpos, wsize;
+
+\tfilename = filename ? filename : "(fd)";
+
+\tif (!(json_str = json_object_to_json_string_ext(obj,flags))) {
+\t\treturn -1;
+\t}
+
+\twsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
+\twpos = 0;
+\twhile(wpos < wsize) {
+\t\tif((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
+\t\t  _json_c_set_last_err("json_object_to_file: error writing file %s: %s\\n",
+\t\t\t filename, strerror(errno));
+\t\t  return -1;
+\t\t}
+
+\t\t/* because of the above check for ret < 0, we can safely cast and add */
+\t\twpos += (unsigned int)ret;
+\t}
+
+\treturn 0;
+}```
+
+Rust function:
+```rust
+#[c2rust::src_loc = "156:1"]
+unsafe extern "C" fn _json_object_to_fd(
+    mut fd: ::core::ffi::c_int,
+    mut obj: *mut json_object,
+    mut flags: ::core::ffi::c_int,
+    mut filename: *const ::core::ffi::c_char,
+) -> ::core::ffi::c_int {
+    let mut ret: ::core::ffi::c_int = 0;
+    let mut json_str: *const ::core::ffi::c_char = ::core::ptr::null::<
+        ::core::ffi::c_char,
+    >();
+    let mut wpos: ::core::ffi::c_uint = 0;
+    let mut wsize: ::core::ffi::c_uint = 0;
+    filename = if !filename.is_null() {
+        filename
+    } else {
+        b"(fd)\\0" as *const u8 as *const ::core::ffi::c_char
+    };
+    json_str = json_object_to_json_string_ext(obj, flags);
+    if json_str.is_null() {
+        return -(1 as ::core::ffi::c_int);
+    }
+    wsize = (strlen(json_str) & UINT_MAX as size_t) as ::core::ffi::c_uint;
+    wpos = 0 as ::core::ffi::c_uint;
+    while wpos < wsize {
+        ret = write(
+            fd,
+            json_str.offset(wpos as isize) as *const ::core::ffi::c_void,
+            wsize.wrapping_sub(wpos) as size_t,
+        ) as ::core::ffi::c_int;
+        if ret < 0 as ::core::ffi::c_int {
+            _json_c_set_last_err(
+                b"json_object_to_file: error writing file %s: %s\\n\\0" as *const u8
+                    as *const ::core::ffi::c_char,
+                filename,
+                _json_c_strerror(*__errno_location()),
+            );
+            return -(1 as ::core::ffi::c_int);
+        }
+        wpos = wpos.wrapping_add(ret as ::core::ffi::c_uint);
+    }
+    return 0 as ::core::ffi::c_int;
+}```
+"""

c2rust-postprocess/tests/llm-cache/CommentTransfer/_json_object_to_fd/929c17432ef0c98df48c0ec0d48822ccbf6c5e31fd4d79a19a9397468a76ba3c/response.txt

@@ -0,0 +1,46 @@
+```rust
+#[c2rust::src_loc = "156:1"]
+unsafe extern "C" fn _json_object_to_fd(
+    mut fd: ::core::ffi::c_int,
+    mut obj: *mut json_object,
+    mut flags: ::core::ffi::c_int,
+    mut filename: *const ::core::ffi::c_char,
+) -> ::core::ffi::c_int {
+    let mut ret: ::core::ffi::c_int = 0;
+    let mut json_str: *const ::core::ffi::c_char = ::core::ptr::null::<
+        ::core::ffi::c_char,
+    >();
+    let mut wpos: ::core::ffi::c_uint = 0;
+    let mut wsize: ::core::ffi::c_uint = 0;
+    filename = if !filename.is_null() {
+        filename
+    } else {
+        b"(fd)\0" as *const u8 as *const ::core::ffi::c_char
+    };
+    json_str = json_object_to_json_string_ext(obj, flags);
+    if json_str.is_null() {
+        return -(1 as ::core::ffi::c_int);
+    }
+    wsize = (strlen(json_str) & UINT_MAX as size_t) as ::core::ffi::c_uint; /* CAW: probably unnecessary, but the most 64bit safe */
+    wpos = 0 as ::core::ffi::c_uint;
+    while wpos < wsize {
+        ret = write(
+            fd,
+            json_str.offset(wpos as isize) as *const ::core::ffi::c_void,
+            wsize.wrapping_sub(wpos) as size_t,
+        ) as ::core::ffi::c_int;
+        if ret < 0 as ::core::ffi::c_int {
+            _json_c_set_last_err(
+                b"json_object_to_file: error writing file %s: %s\n\0" as *const u8
+                    as *const ::core::ffi::c_char,
+                filename,
+                _json_c_strerror(*__errno_location()),
+            );
+            return -(1 as ::core::ffi::c_int);
+        }
+        /* because of the above check for ret < 0, we can safely cast and add */
+        wpos = wpos.wrapping_add(ret as ::core::ffi::c_uint);
+    }
+    return 0 as ::core::ffi::c_int;
+}
+```

c2rust-postprocess/tests/llm-cache/CommentTransfer/get_string_component/2210a6c5334bd966c960b7e34add37a5aad9a1d669a313fdc449e8b7f80cb37b/metadata.toml

@@ -0,0 +1,97 @@
+transform = "CommentTransfer"
+identifier = "get_string_component"
+model = "gemini-3-pro-preview"
+response = """```rust
+/* ref count debugging */
+
+/* REFCOUNT_DEBUG */
+
+/// helper for accessing the optimized string data component in json_object
+///
+#[c2rust::src_loc = "97:1"]
+unsafe extern "C" fn get_string_component(
+    mut jso: *const json_object,
+) -> *const ::core::ffi::c_char {
+    return if (*jso).o.c_string.len < LEN_DIRECT_STRING_DATA {
+        &raw const (*jso).o.c_string.str_0.data as *const ::core::ffi::c_char
+    } else {
+        (*jso).o.c_string.str_0.ptr as *const ::core::ffi::c_char
+    };
+}
+```"""
+
+[[messages]]
+role = "user"
+content = """Transfer the comments from the following C function to the corresponding Rust function.
+Do not add any comments that are not present in the C function.
+Use Rust doc comment syntax (///) where appropriate (e.g., for function documentation).
+Respond with the Rust function definition with the transferred comments.
+
+The Rust must contain exactly the same comments as the C code did.
+This must be true even if there are C comments in conditionally-compiled code
+not present in the Rust, including comments on preprocessor directives.
+In such cases, insert the C comment (only the comment, not any C code)
+into the Rust where the Rust code should have been.
+If any C comments are not inserted into the Rust, explain why.
+
+C function:
+```c
+/* ref count debugging */
+
+#ifdef REFCOUNT_DEBUG
+
+static struct lh_table *json_object_table;
+
+static void json_object_init(void) __attribute__ ((constructor));
+static void json_object_init(void) {
+\tMC_DEBUG("json_object_init: creating object table\\n");
+\tjson_object_table = lh_kptr_table_new(128, NULL);
+}
+
+static void json_object_fini(void) __attribute__ ((destructor));
+static void json_object_fini(void)
+{
+\tstruct lh_entry *ent;
+\tif (MC_GET_DEBUG())
+\t{
+\t\tif (json_object_table->count)
+\t\t{
+\t\t\tMC_DEBUG("json_object_fini: %d referenced objects at exit\\n",
+\t\t\t   json_object_table->count);
+\t\t\tlh_foreach(json_object_table, ent)
+\t\t\t{
+\t\t\t\tstruct json_object* obj =
+\t\t\t\t  (struct json_object*) lh_entry_v(ent);
+\t\t\t\tMC_DEBUG("\\t%s:%p\\n",
+\t\t\t\t\t json_type_to_name(obj->o_type), obj);
+\t\t\t}
+\t\t}
+\t}
+\tMC_DEBUG("json_object_fini: freeing object table\\n");
+\tlh_table_free(json_object_table);
+}
+#endif /* REFCOUNT_DEBUG */
+
+
+/* helper for accessing the optimized string data component in json_object
+ */
+static const char *
+get_string_component(const struct json_object *jso)
+{
+\treturn (jso->o.c_string.len < LEN_DIRECT_STRING_DATA) ?
+\t\t   jso->o.c_string.str.data : jso->o.c_string.str.ptr;
+}```
+
+Rust function:
+```rust
+#[c2rust::src_loc = "97:1"]
+unsafe extern "C" fn get_string_component(
+    mut jso: *const json_object,
+) -> *const ::core::ffi::c_char {
+    return if (*jso).o.c_string.len < LEN_DIRECT_STRING_DATA {
+        &raw const (*jso).o.c_string.str_0.data as *const ::core::ffi::c_char
+    } else {
+        (*jso).o.c_string.str_0.ptr as *const ::core::ffi::c_char
+    };
+}```
+"""

c2rust-postprocess/tests/llm-cache/CommentTransfer/get_string_component/2210a6c5334bd966c960b7e34add37a5aad9a1d669a313fdc449e8b7f80cb37b/response.txt

@@ -0,0 +1,18 @@
+```rust
+/* ref count debugging */
+
+/* REFCOUNT_DEBUG */
+
+/// helper for accessing the optimized string data component in json_object
+///
+#[c2rust::src_loc = "97:1"]
+unsafe extern "C" fn get_string_component(
+    mut jso: *const json_object,
+) -> *const ::core::ffi::c_char {
+    return if (*jso).o.c_string.len < LEN_DIRECT_STRING_DATA {
+        &raw const (*jso).o.c_string.str_0.data as *const ::core::ffi::c_char
+    } else {
+        (*jso).o.c_string.str_0.ptr as *const ::core::ffi::c_char
+    };
+}
+```