porffor 0.18.17 → 0.18.19

package/compiler/builtins/array.ts

@@ -531,6 +531,9 @@ export const __Array_prototype_toString = (_this: any[]) => {
   return out;
 };
 
+// @porf-typed-array
+export const __Array_prototype_toLocaleString = (_this: any[]) => __Array_prototype_toString(_this);
+
 // @porf-typed-array
 export const __Array_prototype_join = (_this: any[], _separator: any) => {
   // todo: this is bytestring only!

package/compiler/builtins/number.ts

@@ -320,6 +320,8 @@ export const __Number_prototype_toFixed = (_this: number, fractionDigits: number
   return out;
 };
 
+export const __Number_prototype_toLocaleString = (_this: number) => __Number_prototype_toString(_this, 10);
+
 // fractionDigits: number|any for rawType check
 export const __Number_prototype_toExponential = (_this: number, fractionDigits: number|any) => {
   let out: bytestring = Porffor.allocate();
@@ -518,3 +520,142 @@ export const __Number_prototype_valueOf = (_this: number) => {
   // 1. Return ? ThisNumberValue(this value).
   return _this;
 };
+
+
+export const parseInt = (input: string|bytestring, radix: number): f64 => {
+  // todo/perf: optimize this instead of doing a naive algo (https://kholdstare.github.io/technical/2020/05/26/faster-integer-parsing.html)
+  // todo/perf: use i32s here once that becomes not annoying
+
+  if (radix == 0) radix = 10;
+  if (radix < 2 || radix > 36) return NaN;
+
+  let nMax: f64 = 58;
+  if (radix < 10) nMax = 48 + radix;
+
+  let n: f64 = NaN;
+
+  const inputPtr: f64 = Porffor.wasm`local.get ${input}`;
+  const len: f64 = Porffor.wasm.i32.load(inputPtr, 0, 0);
+  let i: f64 = inputPtr;
+
+  let negative: boolean = false;
+
+  if (Porffor.rawType(input) == Porffor.TYPES.bytestring) {
+    const endPtr: f64 = i + len;
+
+    // check start of string
+    const startChr: f64 = Porffor.wasm.i32.load8_u(i, 0, 4);
+
+    // +, ignore
+    if (startChr == 43) i++;
+
+    // -, switch to negative
+    if (startChr == 45) {
+      negative = true;
+      i++;
+    }
+
+    // 0, potential start of hex
+    if (startChr == 48) {
+      const second: f64 = Porffor.wasm.i32.load8_u(i + 1, 0, 4);
+      // 0x or 0X
+      if (second == 120 || second == 88) {
+        // set radix to 16 and skip leading 2 chars
+        i += 2;
+        radix = 16;
+      }
+    }
+
+    while (i < endPtr) {
+      const chr: f64 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+
+      if (chr >= 48 && chr < nMax) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 48;
+      } else if (radix > 10) {
+        if (chr >= 97 && chr < (87 + radix)) {
+          if (Number.isNaN(n)) n = 0;
+
+          n *= radix;
+          n += chr - 87;
+        } else if (chr >= 65 && chr < (55 + radix)) {
+          if (Number.isNaN(n)) n = 0;
+
+          n *= radix;
+          n += chr - 55;
+        } else {
+          if (negative) return -n;
+          return n;
+        }
+      } else {
+        if (negative) return -n;
+        return n;
+      }
+    }
+
+    if (negative) return -n;
+    return n;
+  }
+
+  const endPtr: f64 = i + len * 2;
+
+  // check start of string
+  const startChr: f64 = Porffor.wasm.i32.load16_u(i, 0, 4);
+
+  // +, ignore
+  if (startChr == 43) i += 2;
+
+  // -, switch to negative
+  if (startChr == 45) {
+    negative = true;
+    i += 2;
+  }
+
+  // 0, potential start of hex
+  if (startChr == 48) {
+    const second: f64 = Porffor.wasm.i32.load16_u(i + 2, 0, 4);
+    // 0x or 0X
+    if (second == 120 || second == 88) {
+      // set radix to 16 and skip leading 2 chars
+      i += 4;
+      radix = 16;
+    }
+  }
+
+  while (i < endPtr) {
+    const chr: f64 = Porffor.wasm.i32.load16_u(i, 0, 4);
+    i += 2;
+
+    if (chr >= 48 && chr < nMax) {
+      if (Number.isNaN(n)) n = 0;
+
+      n *= radix;
+      n += chr - 48;
+    } else if (radix > 10) {
+      if (chr >= 97 && chr < (87 + radix)) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 87;
+      } else if (chr >= 65 && chr < (55 + radix)) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 55;
+      } else {
+        if (negative) return -n;
+        return n;
+      }
+    } else {
+      if (negative) return -n;
+      return n;
+    }
+  }
+
+  if (negative) return -n;
+  return n;
+};
+
+export const __Number_parseInt = (input: string|bytestring, radix: number): f64 => parseInt(input, radix);

package/compiler/builtins/object.ts

@@ -3,4 +3,6 @@ import type {} from './porffor.d.ts';
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';
   return out;
-};
+};
+
+export const __Object_prototype_toLocaleString = (_this: object) => __Object_prototype_toLocaleString(_this);

package/compiler/builtins/set.ts

@@ -191,4 +191,6 @@ export const __Set_prototype_union = (_this: Set, other: any) => {
 export const __Set_prototype_toString = (_this: Set) => {
   const out: bytestring = '[object Set]';
   return out;
-};
+};
+
+export const __Set_prototype_toLocaleString = (_this: Set) => __Set_prototype_toString(_this);

package/compiler/builtins/string.ts

@@ -1031,7 +1031,6 @@ export const __ByteString_prototype_trimEnd = (_this: bytestring) => {
   return out;
 };
 
-
 export const __String_prototype_trim = (_this: string) => {
   // todo/perf: optimize and not just reuse
   return __String_prototype_trimStart(__String_prototype_trimEnd(_this));
@@ -1042,6 +1041,7 @@ export const __ByteString_prototype_trim = (_this: bytestring) => {
   return __ByteString_prototype_trimStart(__ByteString_prototype_trimEnd(_this));
 };
 
+
 // 22.1.3.29 String.prototype.toString ()
 // https://tc39.es/ecma262/#sec-string.prototype.tostring
 export const __String_prototype_toString = (_this: string) => {
@@ -1054,6 +1054,8 @@ export const __ByteString_prototype_toString = (_this: bytestring) => {
   return _this;
 };
 
+export const __String_prototype_toLocaleString = (_this: string) => __String_prototype_toString(_this);
+export const __ByteString_prototype_toLocaleString = (_this: bytestring) => __ByteString_prototype_toString(_this);
 
 // 22.1.3.35 String.prototype.valueOf ()
 // https://tc39.es/ecma262/#sec-string.prototype.valueof

package/compiler/builtins/symbol.ts

@@ -58,6 +58,8 @@ export const __Symbol_prototype_toString = (_this: Symbol) => {
   return out;
 };
 
+export const __Symbol_prototype_toLocaleString = (_this: Symbol) => __Symbol_prototype_toString(_this);
+
 export const __Symbol_prototype_valueOf = (_this: Symbol) => {
   return _this;
 };

package/compiler/codegen.js

@@ -1138,9 +1138,11 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
   }
 
   for (const x of _data) {
-    const copy = { ...x };
-    if (copy.offset != null) copy.offset += pages.size * pageSize;
-    data.push(copy);
+    let offset = x[0];
+    if (offset != null) offset += pages.size * pageSize;
+
+    const bytes = x[1];
+    data.push({ offset, bytes });
   }
 
   const func = {