porffor 0.2.0-fbab1de → 0.2.0-fdf0fc5

package/compiler/builtins/annexb_string.js

@@ -0,0 +1,72 @@
+export default () => {
+  let out = `// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+`;
+
+  const annexB_noArgs = (a0, a1) => out += `
+export const __String_prototype_${a0} = (_this: string) => {
+  let out: string = Porffor.s\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${(2 + a1.length) * 2};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen * 2;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load16_u(thisPtr, 0, 4);
+    Porffor.wasm.i32.store16(outPtr, chr, 0, 4);
+
+    thisPtr += 2;
+    outPtr += 2;
+  }
+
+  Porffor.wasm.i32.store16(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store16(outPtr, 47, 0, 6); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store16(outPtr, ${x.charCodeAt(0)}, 0, ${8 + i * 2}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store16(outPtr, 62, 0, ${8 + a1.length * 2}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+export const __ByteString_prototype_${a0} = (_this: bytestring) => {
+  let out: bytestring = Porffor.bs\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${2 + a1.length};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load8_u(thisPtr++, 0, 4);
+    Porffor.wasm.i32.store8(outPtr++, chr, 0, 4);
+  }
+
+  Porffor.wasm.i32.store8(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store8(outPtr, 47, 0, 5); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store8(outPtr, ${x.charCodeAt(0)}, 0, ${6 + i}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store8(outPtr, 62, 0, ${6 + a1.length}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+`;
+
+  annexB_noArgs('big', 'big');
+  annexB_noArgs('blink', 'blink');
+  annexB_noArgs('bold', 'b');
+  annexB_noArgs('fixed', 'tt');
+  annexB_noArgs('italics', 'i');
+  annexB_noArgs('small', 'small');
+  annexB_noArgs('strike', 'strike');
+  annexB_noArgs('sub', 'sub');
+  annexB_noArgs('sup', 'sup');
+
+  return out;
+};

package/compiler/builtins/annexb_string.ts

@@ -0,0 +1,18 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+export const __String_prototype_trimLeft = (_this: string) => {
+  return __String_prototype_trimStart(_this);
+};
+
+export const __ByteString_prototype_trimLeft = (_this: string) => {
+  return __ByteString_prototype_trimStart(_this);
+};
+
+
+export const __String_prototype_trimRight = (_this: string) => {
+  return __String_prototype_trimEnd(_this);
+};
+
+export const __ByteString_prototype_trimEnd = (_this: string) => {
+  return __ByteString_prototype_trimRight(_this);
+};

package/compiler/builtins/array.ts

@@ -0,0 +1,149 @@
+// @porf --funsafe-no-unlikely-proto-checks
+
+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) {
+      // todo: throw RangeError: Invalid index
+      return null;
+    }
+  }
+
+  if (index > len) {
+    // todo: throw RangeError: Invalid index
+    return null;
+  }
+
+  // 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

@@ -0,0 +1,76 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+export const btoa = (input: bytestring): bytestring => {
+  const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  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.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) {
+    const chr1: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+    const chr2: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+    const chr3: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+
+    const enc1: i32 = chr1 >> 2;
+    const enc2: i32 = ((chr1 & 3) << 4) | (chr2 == -1 ? 0 : (chr2 >> 4));
+    let enc3: i32 = ((chr2 & 15) << 2) | (chr3 == -1 ? 0 : (chr3 >> 6));
+    let enc4: i32 = chr3 & 63;
+
+    if (chr2 == -1) {
+      enc3 = 64;
+      enc4 = 64;
+    } else if (chr3 == -1) {
+      enc4 = 64;
+    }
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc2, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc3, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc4, 0, 4), 0, 4);
+  }
+
+  return output;
+};
+
+// todo: impl atob by converting below to "porf ts"
+/* var atob = function (input) {
+  const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+  let output = "";
+  let chr1, chr2, chr3;
+  let enc1, enc2, enc3, enc4;
+  let i = 0;
+
+  while (i < input.length) {
+    enc1 = keyStr.indexOf(input.charAt(i++));
+    enc2 = keyStr.indexOf(input.charAt(i++));
+    enc3 = keyStr.indexOf(input.charAt(i++));
+    enc4 = keyStr.indexOf(input.charAt(i++));
+
+    chr1 = (enc1 << 2) | (enc2 >> 4);
+    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+    chr3 = ((enc3 & 3) << 6) | enc4;
+
+    // output += String.fromCharCode(chr1);
+    Porffor.bytestring.appendCharCode(output, chr1);
+
+    if (enc3 != 64) {
+      // output += String.fromCharCode(chr2);
+      Porffor.bytestring.appendCharCode(output, chr2);
+    }
+    if (enc4 != 64) {
+      // output += String.fromCharCode(chr3);
+      Porffor.bytestring.appendCharCode(output, chr3);
+    }
+  }
+
+  return output;
+}; */

package/compiler/builtins/boolean.ts

@@ -0,0 +1,20 @@
+// @porf --funsafe-no-unlikely-proto-checks
+
+// 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 --funsafe-no-unlikely-proto-checks --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;
+};