try

let regex = Str.regexp pattern in

ignore (Str.search_forward regex code 0);

true

let ast = parse_string program_text in

let symbol_table = Kernelscript.Symbol_table.build_symbol_table ast in

let (annotated_ast, _typed_programs) = Kernelscript.Type_checker.type_check_and_annotate_ast ast in

let ir = Kernelscript.Ir_generator.generate_ir annotated_ast symbol_table filename in

let temp_dir = Filename.temp_file "test_string_struct_fixes" "" in

Unix.unlink temp_dir;

Unix.mkdir temp_dir 0o755;

let _output_file = Kernelscript.Userspace_codegen.generate_userspace_code_from_ir

ir ~output_dir:temp_dir filename in

let generated_file = Filename.concat temp_dir (filename ^ ".c") in

if Sys.file_exists generated_file then (

let ic = open_in generated_file in

let content = really_input_string ic (in_channel_length ic) in

close_in ic;

(* Cleanup *)

Unix.unlink generated_file;

Unix.rmdir temp_dir;

content

) else (

failwith "Failed to generate userspace code file"

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

struct Args {

enable_debug: u32,

interface: str(16),

config_path: str(256),

short_name: str(8)

}

fn main(args: Args) -> i32 {

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_struct_fields" in

(* Should generate correct C struct syntax *)

check bool "interface field correct syntax" true

(contains_pattern result "char interface\\[16\\];");

check bool "config_path field correct syntax" true

(contains_pattern result "char config_path\\[256\\];");

check bool "short_name field correct syntax" true

(contains_pattern result "char short_name\\[8\\];");

(* Should NOT generate incorrect syntax *)

check bool "no invalid char[N] field syntax" false

(contains_pattern result "char\\[16\\] interface");

check bool "no invalid char[256] field syntax" false

(contains_pattern result "char\\[256\\] config_path");

check bool "no invalid char[8] field syntax" false

(contains_pattern result "char\\[8\\] short_name");

(* Should have proper struct declaration *)

check bool "struct declared properly" true

(contains_pattern result "struct Args {");

check bool "non-string fields preserved" true

(contains_pattern result "uint32_t enable_debug;");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

fn process_message(msg: str(64), target: str(32)) -> i32 {

return 0

}

fn main() -> i32 {

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_function_params" in

(* Should generate correct C function parameter syntax *)

check bool "msg parameter correct syntax" true

(contains_pattern result "char msg\\[64\\]");

check bool "target parameter correct syntax" true

(contains_pattern result "char target\\[32\\]");

(* Should NOT generate incorrect parameter syntax *)

check bool "no invalid char[64] msg syntax" false

(contains_pattern result "char\\[64\\] msg");

check bool "no invalid char[32] target syntax" false

(contains_pattern result "char\\[32\\] target");

(* Should have proper function declaration *)

check bool "function declared properly" true

(contains_pattern result "process_message.*char msg\\[64\\].*char target\\[32\\]");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

fn main() -> i32 {

var small_buffer: str(16) = "small"

var medium_buffer: str(64) = "medium"

var large_buffer: str(256) = "large"

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_variable_declarations" in

(* Should declare variables with proper C array syntax *)

check bool "declares char array 16" true

(contains_pattern result "char var_.*\\[16\\]");

check bool "declares char array 64" true

(contains_pattern result "char var_.*\\[64\\]");

check bool "declares char array 256" true

(contains_pattern result "char var_.*\\[256\\]");

(* Should NOT use incorrect syntax *)

check bool "no char[16] var syntax" false

(contains_pattern result "char\\[16\\] var_");

check bool "no char[64] var syntax" false

(contains_pattern result "char\\[64\\] var_");

check bool "no char[256] var syntax" false

(contains_pattern result "char\\[256\\] var_");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

struct Args {

enable_debug: u32,

interface: str(16),

config_file: str(64),

log_level: u32

}

fn main(args: Args) -> i32 {

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_argument_parsing" in

(* Should use strncpy for string arguments *)

check bool "interface uses strncpy" true

(contains_pattern result "strncpy(args.interface, optarg, 16 - 1)");

check bool "config_file uses strncpy" true

(contains_pattern result "strncpy(args.config_file, optarg, 64 - 1)");

(* Should add null termination *)

check bool "interface null termination" true

(contains_pattern result "args.interface\\[16 - 1\\] = '\\\\0'");

check bool "config_file null termination" true

(contains_pattern result "args.config_file\\[64 - 1\\] = '\\\\0'");

(* Should NOT use integer assignment for strings *)

check bool "no integer assignment for interface" false

(contains_pattern result "args.interface = .*atoi");

check bool "no integer assignment for config_file" false

(contains_pattern result "args.config_file = .*atoi");

(* Should still use atoi for integer fields *)

check bool "enable_debug uses atoi" true

(contains_pattern result "args.enable_debug = .*atoi");

check bool "log_level uses atoi" true

(contains_pattern result "args.log_level = .*atoi");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

struct Args {

port: u32,

hostname: str(64),

debug: bool,

interface: str(16)

}

fn main(args: Args) -> i32 {

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_help_text" in

(* Should show <string> for string fields *)

check bool "hostname shows string hint" true

(contains_pattern result "--hostname=<string>");

check bool "interface shows string hint" true

(contains_pattern result "--interface=<string>");

(* Should show appropriate hints for other types *)

check bool "port shows number hint" true

(contains_pattern result "--port=<number>");

check bool "debug shows bool hint" true

(contains_pattern result "--debug=<0|1>");

(* Should NOT show generic <value> for strings *)

check bool "hostname not generic value" false

(contains_pattern result "--hostname=<value>");

check bool "interface not generic value" false

(contains_pattern result "--interface=<value>");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

struct Config {

server_name: str(128),

port: u32,

interface: str(16),

enabled: bool,

log_file: str(256)

}

fn main(config: Config) -> i32 {

var local_buffer: str(32) = "test"

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_comprehensive" in

(* 1. Struct field declarations should be correct *)

check bool "struct server_name correct" true

(contains_pattern result "char server_name\\[128\\];");

check bool "struct interface correct" true

(contains_pattern result "char interface\\[16\\];");

check bool "struct log_file correct" true

(contains_pattern result "char log_file\\[256\\];");

(* 3. Variable declarations should be correct *)

check bool "local variable correct" true

(contains_pattern result "char var_.*\\[32\\]");

(* 4. Argument parsing should use strncpy *)

check bool "server_name parsing correct" true

(contains_pattern result "strncpy(config.server_name, optarg, 128 - 1)");

check bool "interface parsing correct" true

(contains_pattern result "strncpy(config.interface, optarg, 16 - 1)");

check bool "log_file parsing correct" true

(contains_pattern result "strncpy(config.log_file, optarg, 256 - 1)");

(* 5. Help text should show string hints *)

check bool "server_name help hint" true

(contains_pattern result "--server_name=<string>");

check bool "interface help hint" true

(contains_pattern result "--interface=<string>");

check bool "log_file help hint" true

(contains_pattern result "--log_file=<string>");

(* 6. Non-string fields should be unchanged *)

check bool "port field preserved" true

(contains_pattern result "uint32_t port;");

check bool "enabled field preserved" true

(contains_pattern result "bool enabled;");

check bool "port parsing preserved" true

(contains_pattern result "config.port = .*atoi");

check bool "enabled parsing preserved" true

(contains_pattern result "config.enabled = .*atoi.*!= 0");

(* 7. Should NOT have any invalid syntax *)

check bool "no invalid field syntax" false

(contains_pattern result "char\\[[0-9]+\\] server_name");

check bool "no invalid variable syntax" false

(contains_pattern result "char\\[[0-9]+\\] var_");

with

let program_text = {|

@xdp fn test(ctx: *xdp_md) -> xdp_action {

return 2

}

struct EdgeCases {

tiny: str(1),

small: str(8),

medium: str(64),

large: str(512),

huge: str(1024)

}

fn main(args: EdgeCases) -> i32 {

return 0

}

|} in

try

let result = generate_userspace_code_from_program program_text "test_edge_cases" in

(* Should handle all sizes correctly *)

check bool "tiny field correct" true

(contains_pattern result "char tiny\\[1\\];");

check bool "small field correct" true

(contains_pattern result "char small\\[8\\];");

check bool "medium field correct" true

(contains_pattern result "char medium\\[64\\];");

check bool "large field correct" true

(contains_pattern result "char large\\[512\\];");

check bool "huge field correct" true

(contains_pattern result "char huge\\[1024\\];");

(* Argument parsing should handle all sizes *)

check bool "tiny parsing correct" true

(contains_pattern result "strncpy(args.tiny, optarg, 1 - 1)");

check bool "small parsing correct" true

(contains_pattern result "strncpy(args.small, optarg, 8 - 1)");

check bool "medium parsing correct" true

(contains_pattern result "strncpy(args.medium, optarg, 64 - 1)");

check bool "large parsing correct" true

(contains_pattern result "strncpy(args.large, optarg, 512 - 1)");

check bool "huge parsing correct" true

(contains_pattern result "strncpy(args.huge, optarg, 1024 - 1)");

with

(* This test verifies that the original compilation error is resolved.

let program_text = {|

struct ConfigData {

interface_name: str(16),

log_message: str(20)

}

config test_config {

enable_logging: bool = true,

}

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var local_str: str(32) = "test string"

if (test_config.enable_logging) {

print("Dropping packets")

return 2

}

return 1

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Kernelscript.Symbol_table.build_symbol_table ast in

let (annotated_ast, _typed_programs) = Kernelscript.Type_checker.type_check_and_annotate_ast ast in

let ir_multi = Kernelscript.Ir_generator.generate_ir annotated_ast symbol_table "test_string_typedef" in

(* Generate eBPF C code *)

let ebpf_code = Kernelscript.Ebpf_c_codegen.generate_c_multi_program ir_multi in

(* The specific fix: check that string typedefs are generated *)

check bool "eBPF code contains string typedef comment" true

(contains_pattern ebpf_code "String type definitions");

check bool "eBPF code contains string typedef definition" true

(contains_pattern ebpf_code "typedef struct { char data\\[[0-9]+\\]; __u16 len; } str_[0-9]+_t;");

(* Check that string types are used somewhere in the code (struct fields, variables, etc.) *)

let has_string_type_usage =

contains_pattern ebpf_code "str_[0-9]+_t" ||

contains_pattern ebpf_code "str_16_t" ||

contains_pattern ebpf_code "str_20_t" ||

contains_pattern ebpf_code "str_32_t"

in

check bool "eBPF code uses string types somewhere" true has_string_type_usage;

(* Verify that bpf_printk works correctly with direct string literals (our bug fix) *)

check bool "bpf_printk uses direct string literals correctly" true

(contains_pattern ebpf_code "bpf_printk(\"[^\"]*\")");

with