porffor 0.17.0-b7ba5b83d → 0.17.0-b92c546cf

package/compiler/2c.js

@@ -182,7 +182,15 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   }, {});
   const invGlobals = inv(globals, x => x.idx);
 
-  const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => String.fromCharCode(97 + _.charCodeAt(0) % 32));
+  const codeToSanitizedStr = code => {
+    let out = '';
+    while (code > 0) {
+      out += String.fromCharCode(97 + code % 26);
+      code -= 26;
+    }
+    return out;
+  };
+  const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => codeToSanitizedStr(_.charCodeAt(0)));
 
   for (const x in invGlobals) {
     invGlobals[x] = sanitize(invGlobals[x]);
@@ -273,10 +281,11 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     }
 
     const returns = f.returns.length > 0;
+    const typedReturns = f.returnType == null;
 
     const shouldInline = false; // f.internal;
     if (f.name === 'main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
-      else out += `${f.internal ? (returns ? 'f64' : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+      else out += `${!typedReturns ? (returns ? CValtype[f.returns[0]] : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
     if (f.name === 'main') {
       out += '  ' + [...prependMain.values()].join('\n  ');
@@ -418,11 +427,14 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           continue;
 
         case Opcodes.return:
-          // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
-          const b = vals.pop();
-          const a = vals.pop();
+          if (!typedReturns) {
+            line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
+            break;
+          }
+
+          const b = returns ? vals.pop() : -1;
+          const a = returns ? vals.pop() : -1;
           line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(a)}, ${removeBrackets(b)} }` : ''}`);
-          // line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
         case Opcodes.if: {
@@ -549,10 +561,15 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
                 prepend.set('__Porffor_readFile',
 `i32 __Porffor_readFile(u32 pathPtr, u32 outPtr) {
-  char* path = _memory + pathPtr + 4;
-  FILE* fp = fopen(path, "r");
-  if (fp == NULL) {
-    return -1;
+  FILE* fp;
+  if (pathPtr == 0) {
+    fp = stdin;
+  } else {
+    char* path = _memory + pathPtr + 4;
+    fp = fopen(path, "r");
+    if (fp == NULL) {
+      return -1;
+    }
   }
 
   u32 read = 0;
@@ -585,7 +602,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           for (let j = 0; j < func.params.length; j++) args.unshift(removeBrackets(vals.pop()));
 
           if (func.returns.length > 0) {
-            if (func.internal) {
+            if (func.returnType != null) {
               vals.push(`${sanitize(func.name)}(${args.join(', ')})`);
             } else {
               const id = retTmpId++;

package/compiler/builtins/array.ts

@@ -225,6 +225,16 @@ export const __Array_prototype_every = (_this: any[], callbackFn: any) => {
   return true;
 };
 
+export const __Array_prototype_some = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (Boolean(callbackFn(_this[i], i++, _this))) return true;
+  }
+
+  return false;
+};
+
 export const __Array_prototype_reduce = (_this: any[], callbackFn: any, initialValue: any) => {
   let acc: any = initialValue ?? _this[0];
 
@@ -237,6 +247,18 @@ export const __Array_prototype_reduce = (_this: any[], callbackFn: any, initialV
   return acc;
 };
 
+export const __Array_prototype_reduceRight = (_this: any[], callbackFn: any, initialValue: any) => {
+  const len: i32 = _this.length;
+  let acc: any = initialValue ?? _this[len - 1];
+
+  let i: i32 = len;
+  while (i > 0) {
+    acc = callbackFn(acc, _this[--i], i, _this);
+  }
+
+  return acc;
+};
+
 export const __Array_prototype_toString = (_this: any[]) => {
   // todo: this is bytestring only!
 

package/compiler/builtins/math.ts

@@ -16,7 +16,7 @@ export const __Math_exp = (x: number): number => {
     return 1 / Math.exp(-x);
   }
 
-  const k: number = Math.floor(x / Math.LN2);
+  let k: number = Math.floor(x / Math.LN2);
   const r: number = x - k * Math.LN2;
 
   // Taylor series via Horner's method
@@ -30,7 +30,11 @@ export const __Math_exp = (x: number): number => {
     i++;
   }
 
-  return sum * (1 << k);
+  while (k-- > 0) {
+    sum *= 2;
+  }
+
+  return sum;
 };
 
 export const __Math_log2 = (y: number): number => {

package/compiler/builtins/set.ts

@@ -170,15 +170,8 @@ export const Set = () => {
 export const Set$constructor = (iterable: any): Set => {
   const out: Set = __Porffor_allocate();
 
-  const type: number = Porffor.rawType(iterable);
-  if (Porffor.fastOr(
-    type == Porffor.TYPES.array,
-    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
-    type == Porffor.TYPES.set
-  )) {
-    for (const x of iterable) {
-      __Set_prototype_add(out, x);
-    }
+  if (Porffor.rawType(iterable) != Porffor.TYPES.undefined) for (const x of iterable) {
+    __Set_prototype_add(out, x);
   }
 
   return out;

package/compiler/builtins/typedarray.js

@@ -0,0 +1,47 @@
+export default () => {
+  let out = '';
+
+  const constr = name => out += `export const ${name} = () => {
+  throw new TypeError("Constructor ${name} requires 'new'");
+};
+
+export const ${name}$constructor = (arg: any): ${name} => {
+  const out: ${name} = Porffor.allocate();
+  let len: i32 = 0;
+
+  const type: i32 = Porffor.rawType(arg);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set
+  )) {
+    let i: i32 = 0;
+    for (const x of arg) {
+      out[i++] = x;
+    }
+    len = i;
+  } else if (type == Porffor.TYPES.number) {
+    len = arg;
+  }
+
+  out.length = len;
+  return out;
+};
+
+export const __${name}_prototype_byteLength$get = (_this: ${name}) => {
+  return _this.length * ${name}.BYTES_PER_ELEMENT;
+};
+`;
+
+  constr('Uint8Array');
+  constr('Int8Array');
+  constr('Uint8ClampedArray');
+  constr('Uint16Array');
+  constr('Int16Array');
+  constr('Uint32Array');
+  constr('Int32Array');
+  constr('Float32Array');
+  constr('Float64Array');
+
+  return out;
+};

package/compiler/builtins.js

@@ -160,6 +160,17 @@ export const BuiltinVars = function() {
   this.__performance_timeOrigin = [
     [ Opcodes.call, importedFuncs.timeOrigin ]
   ];
+
+
+  this.__Uint8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Int8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Uint8ClampedArray_BYTES_PER_ELEMENT = number(1);
+  this.__Uint16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Int16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Uint32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Int32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float64Array_BYTES_PER_ELEMENT = number(8);
 };
 
 export const BuiltinFuncs = function() {
@@ -184,6 +195,20 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this['f64_**'] = this['i32_**'] = {
+    params: [ valtypeBinary, valtypeBinary ],
+    locals: [],
+    returns: [ valtypeBinary ],
+    returnType: TYPES.number,
+    wasm: (scope, { builtin }) => [
+      [ Opcodes.local_get, 0 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.local_get, 1 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.call, builtin('__Math_pow') ]
+    ]
+  };
+
   // add bitwise ops by converting operands to i32 first
   for (const [ char, op ] of [ ['&', Opcodes.i32_and], ['|', Opcodes.i32_or], ['^', Opcodes.i32_xor], ['<<', Opcodes.i32_shl], ['>>', Opcodes.i32_shr_s], ['>>>', Opcodes.i32_shr_u] ]) {
     this[`f64_${char}`] = {