cmajor 0.7.0

Rust bindings for the Cmajor JIT engine.
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

use {
    crate::ffi::string::{CmajorString, CmajorStringPtr},
    std::{
        ffi::{c_char, c_int, CStr},
        ptr::null,
    },
};

#[repr(C)]
struct SyntaxTreeOptions {
    namespace_or_module: *const c_char,
    include_source_locations: bool,
    include_comments: bool,
    include_function_contents: bool,
}

#[repr(C)]
struct ProgramVTable {
    add_ref: unsafe extern "system" fn(*mut Program) -> c_int,
    release: unsafe extern "system" fn(*mut Program) -> c_int,
    ref_count: unsafe extern "system" fn(*const Program) -> c_int,
    parse: unsafe extern "system" fn(
        *mut Program,
        *const c_char,
        *const c_char,
        isize,
    ) -> *mut CmajorString,
    get_syntax_tree:
        unsafe extern "system" fn(*mut Program, *const SyntaxTreeOptions) -> *mut CmajorString,
}

#[repr(C)]
pub struct Program {
    vtable: *const ProgramVTable,
}

#[derive(Debug)]
pub struct ProgramPtr {
    program: *mut Program,
}

impl ProgramPtr {
    pub unsafe fn new(program: *mut Program) -> Self {
        Self { program }
    }

    pub fn get(&self) -> *mut Program {
        self.program
    }

    pub fn parse(
        &self,
        file_name: Option<&CStr>,
        file_content: impl AsRef<str>,
    ) -> Result<(), CmajorStringPtr> {
        let file_name = file_name.map(CStr::as_ptr).unwrap_or(null());

        let file_content_len = file_content.as_ref().len() as isize;
        let file_content = file_content.as_ref().as_ptr().cast();

        let error = unsafe {
            ((*(*self.program).vtable).parse)(
                self.program,
                file_name,
                file_content,
                file_content_len,
            )
        };

        if error.is_null() {
            return Ok(());
        }

        Err(unsafe { CmajorStringPtr::new(error) })
    }
}

impl Drop for ProgramPtr {
    fn drop(&mut self) {
        unsafe { ((*(*self.program).vtable).release)(self.program) };
    }
}