release

Author: pavelsavara

src/native/corehost/browserhost/host/host.ts

@@ -7,45 +7,45 @@ import { } from "./cross-linked"; // ensure ambient symbols are declared
 const loadedAssemblies : Map<string, { ptr: number, length: number }> = new Map();
 
 export function registerDllBytes(bytes: Uint8Array, asset: { name: string }) {
-    const sp = _Module.stackSave();
+    const sp = Module.stackSave();
     try {
         const sizeOfPtr = 4;
-        const ptrPtr = _Module.stackAlloc(sizeOfPtr);
-        if (_Module._posix_memalign(ptrPtr as any, 16, bytes.length)) {
+        const ptrPtr = Module.stackAlloc(sizeOfPtr);
+        if (Module._posix_memalign(ptrPtr as any, 16, bytes.length)) {
             throw new Error("posix_memalign failed");
         }
 
-        const ptr = _Module.HEAPU32[ptrPtr as any >>> 2];
-        _Module.HEAPU8.set(bytes, ptr);
+        const ptr = Module.HEAPU32[ptrPtr as any >>> 2];
+        Module.HEAPU8.set(bytes, ptr);
         loadedAssemblies.set(asset.name, { ptr, length: bytes.length });
     } finally {
-        _Module.stackRestore(sp);
+        Module.stackRestore(sp);
     }
 }
 
 // bool BrowserHost_ExternalAssemblyProbe(const char* pathPtr, /*out*/ void **outDataStartPtr, /*out*/ int64_t* outSize);
 export function BrowserHost_ExternalAssemblyProbe(pathPtr:CharPtr, outDataStartPtr:VoidPtrPtr, outSize:VoidPtr) {
-    const path = _Module.UTF8ToString(pathPtr);
+    const path = Module.UTF8ToString(pathPtr);
     const assembly = loadedAssemblies.get(path);
     if (assembly) {
-        _Module.HEAPU32[outDataStartPtr as any >>> 2] = assembly.ptr;
+        Module.HEAPU32[outDataStartPtr as any >>> 2] = assembly.ptr;
         // int64_t target
-        _Module.HEAPU32[outSize as any >>> 2] = assembly.length;
-        _Module.HEAPU32[((outSize as any) + 4) >>> 2] = 0;
+        Module.HEAPU32[outSize as any >>> 2] = assembly.length;
+        Module.HEAPU32[((outSize as any) + 4) >>> 2] = 0;
         return true;
     }
-    _Module.HEAPU32[outDataStartPtr as any >>> 2] = 0;
-    _Module.HEAPU32[outSize as any >>> 2] = 0;
-    _Module.HEAPU32[((outSize as any) + 4) >>> 2] = 0;
+    Module.HEAPU32[outDataStartPtr as any >>> 2] = 0;
+    Module.HEAPU32[outSize as any >>> 2] = 0;
+    Module.HEAPU32[((outSize as any) + 4) >>> 2] = 0;
     return false;
 }
 
 export function BrowserHost_ResolveMain(exitCode:number) {
-    _netLoaderExports.resolveRunMainPromise(exitCode);
+    netLoaderExports.resolveRunMainPromise(exitCode);
 }
 
 export function BrowserHost_RejectMain(reason:any) {
-    _netLoaderExports.rejectRunMainPromise(reason);
+    netLoaderExports.rejectRunMainPromise(reason);
 }
 
 // WASM-TODO: take ideas from Mono
@@ -56,24 +56,24 @@ export function BrowserHost_RejectMain(reason:any) {
 export function exit(exit_code: number, reason: any): void {
     const reasonStr = reason ? (reason.stack ? reason.stack || reason.message : reason.toString()) : "";
     if (exit_code !== 0) {
-        _Logger.error(`Exit with code ${exit_code} ${reason ? "and reason: " + reasonStr : ""}`);
+        Logger.error(`Exit with code ${exit_code} ${reason ? "and reason: " + reasonStr : ""}`);
     }
-    if (_netJSEngine.IS_NODE) {
+    if (netJSEngine.IS_NODE) {
         (globalThis as any).process.exit(exit_code);
     }
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function runMain(mainAssemblyName?: string, args?: string[]): Promise<number> {
     // int BrowserHost_ExecuteAssembly(char * assemblyPath)
-    const res = _Module.ccall("BrowserHost_ExecuteAssembly", "number", ["string"], [mainAssemblyName]) as number;
+    const res = Module.ccall("BrowserHost_ExecuteAssembly", "number", ["string"], [mainAssemblyName]) as number;
     if (res != 0) {
         const reason = new Error("Failed to execute assembly");
         exit(res, reason);
         throw reason;
     }
 
-    return _netLoaderExports.getRunMainPromise();
+    return netLoaderExports.getRunMainPromise();
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars

src/native/corehost/browserhost/host/index.ts

@@ -27,10 +27,10 @@ export function netInitializeModule(internals: InternalExchange): void {
         registerDllBytes,
         isSharedArrayBuffer
     };
-    _netSetInternals(internals);
+    netSetInternals(internals);
     Object.assign(internals.netPublicApi, runtimeApiLocal);
-    internals.netBrowserHostExportsTable = [..._tabulateHE(hostNativeExportsLocal)];
-    _netUpdateAllInternals();
+    internals.netBrowserHostExportsTable = [...netTabulateHE(hostNativeExportsLocal)];
+    netUpdateAllInternals();
 }
 
 export { BrowserHost_ExternalAssemblyProbe, BrowserHost_ResolveMain, BrowserHost_RejectMain } from "./host";

src/native/corehost/browserhost/host/memory.ts

@@ -9,8 +9,8 @@ export const min_int64_big = BigInt("-9223372036854775808");
 export const sharedArrayBufferDefined = typeof SharedArrayBuffer !== "undefined";
 
 export function assert_int_in_range(value: Number, min: Number, max: Number) {
-    _Assert.check(Number.isSafeInteger(value), () => `Value is not an integer: ${value} (${typeof (value)})`);
-    _Assert.check(value >= min && value <= max, () => `Overflow: value ${value} is out of ${min} ${max} range`);
+    Assert.check(Number.isSafeInteger(value), () => `Value is not an integer: ${value} (${typeof (value)})`);
+    Assert.check(value >= min && value <= max, () => `Overflow: value ${value} is out of ${min} ${max} range`);
 }
 
 export function _zero_region(byteOffset: VoidPtr, sizeBytes: number): void {
@@ -22,24 +22,24 @@ export function setHeapB32(offset: MemOffset, value: number | boolean): void {
     const boolValue = !!value;
     if (typeof (value) === "number")
         assert_int_in_range(value, 0, 1);
-    _Module.HEAP32[<any>offset >>> 2] = boolValue ? 1 : 0;
+    Module.HEAP32[<any>offset >>> 2] = boolValue ? 1 : 0;
 }
 
 export function setHeapB8(offset: MemOffset, value: number | boolean): void {
     const boolValue = !!value;
     if (typeof (value) === "number")
         assert_int_in_range(value, 0, 1);
-    _Module.HEAPU8[<any>offset] = boolValue ? 1 : 0;
+    Module.HEAPU8[<any>offset] = boolValue ? 1 : 0;
 }
 
 export function setHeapU8(offset: MemOffset, value: number): void {
     assert_int_in_range(value, 0, 0xFF);
-    _Module.HEAPU8[<any>offset] = value;
+    Module.HEAPU8[<any>offset] = value;
 }
 
 export function setHeapU16(offset: MemOffset, value: number): void {
     assert_int_in_range(value, 0, 0xFFFF);
-    _Module.HEAPU16[<any>offset >>> 1] = value;
+    Module.HEAPU16[<any>offset >>> 1] = value;
 }
 
 // does not check for growable heap
@@ -50,43 +50,43 @@ export function setHeapU16_local(localView: Uint16Array, offset: MemOffset, valu
 
 // does not check for overflow nor growable heap
 export function setHeapU16_unchecked(offset: MemOffset, value: number): void {
-    _Module.HEAPU16[<any>offset >>> 1] = value;
+    Module.HEAPU16[<any>offset >>> 1] = value;
 }
 
 // does not check for overflow nor growable heap
 export function setHeapU32_unchecked(offset: MemOffset, value: NumberOrPointer): void {
-    _Module.HEAPU32[<any>offset >>> 2] = <number><any>value;
+    Module.HEAPU32[<any>offset >>> 2] = <number><any>value;
 }
 
 export function setHeapU32(offset: MemOffset, value: NumberOrPointer): void {
     assert_int_in_range(<any>value, 0, 0xFFFF_FFFF);
-    _Module.HEAPU32[<any>offset >>> 2] = <number><any>value;
+    Module.HEAPU32[<any>offset >>> 2] = <number><any>value;
 }
 
 export function setHeapI8(offset: MemOffset, value: number): void {
     assert_int_in_range(value, -0x80, 0x7F);
-    _Module.HEAP8[<any>offset] = value;
+    Module.HEAP8[<any>offset] = value;
 }
 
 export function setHeapI16(offset: MemOffset, value: number): void {
     assert_int_in_range(value, -0x8000, 0x7FFF);
-    _Module.HEAP16[<any>offset >>> 1] = value;
+    Module.HEAP16[<any>offset >>> 1] = value;
 }
 
 export function setHeapI32_unchecked(offset: MemOffset, value: number): void {
-    _Module.HEAP32[<any>offset >>> 2] = value;
+    Module.HEAP32[<any>offset >>> 2] = value;
 }
 
 export function setHeapI32(offset: MemOffset, value: number): void {
     assert_int_in_range(<any>value, -0x8000_0000, 0x7FFF_FFFF);
-    _Module.HEAP32[<any>offset >>> 2] = value;
+    Module.HEAP32[<any>offset >>> 2] = value;
 }
 
 /**
  * Throws for values which are not 52 bit integer. See Number.isSafeInteger()
  */
 export function setHeapI52(offset: MemOffset, value: number): void {
-    _Assert.check(Number.isSafeInteger(value), () => `Value is not a safe integer: ${value} (${typeof (value)})`);
+    Assert.check(Number.isSafeInteger(value), () => `Value is not a safe integer: ${value} (${typeof (value)})`);
     throw new Error("TODO");
     // const error = cwraps.mono_wasm_f64_to_i52(<any>offset, value);
     // autoThrowI52(error);
@@ -96,49 +96,49 @@ export function setHeapI52(offset: MemOffset, value: number): void {
  * Throws for values which are not 52 bit integer or are negative. See Number.isSafeInteger().
  */
 export function setHeapU52(offset: MemOffset, value: number): void {
-    _Assert.check(Number.isSafeInteger(value), () => `Value is not a safe integer: ${value} (${typeof (value)})`);
-    _Assert.check(value >= 0, "Can't convert negative Number into UInt64");
+    Assert.check(Number.isSafeInteger(value), () => `Value is not a safe integer: ${value} (${typeof (value)})`);
+    Assert.check(value >= 0, "Can't convert negative Number into UInt64");
     throw new Error("TODO");
     //const error = cwraps.mono_wasm_f64_to_u52(<any>offset, value);
     //autoThrowI52(error);
 }
 
 export function setHeapI64Big(offset: MemOffset, value: bigint): void {
-    _Assert.check(typeof value === "bigint", () => `Value is not an bigint: ${value} (${typeof (value)})`);
-    _Assert.check(value >= min_int64_big && value <= max_int64_big, () => `Overflow: value ${value} is out of ${min_int64_big} ${max_int64_big} range`);
+    Assert.check(typeof value === "bigint", () => `Value is not an bigint: ${value} (${typeof (value)})`);
+    Assert.check(value >= min_int64_big && value <= max_int64_big, () => `Overflow: value ${value} is out of ${min_int64_big} ${max_int64_big} range`);
 
-    _Module.HEAP64[<any>offset >>> 3] = value;
+    Module.HEAP64[<any>offset >>> 3] = value;
 }
 
 export function setHeapF32(offset: MemOffset, value: number): void {
-    _Assert.check(typeof value === "number", () => `Value is not a Number: ${value} (${typeof (value)})`);
-    _Module.HEAPF32[<any>offset >>> 2] = value;
+    Assert.check(typeof value === "number", () => `Value is not a Number: ${value} (${typeof (value)})`);
+    Module.HEAPF32[<any>offset >>> 2] = value;
 }
 
 export function setHeapF64(offset: MemOffset, value: number): void {
-    _Assert.check(typeof value === "number", () => `Value is not a Number: ${value} (${typeof (value)})`);
-    _Module.HEAPF64[<any>offset >>> 3] = value;
+    Assert.check(typeof value === "number", () => `Value is not a Number: ${value} (${typeof (value)})`);
+    Module.HEAPF64[<any>offset >>> 3] = value;
 }
 
 export function getHeapB32(offset: MemOffset): boolean {
-    const value = (_Module.HEAPU32[<any>offset >>> 2]);
+    const value = (Module.HEAPU32[<any>offset >>> 2]);
     if (value > 1 && !(getHeapB32 as any).warnDirtyBool) {
         (getHeapB32 as any).warnDirtyBool = true;
-        _Logger.warn(`getB32: value at ${offset} is not a boolean, but a number: ${value}`);
+        Logger.warn(`getB32: value at ${offset} is not a boolean, but a number: ${value}`);
     }
     return !!value;
 }
 
 export function getHeapB8(offset: MemOffset): boolean {
-    return !!(_Module.HEAPU8[<any>offset]);
+    return !!(Module.HEAPU8[<any>offset]);
 }
 
 export function getHeapU8(offset: MemOffset): number {
-    return _Module.HEAPU8[<any>offset];
+    return Module.HEAPU8[<any>offset];
 }
 
 export function getHeapU16(offset: MemOffset): number {
-    return _Module.HEAPU16[<any>offset >>> 1];
+    return Module.HEAPU16[<any>offset >>> 1];
 }
 
 // does not check for growable heap
@@ -147,7 +147,7 @@ export function getHeapU16_local(localView: Uint16Array, offset: MemOffset): num
 }
 
 export function getHeapU32(offset: MemOffset): number {
-    return _Module.HEAPU32[<any>offset >>> 2];
+    return Module.HEAPU32[<any>offset >>> 2];
 }
 
 // does not check for growable heap
@@ -156,11 +156,11 @@ export function getHeapU32_local(localView: Uint32Array, offset: MemOffset): num
 }
 
 export function getHeapI8(offset: MemOffset): number {
-    return _Module.HEAP8[<any>offset];
+    return Module.HEAP8[<any>offset];
 }
 
 export function getHeapI16(offset: MemOffset): number {
-    return _Module.HEAP16[<any>offset >>> 1];
+    return Module.HEAP16[<any>offset >>> 1];
 }
 
 // does not check for growable heap
@@ -169,7 +169,7 @@ export function getHeapI16_local(localView: Int16Array, offset: MemOffset): numb
 }
 
 export function getHeapI32(offset: MemOffset): number {
-    return _Module.HEAP32[<any>offset >>> 2];
+    return Module.HEAP32[<any>offset >>> 2];
 }
 
 // does not check for growable heap
@@ -202,60 +202,60 @@ export function getHeapU52(offset: MemOffset): number {
 }
 
 export function getHeapI64Big(offset: MemOffset): bigint {
-    return _Module.HEAP64[<any>offset >>> 3];
+    return Module.HEAP64[<any>offset >>> 3];
 }
 
 export function getHeapF32(offset: MemOffset): number {
-    return _Module.HEAPF32[<any>offset >>> 2];
+    return Module.HEAPF32[<any>offset >>> 2];
 }
 
 export function getHeapF64(offset: MemOffset): number {
-    return _Module.HEAPF64[<any>offset >>> 3];
+    return Module.HEAPF64[<any>offset >>> 3];
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewI8(): Int8Array {
-    return _Module.HEAP8;
+    return Module.HEAP8;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewI16(): Int16Array {
-    return _Module.HEAP16;
+    return Module.HEAP16;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewI32(): Int32Array {
-    return _Module.HEAP32;
+    return Module.HEAP32;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewI64Big(): BigInt64Array {
-    return _Module.HEAP64;
+    return Module.HEAP64;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewU8(): Uint8Array {
-    return _Module.HEAPU8;
+    return Module.HEAPU8;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewU16(): Uint16Array {
-    return _Module.HEAPU16;
+    return Module.HEAPU16;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewU32(): Uint32Array {
-    return _Module.HEAPU32;
+    return Module.HEAPU32;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewF32(): Float32Array {
-    return _Module.HEAPF32;
+    return Module.HEAPF32;
 }
 
 // returns memory view which is valid within current synchronous call stack
 export function localHeapViewF64(): Float64Array {
-    return _Module.HEAPF64;
+    return Module.HEAPF64;
 }
 
 export function copyBytes(srcPtr: VoidPtr, dstPtr: VoidPtr, bytes: number): void {

src/native/corehost/browserhost/libBrowserHost.footer.js

@@ -24,7 +24,7 @@
                         const HOST_PROPERTY_NATIVE_DLL_SEARCH_DIRECTORIES = "NATIVE_DLL_SEARCH_DIRECTORIES";
                         const HOST_PROPERTY_APP_PATHS = "APP_PATHS";
 
-                        const config = netInternals.config;
+                        const config = netInternals.netLoaderConfig;
                         const assemblyPaths = config.resources.assembly.map(a => a.virtualPath);
                         const coreAssemblyPaths = config.resources.coreAssembly.map(a => a.virtualPath);
                         ENV[HOST_PROPERTY_TRUSTED_PLATFORM_ASSEMBLIES] = config.environmentVariables[HOST_PROPERTY_TRUSTED_PLATFORM_ASSEMBLIES] = [...coreAssemblyPaths, ...assemblyPaths].join(":");

src/native/corehost/browserhost/loader/index.ts

@@ -12,7 +12,7 @@ import { exit } from "./exit";
 import { invokeLibraryInitializers } from "./lib-initializers";
 import { check, error, info, warn } from "./logging";
 
-import { Assert, netInternals, netJSEngine, netLoaderExports, tabulateLE, Logger, netSetInternals, netUpdateAllInternals, netUpdateModuleInternals } from "./cross-module";
+import { Assert, netInternals, netJSEngine, netLoaderExports, netTabulateLE, Logger, netSetInternals, netUpdateAllInternals, netUpdateModuleInternals } from "./cross-module";
 import { rejectRunMainPromise, resolveRunMainPromise, getRunMainPromise } from "./run";
 
 export function netInitializeModule(): RuntimeAPI {
@@ -78,7 +78,7 @@ export function netInitializeModule(): RuntimeAPI {
     Object.assign(Assert, assert);
     Object.assign(netJSEngine, jsEngine);
     Object.assign(netLoaderExports, loaderFunctions);
-    netInternals.netLoaderExportsTable = [...tabulateLE(Logger, Assert, netLoaderExports)];
+    netInternals.netLoaderExportsTable = [...netTabulateLE(Logger, Assert, netLoaderExports)];
     netInternalUpdates.push(netUpdateModuleInternals);
     netUpdateAllInternals();