porffor 0.2.0-6aff0fa → 0.2.0-6bc63ef

package/compiler/builtins/array.ts

@@ -0,0 +1,145 @@
+export const __Array_isArray = (x: unknown): boolean =>
+  // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
+  Porffor.rawType(x) == Porffor.TYPES.array;
+
+export const __Array_prototype_slice = (_this: any[], start: number, end: number) => {
+  const len: i32 = _this.length;
+  if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  let out: any[] = [];
+
+  if (start > end) return out;
+
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+  let thisPtr: i32 = Porffor.wasm`local.get ${_this}`;
+
+  const thisPtrEnd: i32 = thisPtr + end * 8;
+
+  thisPtr += start * 8;
+
+  while (thisPtr < thisPtrEnd) {
+    Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
+    thisPtr += 8;
+    outPtr += 8;
+  }
+
+  out.length = end - start;
+
+  return out;
+};
+
+export const __Array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const __Array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = len - 1; i >= position; i--) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const __Array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return true;
+  }
+
+  return false;
+};
+
+export const __Array_prototype_with = (_this: any[], index: number, value: any) => {
+  const len: i32 = _this.length;
+  if (index < 0) {
+    index = len + index;
+    if (index < 0) {
+      throw new RangeError('Invalid index');
+    }
+  }
+
+  if (index > len) {
+    throw new RangeError('Invalid index');
+  }
+
+  // todo: allocator is bad here?
+  let out: any[] = [];
+
+  Porffor.clone(_this, out);
+
+  out[index] = value;
+
+  return out;
+};
+
+export const __Array_prototype_reverse = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  while (start < end) {
+    const tmp: i32 = _this[start];
+    _this[start++] = _this[end];
+    _this[end--] = tmp;
+  }
+
+  return _this;
+};
+
+// todo: this has memory/allocation bugs so sometimes crashes :(
+export const __Array_prototype_toReversed = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  let out: any[] = [];
+  out.length = len;
+
+  while (start < end) {
+    out[start] = _this[end];
+    out[end--] = _this[start++];
+  }
+
+  return out;
+};
+
+export const __Array_prototype_valueOf = (_this: any[]) => {
+  return _this;
+};

package/compiler/builtins/base64.ts

@@ -1,95 +1,17 @@
-// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
-
-import type { i32, bytestring } from './porffor.d.ts';
-
-// while (len >= 8) {
-//   Porffor.wasm`
-// local tmp i64
-// local.get ${i}
-// i64.load 0 4
-// local.set tmp
-
-// local k i64
-// i64.const 0
-// local.set k
-
-// loop 64
-// local.get ${j}
-
-// local.get ${keyStrPtr}
-
-// local.get tmp
-
-// ;; k * 6
-// i64.const 58
-
-// local.get k
-// i64.const 6
-// i64.mul
-
-// i64.sub
-
-// ;; tmp >> (58 - (k * 6))
-// i64.shr_u
-
-// ;; (tmp >> (58 - (k * 6))) & 0x3f
-// i64.const 63
-// i64.and
-
-// i32.wrap_i64
-
-// ;; keyStrPtr + ...
-// i32.add
-
-// ;; load character from keyStr
-// i32.load8_u 0 4
-
-// ;; store in output at j
-// i32.store8 0 4
-
-// local.get ${j}
-// i32.const 1
-// i32.add
-// local.set ${j}
-
-// local.get k
-// i64.const 1
-// i64.add
-// local.tee k
-
-// i64.const 8
-// i64.lt_s
-// br_if 0
-// end
-
-// `;
-
-//   // len -= 6;
-//   i += 6;
-// }
-
-//     // while (k < 8) {
-//     //   Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + Porffor.wasm.i32.wrap_i64(Porffor.wasm.i64.and(
-//     //     Porffor.wasm.i64.shr_u(tmp, Porffor.wasm.i64.extend_i32_u(58 - k * 6)),
-//     //     Porffor.wasm.i64.const(0x3f)
-//     //   )), 0, 4), 0, 4);
-//     //   k += 1;
-//     // }
-
-//     i += 6;
-//     len -= 6;
-//   }
+// @porf --valtype=i32
 
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-  const keyStrPtr: i32 = Porffor.i32.ptrUnsafe(keyStr);
+  const keyStrPtr: i32 = Porffor.wasm`local.get ${keyStr}`;
 
   let len: i32 = input.length;
   let output: bytestring = '';
   output.length = 4 * (len / 3 + !!(len % 3));
 
-  let i: i32 = Porffor.i32.ptrUnsafe(input),
-      j: i32 = Porffor.i32.ptrUnsafe(output);
+  let i: i32 = Porffor.wasm`local.get ${input}`,
+      j: i32 = Porffor.wasm`local.get ${output}`;
+
+  // todo/perf: add some per 6 char variant using bitwise magic
 
   const endPtr = i + len;
   while (i < endPtr) {
@@ -118,6 +40,7 @@ export const btoa = (input: bytestring): bytestring => {
   return output;
 };
 
+// todo: impl atob by converting below to "porf ts"
 /* var atob = function (input) {
   const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 

package/compiler/builtins/boolean.ts

@@ -0,0 +1,18 @@
+// 20.3.3.2 Boolean.prototype.toString ()
+// https://tc39.es/ecma262/#sec-boolean.prototype.tostring
+export const __Boolean_prototype_toString = (_this: boolean) => {
+  // 1. Let b be ? ThisBooleanValue(this value).
+  // 2. If b is true, return "true"; else return "false".
+  let out: bytestring = '';
+  if (_this) out = 'true';
+    else out = 'false';
+
+  return out;
+};
+
+// 20.3.3.3 Boolean.prototype.valueOf ()
+// https://tc39.es/ecma262/#sec-boolean.prototype.valueof
+export const __Boolean_prototype_valueOf = (_this: boolean) => {
+  // 1. Return ? ThisBooleanValue(this value).
+  return _this;
+};

package/compiler/builtins/crypto.ts

@@ -0,0 +1,120 @@
+// @porf --valtype=i32
+
+export const __crypto_randomUUID = (): bytestring => {
+  let bytes: bytestring = '................';
+
+  const bytesPtr: i32 = Porffor.wasm`local.get ${bytes}`;
+
+  let a: i32 = bytesPtr;
+  let aEndPtr: i32 = a + 16;
+  while (a < aEndPtr) {
+    Porffor.wasm.i32.store8(a++, Porffor.randomByte(), 0, 4);
+  }
+
+  // bytes[6] = (bytes[6] & 0b00001111) | 0b01000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 10) & 0b00001111) | 0b01000000,
+    0,
+    10 // 4 + 6
+  );
+
+  // bytes[8] = (bytes[8] & 0b00111111) | 0b10000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 12) & 0b00111111) | 0b10000000,
+    0,
+    12 // 4 + 8
+  );
+
+  let output: bytestring = '------------------------------------';
+
+  let i: i32 = Porffor.wasm`local.get ${output}`;
+  let j: i32 = bytesPtr;
+
+  // bytes[0..4]-bytes[4..6]-bytes[6..8]-bytes[8..10]-bytes[10..15]
+  // 00112233-4455-6677-8899-aabbccddeeff
+
+  // bytes[0..4]-
+  let endPtr: i32 = i + 8;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[4..6]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[6..8]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[8..10]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[10..15]
+  endPtr = i + 12;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+
+  return output;
+};