rusteal-codegen 0.6.1

Code generator: UHT JSON to Rust bindings and C++ wrappers for rusteal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::context::CodegenContext;
use crate::naming::{escape_reserved, to_snake_case};
use crate::schema::*;
use crate::type_map::{ConversionKind, MappedType};

use super::classes::is_struct_owned;
use super::properties;

pub fn emit_out_param_var_decl(out: &mut String, param: &ParamInfo, mapped: &MappedType) {
    let pname = escape_reserved(&to_snake_case(&param.name));

    match mapped.ffi_to_rust {
        ConversionKind::StructOpaque => {
            out.push_str(&format!("        let mut {pname}_buf = vec![0u8; 256];\n"));
        }
        ConversionKind::StringUtf8 => {
            out.push_str(&format!("        let mut {pname}_buf = vec![0u8; 512];\n"));
            out.push_str(&format!("        let mut {pname}_len: u32 = 0;\n"));
        }
        ConversionKind::ObjectRef => {
            out.push_str(&format!(
                "        let mut {pname} = rusteal_core::UObjectHandle::null();\n"
            ));
        }
        ConversionKind::EnumCast => {
            out.push_str(&format!(
                "        let mut {pname}: {} = 0;\n",
                mapped.rust_ffi_type
            ));
        }
        _ => {
            let default = properties::default_value_for(&mapped.rust_ffi_type);
            out.push_str(&format!("        let mut {pname} = {default};\n"));
        }
    }
}

pub fn emit_inout_string_buf_decl(out: &mut String, param: &ParamInfo, mapped: &MappedType) {
    if mapped.ffi_to_rust == ConversionKind::StringUtf8 {
        let pname = escape_reserved(&to_snake_case(&param.name));
        out.push_str(&format!("        let mut {pname}_buf = vec![0u8; 512];\n"));
        out.push_str(&format!("        let mut {pname}_len: u32 = 0;\n"));
    }
}

pub fn emit_out_param_conversion(
    out: &mut String,
    param: &ParamInfo,
    mapped: &MappedType,
    ctx: &CodegenContext,
) -> String {
    let pname = escape_reserved(&to_snake_case(&param.name));

    match mapped.ffi_to_rust {
        ConversionKind::ObjectRef => {
            format!("unsafe {{ rusteal_core::ObjectPointer::from_object_handle({pname}) }}")
        }
        ConversionKind::StringUtf8 => {
            out.push_str(&format!(
                "        {pname}_buf.truncate({pname}_len as usize);\n"
            ));

            out.push_str(&format!(
                "        let {pname}_str = String::from_utf8_lossy(&{pname}_buf).into_owned();\n"
            ));

            format!("{pname}_str")
        }
        ConversionKind::EnumCast => {
            let rt = &mapped.rust_type;

            let actual_repr = param
                .enum_name
                .as_deref()
                .and_then(|en| ctx.enum_actual_repr(en))
                .unwrap_or(&mapped.rust_ffi_type);

            out.push_str(&format!(
                "        let {pname}_enum = {rt}::from_value({pname} as {actual_repr}).expect(\"unknown enum value\");\n"
            ));

            format!("{pname}_enum")
        }
        ConversionKind::StructOpaque => {
            if is_struct_owned(param.struct_name.as_deref(), ctx) {
                out.push_str(&format!(
                    "        let {pname}_owned = rusteal_core::OwnedStruct::from_bytes({pname}_buf);\n"
                ));

                format!("{pname}_owned")
            } else {
                out.push_str(&format!(
                    "        let {pname}_ptr = {pname}_buf.as_ptr();\n"
                ));

                out.push_str(&format!("        std::mem::forget({pname}_buf);\n"));

                format!("{pname}_ptr")
            }
        }
        ConversionKind::IntCast => {
            let rt = &mapped.rust_type;

            format!("{pname} as {rt}")
        }
        ConversionKind::FName => pname.to_string(),
        _ => pname.to_string(),
    }
}

pub fn emit_return_expr(out: &mut String, return_parts: &[String]) {
    match return_parts.len() {
        0 => {}
        1 => out.push_str(&format!("        {}\n", return_parts[0])),
        _ => out.push_str(&format!("        ({})\n", return_parts.join(", "))),
    }
}