start working on separating runtime into a framework, implement interop.sizeof

Author: DjDeveloperr

examples/foundation.js

@@ -36,3 +36,10 @@ console.log(`${dict}`);
 for (const key of dict) {
   console.log(key);
 }
+
+console.log(
+  interop.sizeof(dict),
+  interop.sizeof(interop.types.uint8),
+  interop.sizeof(NSMutableArray),
+  interop.sizeof(AudioBuffer),
+);

runtime/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CMAKE_CXX_FLAGS_DEBUG "-g")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3")
 
 set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_OBJCXX_STANDARD 20)
 
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/include
@@ -20,6 +21,8 @@ set(EXEC_SOURCE_FILES
   src/Runtime.cpp
   src/segappend.cpp
   src/Compiler.cpp
+  src/Require.mm
+  src/Performance.cpp
 )
 
 add_executable(
@@ -36,7 +39,7 @@ target_link_options(
 target_link_directories(
   ${NAME}
   PRIVATE
-  ${CMAKE_CURRENT_SOURCE_DIR}/../build/macos/Release
+  ${CMAKE_CURRENT_SOURCE_DIR}/../packages/macos/build/macos/Release
 )
 
 target_link_libraries(

runtime/include/NapiUtil.h

@@ -0,0 +1,17 @@
+#ifndef NAPIUTIL_H
+#define NAPIUTIL_H
+
+#include <string>
+#include "js_native_api.h"
+
+inline std::string getStringValue(napi_env env, napi_value str) {
+    size_t length = 0;
+    napi_get_value_string_utf8(env, str, nullptr, 0, &length);
+    char* strbuf = (char*) malloc(length + 1);
+    napi_get_value_string_utf8(env, str, strbuf, length + 1, &length);
+    std::string result = strbuf;
+    free(strbuf);
+    return result;
+}
+
+#endif // NAPIUTIL_H

runtime/src/Compiler.cpp

@@ -2,6 +2,7 @@
 #include "segappend.h"
 #include <filesystem>
 #include <iostream>
+#include <array>
 
 namespace charon {
 

runtime/src/Require.mm

@@ -0,0 +1,135 @@
+#include <string>
+#include "js_native_api.h"
+#include "NapiUtil.h"
+
+#import <Foundation/Foundation.h>
+
+class Require {
+public:
+    Require(std::string path) : path(path) {}
+    
+    static napi_value createRequire(napi_env env, std::string &path) {
+        Require *require = new Require(path);
+        napi_value result;
+        napi_create_function(env, "require", NAPI_AUTO_LENGTH, Require::requireCallback, require, &result);
+        napi_ref ref;
+        napi_wrap(env, result, require, Require::finalize, nullptr, &ref);
+        return result;
+    }
+    
+    static void finalize(napi_env env, void *data, void *hint) {
+        Require *require = (Require *) data;
+        delete require;
+    }
+    
+    std::string resolve(std::string &spec) {
+        if (spec.find("/") == 0) {
+            return spec;
+        }
+        
+        size_t dotpos = spec.find(".");
+        size_t tildepos = spec.find("~");
+        std::string result;
+        if (tildepos == 0) {
+            result = [NSBundle.mainBundle.resourcePath UTF8String];
+            result += "/app";
+        } else {
+            result = path;
+        }
+        
+        if (dotpos == 0 || tildepos == 0) {
+            std::string relativeSpec = spec.substr(spec.find("./") == 0 || spec.find("~/") == 0 ? 2 : 1);
+            if (relativeSpec.empty()) {
+                result += "/index.js";
+            } else {
+                result += "/" + relativeSpec;
+            }
+        } else {
+            result += "/" + spec;
+        }
+        
+        size_t pos = result.rfind("/");
+        size_t jspos = result.find(".js");
+        if (jspos < pos || jspos == std::string::npos) {
+            result += result.ends_with("/") ? "index.js" : "/index.js";
+        }
+        
+        return result;
+    }
+    
+    napi_value require(napi_env env, std::string &spec) {
+        std::string path = resolve(spec);
+        NSError *error = nil;
+        
+        NSString *source = [NSString stringWithContentsOfFile:[NSString stringWithUTF8String:path.c_str()] encoding:NSUTF8StringEncoding error:&error];
+        if (error != nil) {
+            NSLog(@"error: %@", error);
+            napi_throw_error(env, nullptr, [[error localizedDescription] UTF8String]);
+            return nullptr;
+        }
+        
+        if (spec.ends_with(".json")) {
+            napi_value script, result;
+            napi_create_string_utf8(env, [source UTF8String], NAPI_AUTO_LENGTH, &script);
+            napi_run_script(env, script, &result);
+            return result;
+        }
+        
+        std::string bootstrap;
+        bootstrap = "let cjsModule; try { cjsModule = function cjsModule(exports, require, module, __filename, __dirname) { try { ";
+        bootstrap += [source UTF8String];
+        bootstrap += "\n } catch(e) { console.log('evaluate module failed:', e.stack); } }; Object.defineProperty(cjsModule, \"name\", { value: `" + path + "` }); } catch (e) { console.log(e.stack) }\n cjsModule";
+        
+        napi_status status;
+        napi_value func, script, module, exports, require, __filename, __dirname, global, result;
+        
+        napi_create_string_utf8(env, bootstrap.c_str(), NAPI_AUTO_LENGTH, &script);
+        
+        status = napi_run_script(env, script, &func);
+        if (status != napi_ok) {
+            const napi_extended_error_info *info;
+            napi_get_last_error_info(env, &info);
+            NSLog(@"error in run script: %d, %s", status, info->error_message);
+            return nullptr;
+        }
+        
+        napi_create_object(env, &module);
+        napi_create_object(env, &exports);
+        
+        napi_set_named_property(env, module, "exports", exports);
+        
+        napi_get_global(env, &global);
+        
+        napi_create_string_utf8(env, path.c_str(), NAPI_AUTO_LENGTH, &__filename);
+        
+        std::string dirname = path.substr(0, path.rfind("/"));
+        
+        require = Require::createRequire(env, dirname);
+        
+        napi_create_string_utf8(env, dirname.c_str(), NAPI_AUTO_LENGTH, &__dirname);
+        
+        napi_value argv[5] = {exports, require, module, __filename, __dirname};
+        
+        status = napi_call_function(env, global, func, 5, argv, &result);
+        if (status != napi_ok) {
+            const napi_extended_error_info *info;
+            napi_get_last_error_info(env, &info);
+            NSLog(@"error in evaluate module: %d, %s", status, info->error_message);
+            return nullptr;
+        }
+        
+        napi_get_named_property(env, module, "exports", &exports);
+        return exports;
+    }
+    
+    static napi_value requireCallback(napi_env env, napi_callback_info cbinfo) {
+        napi_value arg;
+        Require *require;
+        size_t argc = 1;
+        napi_get_cb_info(env, cbinfo, &argc, &arg, nullptr, (void**) &require);
+        std::string spec = getStringValue(env, arg);
+        return require->require(env, spec);
+    }
+    
+    std::string path;
+};

src/Class.mm

@@ -216,6 +216,9 @@
   return nullptr;
 }
 
+// Implemented in JS to minimize calls into native. Fast enumeration
+// makes use of buffers, so we only fill up the buffer once via
+// native call and only do it again if needed via _fillStack.
 static const char *FastEnumerationIteratorFactorySource = R"(
   (function () {
     return {
@@ -465,6 +468,9 @@ napi_value toJS(napi_env env) {
     napi_valuetype type;
     napi_typeof(env, SymbolDispose, &type);
 
+    napi_value sizeofValue;
+    napi_create_int32(env, sizeof(id), &sizeofValue);
+
     napi_property_descriptor properties[] = {
         {
             .utf8name = nil,
@@ -486,6 +492,16 @@ napi_value toJS(napi_env env) {
             .attributes = napi_enumerable,
             .data = nil,
         },
+        {
+            .utf8name = nil,
+            .name = jsSymbolFor(env, "sizeof"),
+            .method = nil,
+            .getter = nil,
+            .setter = nil,
+            .value = sizeofValue,
+            .attributes = napi_enumerable,
+            .data = nil,
+        },
         {
             .utf8name = nil,
             .name = SymbolIterator,
@@ -497,7 +513,9 @@ napi_value toJS(napi_env env) {
             .data = nil,
         }};
 
-    napi_define_properties(env, prototype, 3, properties);
+    napi_define_properties(env, prototype, 4, properties);
+
+    napi_define_properties(env, constructor, 1, &properties[2]);
 
     if (type == napi_symbol) {
       properties[0].name = SymbolDispose;

src/Interop.mm

@@ -340,10 +340,92 @@ napi_value interop_free(napi_env env, napi_callback_info info) {
   return nullptr;
 }
 
+size_t jsSizeof(napi_env env, napi_value arg) {
+  napi_valuetype type;
+  napi_typeof(env, arg, &type);
+
+  switch (type) {
+  case napi_number: {
+    int32_t ival;
+    napi_get_value_int32(env, arg, &ival);
+
+    switch (ival) {
+    case mdTypeVoid:
+      return 0;
+    
+    case mdTypeBool:
+    case mdTypeChar:
+    case mdTypeUInt8:
+      return sizeof(uint8_t);
+
+    case mdTypeSShort:
+    case mdTypeUShort:
+      return sizeof(uint16_t);
+
+    case mdTypeSInt:
+    case mdTypeUInt:
+      return sizeof(uint32_t);
+
+    case mdTypeSInt64:
+    case mdTypeUInt64:
+      return sizeof(uint64_t);
+
+    case mdTypeFloat:
+      return sizeof(float);
+
+    case mdTypeDouble:
+      return sizeof(double);
+
+    case mdTypeString:
+      return sizeof(char *);
+
+    case mdTypeAnyObject:
+      return sizeof(id);
+
+    case mdTypePointer:
+      return sizeof(void *);
+
+    case mdTypeSelector:
+      return sizeof(SEL);
+
+    default:
+      napi_throw_type_error(env, "TypeError", "Invalid type number for sizeof. Use interop.types.*");
+    }
+  }
+
+  case napi_object:
+  case napi_function: {
+    napi_value symbolSizeof = jsSymbolFor(env, "sizeof");
+    napi_value result;
+    napi_get_property(env, arg, symbolSizeof, &result);
+    napi_valuetype resultType;
+    napi_typeof(env, result, &resultType);
+    if (resultType == napi_number) {
+      int32_t size;
+      napi_get_value_int32(env, result, &size);
+      return size;
+    } else {
+      napi_throw_type_error(env, "TypeError", "Invalid type for sizeof");
+    }
+  }
+
+  default:
+    napi_throw_type_error(env, "TypeError", "Invalid type for sizeof");
+  }
+
+  return -1;
+}
+
 napi_value interop_sizeof(napi_env env, napi_callback_info info) {
-  // TODO
+  napi_valuetype type;
+  napi_value arg;
+  size_t argc = 1;
+  napi_get_cb_info(env, info, &argc, &arg, nullptr, nullptr);
+  
+  size_t size = jsSizeof(env, arg);
   napi_value result;
-  napi_create_int32(env, 0, &result);
+  napi_create_int32(env, size, &result);
+
   return result;
 }
 

src/Struct.mm

@@ -316,7 +316,7 @@ void StructObject_finalize(napi_env env, void *data, void *hint) {
 
 napi_value StructObject::defineJSClass(napi_env env, StructInfo *info) {
   auto properties = (napi_property_descriptor *)malloc(
-      (info->fields.size() + 1) * sizeof(napi_property_descriptor));
+      (info->fields.size() + 2) * sizeof(napi_property_descriptor));
 
   for (int i = 0; i < info->fields.size(); i++) {
     auto field = info->fields[i];
@@ -342,9 +342,24 @@ void StructObject_finalize(napi_env env, void *data, void *hint) {
   prop->attributes = napi_default;
   prop->data = nullptr;
 
+  napi_value size;
+  napi_create_int32(env, info->size, &size);
+
+  auto sizeofProp = &properties[info->fields.size() + 1]; 
+  sizeofProp->utf8name = nullptr;
+  sizeofProp->name = jsSymbolFor(env, "sizeof");
+  sizeofProp->method = nullptr;
+  sizeofProp->getter = nullptr;
+  sizeofProp->setter = nullptr;
+  sizeofProp->value = size;
+  sizeofProp->attributes = napi_enumerable;
+  sizeofProp->data = nullptr;
+
   napi_value result;
   napi_define_class(env, info->name, NAPI_AUTO_LENGTH, JS_StructConstructor,
-                    (void *)info, info->fields.size() + 1, properties, &result);
+                    (void *)info, info->fields.size() + 2, properties, &result);
+
+  napi_define_properties(env, result, 1, sizeofProp);
 
   free(properties);
 

src/TypeConv.mm

@@ -1299,10 +1299,13 @@ napi_value toJS(napi_env env, void *value, uint32_t flags) override {
 
   void toNative(napi_env env, napi_value value, void *result, bool *shouldFree,
                 bool *shouldFreeAny) override {
-    // TODO?
     NAPI_PREAMBLE
-
-    NSLog(@"ArrayTypeConv toNative: TODO");
+    
+    if (Pointer::isInstance(env, value)) {
+      Pointer *ptr = Pointer::unwrap(env, value);
+      memcpy(result, ptr->data, type->size);
+      return;
+    }
 
     void *data;
     size_t length = 0;