line: int;

column: int;

filename: string

| NoPrealloc (* BPF_F_NO_PREALLOC *)

| NoCommonLru (* BPF_F_NO_COMMON_LRU *)

| NumaNode of int (* BPF_F_NUMA_NODE with node ID *)

| Rdonly (* BPF_F_RDONLY *)

| Wronly (* BPF_F_WRONLY *)

(* Primitive types *)

| U8 | U16 | U32 | U64 | I8 | I16 | I32 | I64 | Bool | Char | Void

| Str of int (* Fixed-size string str<N> *)

(* Composite types *)

| Array of bpf_type * int

| Pointer of bpf_type

| UserType of string

(* Extended types for advanced type system *)

| Struct of string

| Enum of string

| Option of bpf_type

| Result of bpf_type * bpf_type

| Function of bpf_type list * bpf_type

| Map of bpf_type * bpf_type * map_type * int (* key_type, value_type, map_type, size *)

(* Built-in context types *)

| Xdp_md

| Xdp_action

(* Program reference types *)

| ProgramRef of program_type

(* Program handle type - represents a loaded program *)

| ProgramHandle

(* Ring buffer reference type - represents a ring buffer for dispatch *)

| RingbufRef of bpf_type (* value type *)

| Ringbuf of bpf_type * int (* value_type, size - ring buffer object *)

(* Null type - represents null pointers, compatible with any pointer type *)

max_entries: int;

key_size: int option;

value_size: int option;

flags: map_flag list;

name: string;

key_type: bpf_type;

value_type: bpf_type;

map_type: map_type;

config: map_config;

is_global: bool;

is_pinned: bool;

map_pos: position;

let of_string s =

try

(* Try signed parsing first *)

Signed64 (Int64.of_string s)

with Failure _ ->

(* Handle unsigned 64-bit integers that exceed signed range *)

try

(* Parse as unsigned using custom logic for large values *)

let parse_uint64 str =

let len = String.length str in

let rec aux i acc =

if i >= len then acc

else

let digit = Char.code str.[i] - Char.code '0' in

if digit < 0 || digit > 9 then

failwith "Invalid digit"

else

let new_acc = Int64.add (Int64.mul acc 10L) (Int64.of_int digit) in

aux (i + 1) new_acc

in

aux 0 0L

in

let uint64_val = parse_uint64 s in

Unsigned64 uint64_val

with _ ->

failwith ("Invalid integer literal: " ^ s)

let to_string = function

| Signed64 i -> Int64.to_string i

| Unsigned64 i ->

(* Handle unsigned 64-bit values correctly *)

if Int64.compare i 0L >= 0 then

Int64.to_string i

else

(* For negative Int64.t values representing large unsigned numbers *)

(* Use Printf to format as unsigned *)

Printf.sprintf "%Lu" i

let to_c_literal = function

| Signed64 i -> Int64.to_string i ^ "LL"

| Unsigned64 i ->

(* Use unsigned formatting for C literals *)

if Int64.compare i 0L >= 0 then

Int64.to_string i ^ "ULL"

else

Printf.sprintf "%LuULL" i

let is_negative = function

| Signed64 i -> Int64.compare i 0L < 0

| Unsigned64 _ -> false (* Unsigned values are never conceptually negative *)

let to_int64 = function

| Signed64 i -> i

| Unsigned64 i -> i

let compare_with_zero = function

| Signed64 i -> Int64.compare i 0L

| Unsigned64 i -> if Int64.compare i 0L < 0 then 1 else Int64.compare i 0L (* Handle unsigned wrap-around *)

| IntLit of integer_value * string option (* value * original_representation *)

| StringLit of string

| CharLit of char

| BoolLit of bool

| ArrayLit of array_init_style (* Enhanced array initialization *)

current_program: program_type option;

accessing_programs: program_type list; (* Programs that access this expression *)

data_flow_direction: data_flow_direction option;

expr_desc: expr_desc;

expr_pos: position;

mutable expr_type: bpf_type option; (* filled by type checker *)

mutable type_checked: bool; (* whether type checking completed *)

mutable program_context: program_context option; (* multi-program context *)

mutable map_scope: map_scope option; (* map access scope *)

| Literal of literal

| Identifier of string

| ConfigAccess of string * string (* config_name, field_name *)

| Call of expr * expr list (* Unified call: callee_expression * arguments *)

| TailCall of string * expr list (* function_name, arguments - for explicit tail calls *)

| ModuleCall of module_call (* module.function(args) calls *)

| ArrayAccess of expr * expr

| FieldAccess of expr * string

| ArrowAccess of expr * string (* pointer->field *)

| BinaryOp of expr * binary_op * expr

| UnaryOp of unary_op * expr

| StructLiteral of string * (string * expr) list

| Match of expr * match_arm list (* match (expr) { arms } *)

| New of bpf_type (* new Type() - object allocation *)

module_name: string;

function_name: string;

args: expr list;

call_pos: position;

arm_pattern: match_pattern;

arm_body: match_arm_body;

arm_pos: position;

| ExprStmt of expr

| Assignment of string * expr

| CompoundAssignment of string * binary_op * expr (* var op= expr *)

| CompoundIndexAssignment of expr * expr * binary_op * expr (* map[key] op= expr *)

| CompoundFieldIndexAssignment of expr * expr * string * binary_op * expr

(* map[key].field op= expr *)

| FieldAssignment of expr * string * expr (* object.field = value *)

| ArrowAssignment of expr * string * expr (* pointer->field = value *)

| IndexAssignment of expr * expr * expr (* map[key] = value *)

| Declaration of string * bpf_type option * expr option

| ConstDeclaration of string * bpf_type option * expr (* const name : type = value *)

| Return of expr option

| If of expr * statement list * statement list option

| IfLet of string * expr * statement list * statement list option

(* if (var name = expr) { then_stmts } else { else_stmts }

| For of string * expr * expr * statement list

| ForIter of string * string * expr * statement list (* for (index, value) in expr.iter() { ... } *)

| While of expr * statement list

| Delete of delete_target (* Unified delete: map[key] or pointer *)

| Break

| Continue

| Try of statement list * catch_clause list (* try { statements } catch clauses *)

| Throw of expr (* throw integer_expression *)

catch_pattern: catch_pattern;

catch_body: statement list;

catch_pos: position;

func_name: string;

func_params: (string * bpf_type) list;

func_return_type: return_type_spec option;

func_body: statement list;

func_scope: function_scope;

func_pos: position;

(* Tail call dependency tracking *)

mutable tail_call_targets: string list; (* Functions this function can tail call *)

mutable is_tail_callable: bool; (* Whether this function can be tail-called *)

struct_name: string;

struct_fields: (string * bpf_type) list;

struct_attributes: attribute list; (* Added attributes for @struct_ops etc. *)

struct_pos: position;

prog_name: string;

prog_type: program_type;

prog_functions: function_def list;

prog_maps: map_declaration list; (* Maps local to this program *)

prog_structs: struct_def list; (* Structs local to this program *)

prog_target: string option; (* Target for kprobe/tracepoint programs *)

prog_pos: position;

attr_list: attribute list;

attr_function: function_def;

attr_pos: position;

(* Tail call dependency analysis *)

mutable program_type: program_type option; (* Extracted from attributes *)

mutable tail_call_dependencies: string list; (* Other attributed functions this calls *)

field_name: string;

field_type: bpf_type;

field_default: literal option;

field_pos: position;

config_name: string;

config_fields: config_field list;

config_pos: position;

global_var_name: string;

global_var_type: bpf_type option;

global_var_init: expr option;

global_var_pos: position;

is_local: bool; (* true if declared with 'local' keyword *)

is_pinned: bool; (* true if declared with 'pin' keyword *)

global_var_attributes: attribute list;

impl_name: string; (* The struct_ops name like "tcp_congestion_ops" *)

impl_attributes: attribute list; (* @struct_ops("tcp_congestion_ops") *)

impl_items: impl_block_item list; (* Functions and static fields *)

impl_pos: position;

module_name: string; (* Local name for the imported module *)

source_path: string; (* File path *)

source_type: import_source_type; (* Determined from file extension *)

import_pos: position;

extern_name: string;

extern_params: (string * bpf_type) list;

extern_return_type: bpf_type option;

extern_pos: position;

| AttributedFunction of attributed_function

| GlobalFunction of function_def

| TypeDef of type_def

| MapDecl of map_declaration

| ConfigDecl of config_declaration

| StructDecl of struct_def

| GlobalVarDecl of global_variable_declaration

| ImplBlock of impl_block

| ImportDecl of import_declaration

| ExternKfuncDecl of extern_kfunc_declaration

expr_desc = desc;

expr_pos = pos;

expr_type = None;

type_checked = false;

program_context = None;

map_scope = None;

func_name = name;

func_params = params;

func_return_type = return_type;

func_body = body;

func_scope = scope;

func_pos = pos;

tail_call_targets = [];

is_tail_callable = false;

prog_name = name;

prog_type = prog_type;

prog_functions = functions;

prog_maps = [];

prog_structs = [];

prog_target = None;

prog_pos = pos;

prog_name = name;

prog_type = prog_type;

prog_functions = functions;

prog_maps = maps;

prog_structs = [];

prog_target = None;

prog_pos = pos;

prog_name = name;

prog_type = prog_type;

prog_functions = functions;

prog_maps = maps;

prog_structs = structs;

prog_target = None;

prog_pos = pos;

attr_list = attrs;

attr_function = func;

attr_pos = pos;

program_type = None;

tail_call_dependencies = [];

extern_name = name;

extern_params = params;

extern_return_type = return_type;

extern_pos = pos;

{

max_entries;

key_size;

value_size;

flags;

name;

key_type;

value_type;

map_type;

config;

is_global;

is_pinned;

map_pos = pos;

struct_name = name;

struct_fields = fields;

struct_attributes = attributes;

struct_pos = pos;

field_name = name;

field_type = field_type;

field_default = default;

field_pos = pos;

config_name = name;

config_fields = fields;

config_pos = pos;

global_var_name = name;

global_var_type = typ;

global_var_init = init;

global_var_pos = pos;

is_local;

is_pinned;

global_var_attributes = attributes;

impl_name = name;

impl_attributes = attributes;

impl_items = items;

impl_pos = pos;

arm_pattern = pattern;

arm_body = body;

arm_pos = pos;

let extension = Filename.extension file_path in

match String.lowercase_ascii extension with

| ".ks" -> KernelScript

| ".py" -> Python

module_name;

source_path;

source_type = detect_import_source_type source_path;

import_pos = pos;

module_name;

function_name;

args;

call_pos = pos;

| Xdp -> "xdp"

| Tc -> "tc"

| Probe Fprobe -> "fprobe"

| Probe Kprobe -> "kprobe"

| Tracepoint -> "tracepoint"

| StructOps -> "struct_ops"

| Hash -> "hash"

| Array -> "array"

| Percpu_hash -> "percpu_hash"

| Percpu_array -> "percpu_array"

| NoPrealloc -> "no_prealloc"

| NoCommonLru -> "no_common_lru"

| NumaNode n -> "numa_node(" ^ string_of_int n ^ ")"

| Rdonly -> "rdonly"

| Wronly -> "wronly"

| U8 -> "u8"

| U16 -> "u16"

| U32 -> "u32"

| U64 -> "u64"

| I8 -> "i8"

| I16 -> "i16"

| I32 -> "i32"

| I64 -> "i64"

| Bool -> "bool"

| Char -> "char"

| Void -> "void"

| Str size -> Printf.sprintf "str(%d)" size

| Array (t, size) -> Printf.sprintf "[%s; %d]" (string_of_bpf_type t) size

| Pointer t -> Printf.sprintf "*%s" (string_of_bpf_type t)

| UserType name -> name

| Struct name -> Printf.sprintf "struct %s" name

| Enum name -> Printf.sprintf "enum %s" name

| Option t -> Printf.sprintf "option %s" (string_of_bpf_type t)

| Result (t1, t2) -> Printf.sprintf "result (%s, %s)" (string_of_bpf_type t1) (string_of_bpf_type t2)

| Function (params, return_type) ->

Printf.sprintf "function (%s) -> %s"

(String.concat ", " (List.map string_of_bpf_type params))

(string_of_bpf_type return_type)

| Map (key_type, value_type, map_type, size) ->

Printf.sprintf "map (%s, %s, %s, %d)"

(string_of_bpf_type key_type)

(string_of_bpf_type value_type)

(string_of_map_type map_type)

size

| Xdp_md -> "xdp_md"

| Xdp_action -> "xdp_action"

| ProgramRef pt -> string_of_program_type pt

| ProgramHandle -> "ProgramHandle"

| RingbufRef value_type -> Printf.sprintf "ringbuf_ref<%s>" (string_of_bpf_type value_type)

| Ringbuf (value_type, size) -> Printf.sprintf "ringbuf<%s>(%d)" (string_of_bpf_type value_type) size

| IntLit (int_val, original_opt) ->

(match original_opt with

| Some orig -> orig (* Use original format if available *)

| None -> IntegerValue.to_string int_val)

| StringLit s -> Printf.sprintf "\"%s\"" s

| CharLit c -> Printf.sprintf "'%c'" c

| BoolLit b -> string_of_bool b

| ArrayLit (FillArray lit) -> Printf.sprintf "[%s]" (string_of_literal lit)

| ArrayLit (ExplicitArray literals) ->

Printf.sprintf "[%s]" (String.concat ", " (List.map string_of_literal literals))

| ArrayLit (ZeroArray) -> "[]"

| Add -> "+"

| Sub -> "-"

| Mul -> "*"

| Div -> "/"

| Mod -> "%"

| Eq -> "=="

| Ne -> "!="

| Lt -> "<"

| Le -> "<="

| Gt -> ">"

| Ge -> ">="

| And -> "&&"

| Not -> "!"

| Neg -> "-"

| Deref -> "*"

match expr.expr_desc with

| Literal lit -> string_of_literal lit

| Identifier name -> name

| ConfigAccess (config_name, field_name) ->

Printf.sprintf "%s.%s" config_name field_name

| Call (callee_expr, args) ->

Printf.sprintf "%s(%s)" (string_of_expr callee_expr)

(String.concat ", " (List.map string_of_expr args))

| TailCall (name, args) ->

Printf.sprintf "%s(%s)" name

(String.concat ", " (List.map string_of_expr args))

| ModuleCall module_call ->

Printf.sprintf "%s.%s(%s)"

module_call.module_name

module_call.function_name

(String.concat ", " (List.map string_of_expr module_call.args))

| ArrayAccess (arr, idx) ->

Printf.sprintf "%s[%s]" (string_of_expr arr) (string_of_expr idx)

| FieldAccess (obj, field) ->

Printf.sprintf "%s.%s" (string_of_expr obj) field

| ArrowAccess (obj, field) ->

Printf.sprintf "%s->%s" (string_of_expr obj) field

| BinaryOp (left, op, right) ->

Printf.sprintf "(%s %s %s)"

(string_of_expr left) (string_of_binary_op op) (string_of_expr right)

| UnaryOp (op, expr) ->

Printf.sprintf "(%s%s)" (string_of_unary_op op) (string_of_expr expr)

| StructLiteral (struct_name, field_assignments) ->

let field_strs = List.map (fun (field_name, expr) ->

Printf.sprintf "%s = %s" field_name (string_of_expr expr)

) field_assignments in

Printf.sprintf "struct %s {\n %s\n}" struct_name (String.concat ",\n " field_strs)

| Match (expr, arms) ->

let arms_str = String.concat ",\n " (List.map string_of_match_arm arms) in

Printf.sprintf "match (%s) {\n %s\n}" (string_of_expr expr) arms_str

| New typ -> Printf.sprintf "new %s()" (string_of_bpf_type typ)

| NewWithFlag (typ, flag_expr) ->

let body_str = match arm.arm_body with

| SingleExpr expr -> string_of_expr expr

| Block stmts ->

let stmt_strs = List.map string_of_stmt stmts in

Printf.sprintf "{\n %s\n }" (String.concat "\n " stmt_strs)

in

Printf.sprintf "%s: %s"

(string_of_match_pattern arm.arm_pattern)

match stmt.stmt_desc with

| ExprStmt expr -> string_of_expr expr ^ ";"

| Assignment (name, expr) ->

Printf.sprintf "%s = %s;" name (string_of_expr expr)

| CompoundAssignment (name, op, expr) ->

Printf.sprintf "%s %s= %s;" name (string_of_binary_op op) (string_of_expr expr)

| CompoundIndexAssignment (map_expr, key_expr, op, value_expr) ->

Printf.sprintf "%s[%s] %s= %s;" (string_of_expr map_expr) (string_of_expr key_expr) (string_of_binary_op op) (string_of_expr value_expr)

| CompoundFieldIndexAssignment (map_expr, key_expr, field, op, value_expr) ->

Printf.sprintf "%s[%s].%s %s= %s;"

(string_of_expr map_expr) (string_of_expr key_expr) field

(string_of_binary_op op) (string_of_expr value_expr)

| FieldAssignment (obj_expr, field, value_expr) ->

Printf.sprintf "%s.%s = %s;" (string_of_expr obj_expr) field (string_of_expr value_expr)

| ArrowAssignment (obj_expr, field, value_expr) ->

Printf.sprintf "%s->%s = %s;" (string_of_expr obj_expr) field (string_of_expr value_expr)

| IndexAssignment (map_expr, key_expr, value_expr) ->

Printf.sprintf "%s[%s] = %s;" (string_of_expr map_expr) (string_of_expr key_expr) (string_of_expr value_expr)

| Declaration (name, typ_opt, expr_opt) ->

let typ_str = match typ_opt with

| Some t -> ": " ^ string_of_bpf_type t

| None -> ""

in

let init_str = match expr_opt with

| Some expr -> " = " ^ string_of_expr expr

| None -> ""

in

Printf.sprintf "var %s%s%s;" name typ_str init_str

| ConstDeclaration (name, typ_opt, expr) ->

let typ_str = match typ_opt with

| Some t -> ": " ^ string_of_bpf_type t

| None -> ""

in

Printf.sprintf "const %s%s = %s;" name typ_str (string_of_expr expr)

| Return None -> "return;"

| Return (Some expr) -> Printf.sprintf "return %s;" (string_of_expr expr)

| If (cond, then_stmts, else_opt) ->

let then_str = String.concat " " (List.map string_of_stmt then_stmts) in

let else_str = match else_opt with

| None -> ""

| Some else_stmts ->

" else { " ^ String.concat " " (List.map string_of_stmt else_stmts) ^ " }"

in

Printf.sprintf "if (%s) { %s }%s" (string_of_expr cond) then_str else_str

| IfLet (name, expr, then_stmts, else_opt) ->

let then_str = String.concat " " (List.map string_of_stmt then_stmts) in

let else_str = match else_opt with

| None -> ""

| Some else_stmts ->

" else { " ^ String.concat " " (List.map string_of_stmt else_stmts) ^ " }"

in

Printf.sprintf "if (var %s = %s) { %s }%s" name (string_of_expr expr) then_str else_str

| For (var, start, end_, body) ->

let body_str = String.concat " " (List.map string_of_stmt body) in

Printf.sprintf "for (%s in %s..%s) { %s }"

var (string_of_expr start) (string_of_expr end_) body_str

| ForIter (index_var, value_var, iterable, body) ->

let body_str = String.concat " " (List.map string_of_stmt body) in

Printf.sprintf "for (%s, %s) in %s.iter() { %s }"

index_var value_var (string_of_expr iterable) body_str

| While (cond, body) ->

let body_str = String.concat " " (List.map string_of_stmt body) in

Printf.sprintf "while (%s) { %s }" (string_of_expr cond) body_str

| Delete (DeleteMapEntry (map_expr, key_expr)) ->

Printf.sprintf "delete %s[%s];" (string_of_expr map_expr) (string_of_expr key_expr)

| Delete (DeletePointer ptr_expr) ->

Printf.sprintf "delete %s;" (string_of_expr ptr_expr)

| Break -> "break;"

| Continue -> "continue;"

| Try (statements, catch_clauses) ->

let statements_str = String.concat " " (List.map string_of_stmt statements) in

let catch_clauses_str = String.concat " " (List.map (fun _ -> "catch {...}") catch_clauses) in

Printf.sprintf "try { %s } %s" statements_str catch_clauses_str

| Throw expr ->

Printf.sprintf "throw %s;" (string_of_expr expr)

| Defer expr ->

let params_str = String.concat ", "

(List.map (fun (name, typ) ->

Printf.sprintf "%s: %s" name (string_of_bpf_type typ)) func.func_params) in

let return_str = match func.func_return_type with

| None -> ""

| Some (Unnamed t) -> " -> " ^ string_of_bpf_type t

| Some (Named (name, t)) -> " -> " ^ name ^ ": " ^ string_of_bpf_type t

in

let body_str = String.concat "\n " (List.map string_of_stmt func.func_body) in

Printf.sprintf "fn %s(%s)%s {\n %s\n}"

let functions_str = String.concat "\n\n "

(List.map string_of_function prog.prog_functions) in

Printf.sprintf "program %s : %s {\n %s\n}"

| AttributedFunction attr_func -> string_of_attributed_function attr_func

| GlobalFunction func -> string_of_function func

| TypeDef td ->

let type_str = match td with

| StructDef (name, fields, _) ->

Printf.sprintf "struct %s {\n %s\n}" name

(String.concat "\n " (List.map (fun (name, typ) ->

Printf.sprintf "%s: %s;" name (string_of_bpf_type typ)) fields))

| EnumDef (name, values, _) ->

Printf.sprintf "enum %s {\n %s\n}" name

(String.concat ",\n " (List.map (fun (name, opt) ->

match opt with

| None -> name

| Some v -> Printf.sprintf "%s = %s" name (IntegerValue.to_string v)) values))

| TypeAlias (name, typ, _) ->

Printf.sprintf "type %s = %s;" name (string_of_bpf_type typ)

in

type_str

| MapDecl md ->

let pin_str = if md.is_pinned then "pin " else "" in

let flags_str = if md.config.flags = [] then "" else

"@flags(" ^ (String.concat " | " (List.map string_of_map_flag md.config.flags)) ^ ") "

in

Printf.sprintf "%s%smap<%s, %s> %s : %s(%s)"

flags_str

pin_str

(string_of_bpf_type md.key_type)

(string_of_bpf_type md.value_type)

md.name

(string_of_map_type md.map_type)

(string_of_int md.config.max_entries)

| ConfigDecl config_decl ->

let fields_str = String.concat ",\n " (List.map (fun field ->

let default_str = match field.field_default with

| Some lit -> " = " ^ string_of_literal lit

| None -> ""

in

Printf.sprintf "%s: %s%s" field.field_name (string_of_bpf_type field.field_type) default_str

) config_decl.config_fields) in

Printf.sprintf "config %s {\n %s\n}" config_decl.config_name fields_str

| StructDecl struct_def ->

let attrs_str = if struct_def.struct_attributes = [] then "" else

(String.concat " " (List.map string_of_attribute struct_def.struct_attributes)) ^ "\n" in

let fields_str = String.concat ",\n " (List.map (fun (name, typ) ->

Printf.sprintf "%s: %s" name (string_of_bpf_type typ)

) struct_def.struct_fields) in

Printf.sprintf "%sstruct %s {\n %s\n}" attrs_str struct_def.struct_name fields_str

| GlobalVarDecl decl ->

let attrs_str = if decl.global_var_attributes = [] then "" else

(String.concat " " (List.map string_of_attribute decl.global_var_attributes)) ^ "\n" in

let pin_str = if decl.is_pinned then "pin " else "" in

let local_str = if decl.is_local then "local " else "" in

let type_str = match decl.global_var_type with

| None -> ""

| Some t -> ": " ^ string_of_bpf_type t

in

let init_str = match decl.global_var_init with

| None -> ""

| Some expr -> " = " ^ string_of_expr expr

in

Printf.sprintf "%s%s%svar %s%s%s;" attrs_str pin_str local_str decl.global_var_name type_str init_str

| ImplBlock impl_block ->

let attrs_str = String.concat " " (List.map string_of_attribute impl_block.impl_attributes) in

let items_str = String.concat "\n " (List.map (function

| ImplFunction func -> string_of_function func

| ImplStaticField (name, expr) -> Printf.sprintf "%s: %s," name (string_of_expr expr)

) impl_block.impl_items) in

Printf.sprintf "%s impl %s {\n %s\n}" attrs_str impl_block.impl_name items_str

| ImportDecl import_decl ->

let source_type_str = match import_decl.source_type with

| KernelScript -> "KernelScript"

| Python -> "Python"

in

Printf.sprintf "import %s from \"%s\" // %s"

import_decl.module_name

import_decl.source_path

source_type_str

| ExternKfuncDecl extern_decl ->

let params_str = String.concat ", " (List.map (fun (name, typ) ->

Printf.sprintf "%s: %s" name (string_of_bpf_type typ)

) extern_decl.extern_params) in

let return_str = match extern_decl.extern_return_type with