sokol/bindgen/gen_rust.py

# -------------------------------------------------------------------------------
#   Generate rust bindings.
#
#   rust coding style:
#   - types are PascalCase
#   - otherwise snake_case
# -------------------------------------------------------------------------------
import gen_ir
import os, shutil, sys

import gen_util as util

module_names = {
    "slog_": "log",
    "sg_": "gfx",
    "sapp_": "app",
    "stm_": "time",
    "saudio_": "audio",
    "sgl_": "gl",
    "sdtx_": "debugtext",
    "sshape_": "shape",
    "sapp_sg": "glue",
    "simgui_": "imgui",
    "sg_imgui_": "gfx_imgui",
}

module_requires_rust_feature = {
    module_names["simgui_"]: "imgui",
    module_names["sg_imgui_"]: "imgui",
}

c_source_paths = {
    "slog_": "sokol-rust/src/sokol/c/sokol_log.c",
    "sg_": "sokol-rust/src/sokol/c/sokol_gfx.c",
    "sapp_": "sokol-rust/src/sokol/c/sokol_app.c",
    "stm_": "sokol-rust/src/sokol/c/sokol_time.c",
    "saudio_": "sokol-rust/src/sokol/c/sokol_audio.c",
    "sgl_": "sokol-rust/src/sokol/c/sokol_gl.c",
    "sdtx_": "sokol-rust/src/sokol/c/sokol_debugtext.c",
    "sshape_": "sokol-rust/src/sokol/c/sokol_shape.c",
    "sapp_sg": "sokol-rust/src/sokol/c/sokol_glue.c",
    "simgui_": "sokol-rust/src/sokol/c/sokol_imgui.c",
    "sg_imgui_": "sokol-rust/src/sokol/c/sokol_gfx_imgui.c",
}

ignores = [
    "sdtx_printf",
    "sdtx_vprintf",
    # "sg_install_trace_hooks",
    # "sg_trace_hooks",
]

range_struct_name = "Range"

# functions that need to be exposed as 'raw' C callbacks without a rust wrapper function
c_callbacks = ["slog_func"]

# NOTE: syntax for function results: "func_name.RESULT"
overrides = {
    "type": "_type",
    "ref": "_ref",

    "sg_apply_uniforms.ub_index": "uintptr_t",
    "sg_draw.base_element": "uintptr_t",
    "sg_draw.num_elements": "uintptr_t",
    "sg_draw.num_instances": "uintptr_t",
    "sshape_element_range_t.base_element": "uintptr_t",
    "sshape_element_range_t.num_elements": "uintptr_t",
    "sdtx_font.font_index": "uintptr_t",

    "sdtx_move": "sdtx_move_cursor",
    "sdtx_move_x": "sdtx_move_cursor_x",
    "sdtx_move_y": "sdtx_move_cursor_y",

    "sg_image_type::SG_IMAGETYPE_2D": "SG_IMAGEYPE_DIM2",
    "sg_image_type::SG_IMAGETYPE_3D": "SG_IMAGETYPE_DIM3",

    "sapp_keycode::SAPP_KEYCODE_0": "SAPP_KEYCODE_NUM0",
    "sapp_keycode::SAPP_KEYCODE_1": "SAPP_KEYCODE_NUM1",
    "sapp_keycode::SAPP_KEYCODE_2": "SAPP_KEYCODE_NUM2",
    "sapp_keycode::SAPP_KEYCODE_3": "SAPP_KEYCODE_NUM3",
    "sapp_keycode::SAPP_KEYCODE_4": "SAPP_KEYCODE_NUM4",
    "sapp_keycode::SAPP_KEYCODE_5": "SAPP_KEYCODE_NUM5",
    "sapp_keycode::SAPP_KEYCODE_6": "SAPP_KEYCODE_NUM6",
    "sapp_keycode::SAPP_KEYCODE_7": "SAPP_KEYCODE_NUM7",
    "sapp_keycode::SAPP_KEYCODE_8": "SAPP_KEYCODE_NUM8",
    "sapp_keycode::SAPP_KEYCODE_9": "SAPP_KEYCODE_NUM9",

    # "sgl_error": "sgl_get_error",  # 'error' is reserved in zig
    # "sgl_deg": "sgl_as_degrees",
    # "sgl_rad": "sgl_as_radians",
    # "sg_context_desc.color_format": "int",
    # "SGL_NO_ERROR": "SGL_ERROR_NO_ERROR",
    # "sg_context_desc.depth_format": "int",
}

prim_types = {
    "int": "i32",
    "bool": "bool",
    "char": "core::ffi::c_char",
    "int8_t": "i8",
    "uint8_t": "u8",
    "int16_t": "i16",
    "uint16_t": "u16",
    "int32_t": "i32",
    "uint32_t": "u32",
    "int64_t": "i64",
    "uint64_t": "u64",
    "float": "f32",
    "double": "f64",
    "uintptr_t": "usize",
    "intptr_t": "isize",
    "size_t": "usize",
}

prim_defaults = {
    "int": "0",
    "bool": "false",
    "int8_t": "0",
    "uint8_t": "0",
    "int16_t": "0",
    "uint16_t": "0",
    "int32_t": "0",
    "uint32_t": "0",
    "int64_t": "0",
    "uint64_t": "0",
    "float": "0.0",
    "double": "0.0",
    "uintptr_t": "0",
    "intptr_t": "0",
    "size_t": "0",
    "char": "0",
}

special_constant_types = {
    "SG_INVALID_ID": "u32"
}

struct_types = []
enum_types = []
enum_items = {}
out_lines = ""


def reset_globals():
    global struct_types
    global enum_types
    global enum_items
    global out_lines
    struct_types = []
    enum_types = []
    enum_items = {}
    out_lines = ""


def l(s):
    global out_lines
    out_lines += s + "\n"


def as_rust_prim_type(s):
    return prim_types[s]


def as_upper_snake_case(s, prefix):
    outp = s.lower()
    if outp.startswith(prefix):
        outp = outp[len(prefix):]
    return outp.upper()


# prefix_bla_blub(_t) => (dep::)BlaBlub
def as_rust_struct_type(s, prefix):
    parts = s.lower().split("_")
    outp = "" if s.startswith(prefix) else f"{parts[0]}::"
    for part in parts[1:]:
        # ignore '_t' type postfix
        if part != "t":
            outp += part.capitalize()
    return outp


# prefix_bla_blub(_t) => (dep::)BlaBlub
def as_rust_enum_type(s, prefix):
    parts = s.lower().split("_")
    outp = "" if s.startswith(prefix) else f"{parts[0]}::"
    for part in parts[1:]:
        # ignore '_t' type postfix
        if part != "t":
            outp += part.capitalize()
    return outp


def check_override(name, default=None):
    if name in overrides:
        return overrides[name]
    elif default is None:
        return name
    else:
        return default


def check_ignore(name):
    return name in ignores


# PREFIX_ENUM_BLA_BLA => BlaBla, _PREFIX_ENUM_BLA_BLA => BlaBla
def as_enum_item_name(s):
    parts = s.lstrip("_").split("_")
    outp = ""
    for i, part in enumerate(parts[2:]):
        # TODO: What to do with enum fields starting with numbers?
        outp += part.capitalize()

    return outp


def enum_default_item(enum_name):
    return enum_items[enum_name][0]


def is_prim_type(s):
    return s in prim_types


def is_struct_type(s):
    return s in struct_types


def is_enum_type(s):
    return s in enum_types


def is_const_prim_ptr(s):
    for prim_type in prim_types:
        if s == f"const {prim_type} *":
            return True
    return False


def is_prim_ptr(s):
    for prim_type in prim_types:
        if s == f"{prim_type} *":
            return True
    return False


def is_const_struct_ptr(s):
    for struct_type in struct_types:
        if s == f"const {struct_type} *":
            return True
    return False


def is_struct_ptr(s):
    for struct_type in struct_types:
        if s == f"{struct_type} *":
            return True
    return False


def type_default_value(s):
    return prim_defaults[s]


def as_c_arg_type(arg_prefix, arg_type, prefix):
    # NOTE: if arg_prefix is None, the result is used as return value
    pre = "" if arg_prefix is None else arg_prefix

    if arg_type == "void":
        return ""
    elif is_prim_type(arg_type):
        return pre + as_rust_prim_type(arg_type)
    elif is_struct_type(arg_type):
        return pre + as_rust_struct_type(arg_type, prefix)
    elif is_enum_type(arg_type):
        return pre + as_rust_enum_type(arg_type, prefix)
    elif util.is_void_ptr(arg_type):
        return pre + "*mut core::ffi::c_void"
    elif util.is_const_void_ptr(arg_type):
        return pre + "*const core::ffi::c_void"
    elif util.is_string_ptr(arg_type):
        return pre + "*const core::ffi::c_char"
    elif is_const_struct_ptr(arg_type):
        return pre + f"*const {as_rust_struct_type(util.extract_ptr_type(arg_type), prefix)}"
    elif is_struct_ptr(arg_type):
        return pre + f"*mut {as_rust_struct_type(util.extract_ptr_type(arg_type), prefix)}"
    elif is_prim_ptr(arg_type):
        return pre + f"*mut {as_rust_prim_type(util.extract_ptr_type(arg_type))}"
    elif is_const_prim_ptr(arg_type):
        return pre + f"*const {as_rust_prim_type(util.extract_ptr_type(arg_type))}"
    else:
        sys.exit(f"ERROR as_c_arg_type(): {arg_type}")


def as_rust_arg_type(arg_prefix, arg_type, prefix):
    # NOTE: if arg_prefix is None, the result is used as return value
    pre = "" if arg_prefix is None else arg_prefix

    if arg_type == "void":
        return ""
    elif is_prim_type(arg_type):
        return pre + as_rust_prim_type(arg_type)
    elif is_struct_type(arg_type):
        return pre + as_rust_struct_type(arg_type, prefix)
    elif is_enum_type(arg_type):
        return pre + as_rust_enum_type(arg_type, prefix)
    elif util.is_void_ptr(arg_type):
        return pre + "*mut core::ffi::c_void"
    elif util.is_const_void_ptr(arg_type):
        return pre + "*const core::ffi::c_void"
    elif util.is_string_ptr(arg_type):
        return pre + "&str"
    elif is_const_struct_ptr(arg_type):
        return pre + f"&{as_rust_struct_type(util.extract_ptr_type(arg_type), prefix)}"
    elif is_struct_ptr(arg_type):
        return pre + f"&mut {as_rust_struct_type(util.extract_ptr_type(arg_type), prefix)}"
    elif is_prim_ptr(arg_type):
        return pre + f"&mut {as_rust_prim_type(util.extract_ptr_type(arg_type))}"
    elif is_const_prim_ptr(arg_type):
        return pre + f"&{as_rust_prim_type(util.extract_ptr_type(arg_type))}"
    else:
        sys.exit(f"ERROR as_rust_arg_type(): {arg_type}")


def is_rust_string(rust_type):
    return rust_type == "&str" or rust_type == " -> &'static str"


# get C-style arguments of a function pointer as string
def funcptr_args_c(field_type, prefix):
    tokens = field_type[field_type.index("(*)") + 4: -1].split(",")
    s = ""
    for token in tokens:
        arg_type = token.strip()
        if s != "":
            s += ", "
        c_arg = as_c_arg_type(None, arg_type, prefix)
        if c_arg == "void":
            return ""
        else:
            s += c_arg
    return s


# get C-style result of a function pointer as string
def funcptr_result_c(field_type):
    res_type = field_type[: field_type.index("(*)")].strip()
    if res_type == "void":
        return ""
    elif util.is_const_void_ptr(res_type):
        return " -> *const core::ffi::c_void"
    elif util.is_void_ptr(res_type):
        return " -> *mut core::ffi::c_void"
    else:
        sys.exit(f"ERROR funcptr_result_c(): {field_type}")


def funcdecl_args_c(decl, prefix):
    s = ""
    func_name = decl["name"]
    for param_decl in decl["params"]:
        if s != "":
            s += ", "
        param_name = param_decl["name"]
        param_type = check_override(
            f"{func_name}.{param_name}", default=param_decl["type"]
        )
        s += f"{as_c_arg_type(f'{param_name}: ', param_type, prefix)}"
    return s


def funcdecl_args_rust(decl, prefix):
    s = ""
    func_name = decl["name"]
    for param_decl in decl["params"]:
        if s != "":
            s += ", "
        param_name = param_decl["name"]
        param_type = check_override(
            f"{func_name}.{param_name}", default=param_decl["type"]
        )
        s += f"{as_rust_arg_type(f'{param_name}: ', param_type, prefix)}"
    return s


def funcdecl_result_c(decl, prefix):
    func_name = decl["name"]
    decl_type = decl["type"]
    result_type = check_override(
        f"{func_name}.RESULT", default=decl_type[: decl_type.index("(")].strip()
    )

    it = as_c_arg_type(None, result_type, prefix)
    if it == "()" or it == "":
        return ""
    else:
        return f" -> {it}"


def funcdecl_result_rust(decl, prefix):
    func_name = decl["name"]
    decl_type = decl["type"]
    result_type = check_override(
        f"{func_name}.RESULT", default=decl_type[: decl_type.index("(")].strip()
    )
    rust_res_type = as_rust_arg_type(None, result_type, prefix)

    if is_rust_string(rust_res_type):
        rust_res_type = "&'static str"

    if rust_res_type == "":
        return ""
    else:
        return f" -> {rust_res_type }"


def gen_struct(decl, prefix):
    struct_name = check_override(decl["name"])
    rust_type = as_rust_struct_type(struct_name, prefix)
    rust_struct_type = rust_type

    struct_lines = []
    default_lines = []

    for field in decl["fields"]:
        field_name = check_override(field["name"])
        field_type = check_override(
            f"{struct_name}.{field_name}", default=field["type"]
        )

        if is_prim_type(field_type):
            struct_lines.append(
                f"pub {field_name}: {as_rust_prim_type(field_type)}"
            )
            default_lines.append(
                f"{field_name}: {type_default_value(field_type)}"
            )
        elif is_struct_type(field_type):
            struct_lines.append(
                f"pub {field_name}: {as_rust_struct_type(field_type, prefix)}"
            )
            default_lines.append(
                f"{field_name}: {as_rust_struct_type(field_type, prefix)}::new()"
            )
        elif is_enum_type(field_type):
            struct_lines.append(
                f"pub {field_name}: {as_rust_enum_type(field_type, prefix)}"
            )
            default_lines.append(
                f"{field_name}: {as_rust_enum_type(field_type, prefix)}::new()"
            )
        elif util.is_string_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *const core::ffi::c_char"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null()"
            )
        elif util.is_const_void_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *const core::ffi::c_void"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null()"
            )
        elif util.is_void_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *mut core::ffi::c_void"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null_mut()"
            )
        elif is_const_prim_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *const {as_rust_prim_type(util.extract_ptr_type(field_type))}"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null()"
            )
        elif is_prim_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *mut {as_rust_prim_type(util.extract_ptr_type(field_type))}"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null_mut()"
            )
        elif is_const_struct_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *const {as_rust_struct_type(util.extract_ptr_type(field_type), prefix)}"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null()"
            )
        elif is_struct_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: *mut {as_rust_struct_type(util.extract_ptr_type(field_type), prefix)}"
            )
            default_lines.append(
                f"{field_name}: core::ptr::null_mut()"
            )
        elif util.is_func_ptr(field_type):
            struct_lines.append(
                f"pub {field_name}: Option<extern \"C\" fn({funcptr_args_c(field_type, prefix)}){funcptr_result_c(field_type)}>"
            )
            default_lines.append(
                f"{field_name}: None"
            )
        elif util.is_1d_array_type(field_type):
            array_type = util.extract_array_type(field_type)
            array_sizes = util.extract_array_sizes(field_type)
            if is_prim_type(array_type) or is_struct_type(array_type):
                if is_prim_type(array_type):
                    rust_type = as_rust_prim_type(array_type)
                    def_val = type_default_value(array_type)
                elif is_struct_type(array_type) or is_enum_type(array_type):
                    rust_type = as_rust_struct_type(array_type, prefix)
                    def_val = f"{rust_type}::new()"
                else:
                    sys.exit(f"ERROR gen_struct is_1d_array_type: {array_type}")
                t0 = f"[{rust_type}; {array_sizes[0]}]"
                # t1 = f"&{rust_type}"
                struct_lines.append(
                    f"pub {field_name}: {t0}"
                )
                default_lines.append(
                    f"{field_name}: [{def_val}; {array_sizes[0]}]"
                )
            elif util.is_const_void_ptr(array_type):
                struct_lines.append(
                    f"pub {field_name}: [*const core::ffi::c_void; {array_sizes[0]}]"
                )
                default_lines.append(
                    f"{field_name}: [core::ptr::null(); {array_sizes[0]}]"
                )
            else:
                sys.exit(
                    f"ERROR gen_struct: array {field_name}: {field_type} => [{array_type}: {array_sizes[0]}]"
                )
        elif util.is_2d_array_type(field_type):
            array_type = util.extract_array_type(field_type)
            array_sizes = util.extract_array_sizes(field_type)

            if is_prim_type(array_type):
                rust_type = as_rust_prim_type(array_type)
                def_val = type_default_value(array_type)
            elif is_struct_type(array_type):
                rust_type = as_rust_struct_type(array_type, prefix)
                def_val = f"{rust_type}::new()"
            else:
                sys.exit(f"ERROR gen_struct is_2d_array_type: {array_type}")

            struct_lines.append(
                f"pub {field_name}: [[{rust_type}; {array_sizes[1]}]; {array_sizes[0]}]"
            )
            default_lines.append(
                f"{field_name}: [[{def_val}; {array_sizes[1]}]; {array_sizes[0]}]"
            )
        else:
            sys.exit(f"ERROR gen_struct: {field_name}: {field_type};")

    #
    # TODO: Is this the best way to have zero-initialization with support for constants?
    #       core::mem::zeroed() cleaner?
    #

    l("#[repr(C)]")
    l("#[derive(Copy, Clone, Debug)]")
    l(f"pub struct {rust_struct_type} {{")
    for line in struct_lines:
        l(f"    {line},")
    l("}")

    l(f"impl {rust_struct_type} {{")
    l("    pub const fn new() -> Self {")
    l("        Self {")
    for line in default_lines:
        l(f"            {line},")
    l("        }")
    l("    }")
    l("}")

    l(f"impl Default for {rust_struct_type} {{")
    l("    fn default() -> Self {")
    l("        Self::new()")
    l("    }")
    l("}")


def gen_consts(decl, prefix):
    for item in decl["items"]:
        #
        # TODO: What type should these constants have? Currently giving all `usize`
        #       unless specifically overriden by `special_constant_types`
        #

        item_name = check_override(item["name"])
        if item_name in special_constant_types:
            special_type = special_constant_types[item_name]
            l(f"pub const {as_upper_snake_case(item_name, prefix)}: {special_type} = {item['value']};")
        else:
            l(f"pub const {as_upper_snake_case(item_name, prefix)}: usize = {item['value']};")


def gen_enum(decl, prefix):
    enum_name = check_override(decl["name"])

    names = [
        as_enum_item_name(check_override(f"{decl['name']}::{item['name']}", item['name'])) for item in decl["items"]
    ]

    is_u32 = False
    for name in names:
        if name == "ForceU32":
            is_u32 = True
            break

    l("#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]")
    if is_u32:
        l("#[repr(u32)]")
    else:
        l("#[repr(i32)]")

    rust_enum_name = as_rust_enum_type(enum_name, prefix)

    l(f"pub enum {rust_enum_name} {{")
    for item_name, item in zip(names, decl["items"]):
        if item_name != "ForceU32":
            if "value" in item:
                l(f"    {item_name} = {item['value']},")
            else:
                l(f"    {item_name},")
    l("}")

    default_item = enum_default_item(enum_name)
    l(f"impl {rust_enum_name} {{")
    l("    pub const fn new() -> Self {")
    l(f"        Self::{default_item}")
    l("    }")
    l("}")

    l(f"impl Default for {rust_enum_name} {{")
    l("    fn default() -> Self {")
    l(f"        Self::{default_item}")
    l("    }")
    l("}")


def gen_func_c(decl, prefix):
    l("pub extern \"C\" {")
    l(f"    fn {decl['name']}({funcdecl_args_c(decl, prefix)}){funcdecl_result_c(decl, prefix)};")
    l("}")


def gen_c_funcs(funcs):
    l("pub mod ffi {")
    l("    #![allow(unused_imports)]")
    l("    use super::*;")
    l("    extern \"C\" {")
    for decl, prefix in funcs:
        l(f"        pub fn {decl['name']}({funcdecl_args_c(decl, prefix)}){funcdecl_result_c(decl, prefix)};")
    l("    }")
    l("}")


def gen_rust_funcs(funcs):
    for decl, prefix in funcs:
        gen_func_rust(decl, prefix)


def gen_func_rust(decl, prefix):
    c_func_name = decl["name"]
    rust_func_name = util.as_lower_snake_case(check_override(decl["name"]), prefix)
    rust_res_type = funcdecl_result_rust(decl, prefix)

    if c_func_name in c_callbacks:
        c_res_type = funcdecl_result_c(decl, prefix)
        l("#[inline]")
        l(f'pub extern "C" fn {c_func_name}({funcdecl_args_c(decl, prefix)}){c_res_type} {{')
        l("    unsafe {")
        s = f"        ffi::{c_func_name}("
        for i, param_decl in enumerate(decl["params"]):
            if i > 0:
                s += ", "
            arg_name = param_decl["name"]
            s += arg_name
        s += ")"
        l(s)
        l("    }")
        l("}")
    else:
        l("#[inline]")
        l(f"pub fn {rust_func_name}({funcdecl_args_rust(decl, prefix)}){rust_res_type} {{")
        for i, param_decl in enumerate(decl["params"]):
            arg_name = param_decl["name"]
            arg_type = param_decl["type"]
            if util.is_string_ptr(arg_type):
                l(f"        let tmp_{i} = std::ffi::CString::new({arg_name}).unwrap();")

        l("    unsafe {")
        if is_rust_string(rust_res_type):
            # special case: convert C string to rust string slice
            s = f"        c_char_ptr_to_rust_str(ffi::{c_func_name}("
        else:
            s = f"        ffi::{c_func_name}("

        for i, param_decl in enumerate(decl["params"]):
            if i > 0:
                s += ", "
            arg_name = param_decl["name"]
            arg_type = param_decl["type"]

            if util.is_string_ptr(arg_type):
                s += f"tmp_{i}.as_ptr()"
            else:
                s += arg_name

        if is_rust_string(rust_res_type):
            s += ")"
        s += ")"
        l(s)
        l("    }")
        l("}")


def pre_parse(inp):
    global struct_types
    global enum_types
    for decl in inp["decls"]:
        kind = decl["kind"]
        if kind == "struct":
            struct_types.append(decl["name"])
        elif kind == "enum":
            enum_name = decl["name"]
            enum_types.append(enum_name)
            enum_items[enum_name] = []
            for item in decl["items"]:
                enum_items[enum_name].append(as_enum_item_name(item["name"]))

def gen_imports(inp, dep_prefixes):
    for dep_prefix in dep_prefixes:
        dep_module_name = module_names[dep_prefix]
        # l(f'const {dep_prefix[:-1]} = @import("{dep_module_name}.rs");')
        l(f'use crate::{dep_module_name} as {dep_prefix[:-1]};')
    l("")


def gen_helpers(inp):
    l("/// Helper function to convert a C string to a rust string slice")
    l("#[inline]")
    l("fn c_char_ptr_to_rust_str(c_char_ptr: *const core::ffi::c_char) -> &'static str {")
    l("    let c_str = unsafe { core::ffi::CStr::from_ptr(c_char_ptr) };")
    l("    c_str.to_str().expect(\"c_char_ptr contained invalid Utf8 Data\")")
    l("}")
    l("")

    if inp['prefix'] in ['sg_', 'sdtx_', 'sshape_', 'sapp_']:
        l("/// Helper function to cast a rust slice into a sokol Range")
        l(f"pub fn slice_as_range<T>(data: &[T]) -> {range_struct_name} {{")
        l(f"    {range_struct_name} {{ size: data.len() * std::mem::size_of::<T>(), ptr: data.as_ptr() as *const _ }}")
        l("}")
        l("/// Helper function to cast a rust reference into a sokol Range")
        l(f"pub fn value_as_range<T>(value: &T) -> {range_struct_name} {{")
        l(f"    {range_struct_name} {{ size: std::mem::size_of::<T>(), ptr: value as *const T as *const _ }}")
        l("}")
        l("")
        l(f"impl<T> From<&[T]> for {range_struct_name} {{")
        l("    #[inline]")
        l("    fn from(data: &[T]) -> Self {")
        l("        slice_as_range(data)")
        l("    }")
        l("}")
        l(f"impl<T> From<&T> for {range_struct_name} {{")
        l("    #[inline]")
        l("    fn from(value: &T) -> Self {")
        l("        value_as_range(value)")
        l("    }")
        l("}")
        l("")

    # if inp["prefix"] == "sdtx_":
    #     l("/// std.fmt compatible Writer")
    #     l("pub const Writer = struct {")
    #     l("    pub const Error = error { };")
    #     l("    pub fn writeAll(self: Writer, bytes: []const u8) Error!void {")
    #     l("        _ = self;")
    #     l("        for (bytes) |byte| {")
    #     l("            putc(byte);")
    #     l("        }")
    #     l("    }")
    #     l("    pub fn writeByteNTimes(self: Writer, byte: u8, n: u64) Error!void {")
    #     l("        _ = self;")
    #     l("        var i: u64 = 0;")
    #     l("        while (i < n): (i += 1) {")
    #     l("            putc(byte);")
    #     l("        }")
    #     l("    }")
    #     l("};")
    #     l("// std.fmt-style formatted print")
    #     l("pub fn print(comptime fmt: anytype, args: anytype) void {")
    #     l("    var writer: Writer = .{};")
    #     l('    @import("std").fmt.format(writer, fmt, args) catch {};')
    #     l("}")
    #     l("")


def gen_module(inp, dep_prefixes):
    module = inp['module']
    if module in module_requires_rust_feature:
        feature = module_requires_rust_feature[module]
        l(f"//! To use this module, enable the feature \"{feature}\"")

    l("// machine generated, do not edit")
    l("")

    
    l("#![allow(dead_code)]")
    l("#![allow(unused_imports)]")
    l("")
    gen_imports(inp, dep_prefixes)
    gen_helpers(inp)
    pre_parse(inp)
    prefix = inp["prefix"]

    funcs = []

    for decl in inp["decls"]:
        #
        #    HACK: gen_ir.py accidentally marks all sg_imgui_ declarations as is_dep since sg_imgui
        #          depends on sg_a but also starts with sg_... Fix gen_ir.py to remove this hack
        #
        dep_hack = False
        if module == "gfx_imgui":
            dep_hack = "name" in decl and decl["name"].startswith("sg_imgui_")

        if not decl["is_dep"] or dep_hack:
            kind = decl["kind"]
            if kind == "consts":
                gen_consts(decl, prefix)
            elif not check_ignore(decl["name"]):
                if kind == "struct":
                    gen_struct(decl, prefix)
                elif kind == "enum":
                    gen_enum(decl, prefix)
                elif kind == "func":
                    funcs.append((decl, prefix))

    gen_c_funcs(funcs)
    gen_rust_funcs(funcs)


def prepare():
    print("=== Generating Rust bindings:")
    if not os.path.isdir("sokol-rust/src/sokol"):
        os.makedirs("sokol-rust/src/sokol")
    if not os.path.isdir("sokol-rust/src/sokol/c"):
        os.makedirs("sokol-rust/src/sokol/c")

    with open("sokol-rust/src/lib.rs", "w", newline="\n") as f_outp:
        f_outp.write("//! Automatically generated sokol bindings for Rust\n\n")


def gen(c_header_path, c_prefix, dep_c_prefixes):
    if c_prefix not in module_names:
        print(f' >> warning: skipping generation for {c_prefix} prefix...')
        return

    module_name = module_names[c_prefix]
    c_source_path = c_source_paths[c_prefix]
    print(f'  {c_header_path} => {module_name}')
    reset_globals()
    c_path_in_project = f'sokol-rust/src/sokol/c/{os.path.basename(c_header_path)}'
    shutil.copyfile(c_header_path, c_path_in_project)
    ir = gen_ir.gen(c_header_path, c_source_path, module_name, c_prefix, dep_c_prefixes)
    gen_module(ir, dep_c_prefixes)
    output_path = f"sokol-rust/src/{ir['module']}.rs"
    with open(output_path, 'w', newline='\n') as f_outp:
        f_outp.write(out_lines)

    with open("sokol-rust/src/lib.rs", "a", newline="\n") as f_outp:
        module = ir['module']
        if module in module_requires_rust_feature:
            feature = module_requires_rust_feature[module]
            f_outp.write(f"/// Enable feature \"{feature}\" to use\n")
            f_outp.write(f"#[cfg(feature=\"{feature}\")]\n")
        f_outp.write(f"pub mod {module};\n")