brickworks 0.0.1

Brick Rigs mod loader
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
118
119

use core::fmt::{self, Write};
use core::ptr;
extern "C"
{
    fn malloc( size: usize ) -> *mut ();
    fn realloc( ptr: *mut (), size: usize ) -> *mut ();
    fn free( ptr: *mut () );
}

pub struct Buffer {
    pub ptr: *mut u8,
    pub len: usize,
    pub cap: usize,
}
impl Buffer {
    pub fn new() -> Self {
        Self {
            ptr: core::ptr::null_mut(),
            len: 0,
            cap: 0,
        }
    }

    fn grow(&mut self, additional: usize) -> Result<(), ()> {
        let required = self.len + additional;

        if required <= self.cap {
            return Ok(());
        }

        let new_cap = if self.cap == 0 {
            required.max(64)
        } else {
            (self.cap * 2).max(required)
        };

        unsafe {
            let new_ptr = if self.ptr.is_null() {
                malloc(new_cap)
            } else {
                realloc(self.ptr as *mut _, new_cap)
            } as *mut u8;

            if new_ptr.is_null() {
                return Err(());
            }

            self.ptr = new_ptr;
            self.cap = new_cap;
        }

        Ok(())
    }
}

impl Write for Buffer {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.grow(s.len()).map_err(|_| fmt::Error)?;

        unsafe {
            let dst = self.ptr.add(self.len);
            ptr::copy_nonoverlapping(s.as_ptr(), dst, s.len());
        }

        self.len += s.len();
        Ok(())
    }
}

impl Drop for Buffer {
    fn drop(&mut self) {
        unsafe {
            if !self.ptr.is_null() {
                free(self.ptr as *mut _);
            }
        }
    }
}


unsafe extern "C"
{
    pub fn BrickRust_print( str: *const u8 );
}

/**
 * Sets module name for br_print
 * [ name ] your log
 * */
#[macro_export]
macro_rules! set_module_name {
    ($name: expr) => {
        #[allow(non_snake_case)]
        unsafe fn BrickRust_print( str: *const u8 )
        {
            use brickworks::logger;
            logger::brickworks_puts(
                $name.as_ptr(),
                str
                );
        }
        
    };
}

#[macro_export]
macro_rules! br_print {
    ($($arg:tt)*) => {{
        use core::fmt::Write;
        use $crate::print::Buffer;

        let mut buf = Buffer::new();
        let _ = write!(&mut buf, "{}\0", core::format_args!($($arg)*));

        unsafe {
            BrickRust_print(buf.ptr as *const u8);
        }
    }};
}