feat: building

javascript-engine/src/engine.rs

@@ -0,0 +1,34 @@
+use boa_engine::{Context, JsValue};
+use boa_engine::property::Attribute;
+
+pub(crate) struct EvalResult {
+    data: Option<JsValue>,
+    error: Option<String>,
+}
+
+impl EvalResult {
+    fn ok(data: JsValue) -> Self {
+        Self {
+            data: Some(data),
+            error: None,
+        }
+    }
+    fn err(error: String) -> Self {
+        Self {
+            data: None,
+            error: Some(error),
+        }
+    }
+}
+
+pub(crate) fn inner_eval(js: &str) -> EvalResult {
+    let mut context = Context::default();
+    context.set_trace(true);
+    context.register_global_property("JS_ENGINE", "1.0.0", Attribute::all());
+    // context.register_global_function("print", 0, print);
+
+    match context.eval(js) {
+        Ok(res) => EvalResult::ok(res),
+        Err(e) => EvalResult::err(format!("{}", e)),
+    }
+}

javascript-engine/src/lib.rs

@@ -1,2 +1,11 @@
 
 mod mem;
+mod engine;
+
+
+#[no_mangle]
+pub unsafe fn eval(ptr: *mut u8, len: usize) -> *mut u8 {
+    // let eval_result = engine::inner_eval()
+    unimplemented!()
+}
+

javascript-engine/src/mem.rs

@@ -1,3 +1,5 @@
+use std::ptr;
+
 #[no_mangle]
 pub unsafe fn malloc(len: usize) -> *mut u8 {
     let align = std::mem::align_of::<usize>();
@@ -11,3 +13,28 @@ pub unsafe fn free(ptr: *mut u8, len: usize) {
     let layout = std::alloc::Layout::from_size_align_unchecked(len, align);
     std::alloc::dealloc(ptr, layout)
 }
+
+pub(crate) fn read_string(ptr: *const u8, len: usize) -> String {
+    let mut buffer = Vec::with_capacity(len);
+    let len = len as isize;
+    for i in 0..len {
+        buffer.push(unsafe { ptr::read(ptr.offset(i)) });
+    }
+    unsafe { String::from_utf8_unchecked(buffer) }
+}
+
+pub(crate) unsafe fn malloc_and_write_string(str: &str) -> (*mut u8, usize) {
+    let bytes = str.as_bytes();
+    let bytes_len = bytes.len();
+    let ptr = malloc(bytes_len);
+    write_bytes(ptr, bytes_len, bytes);
+    (ptr, bytes_len)
+}
+
+pub(crate) fn write_bytes(ptr: *mut u8, len: usize, bytes: &[u8]) {
+    let bytes_len = bytes.len();
+    assert!(bytes_len <= len);
+    for i in 0..bytes_len {
+        unsafe { ptr::write(ptr.offset(i as isize), bytes[i]) };
+    }
+}