porffor 0.0.0-650350 → 0.0.0-745e995

package/compiler/codeGen.js

@@ -327,13 +327,13 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   scope.memory = true;
 
-  const pointer = arrays.get(name ?? '$undeclared');
-
   const rightPointer = localTmp(scope, 'concat_right_pointer', Valtype.i32);
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
   if (assign) {
+    const pointer = arrays.get(name ?? '$undeclared');
+
     return [
       // setup right
       ...right,
@@ -384,15 +384,96 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
 
-  const newOut = makeArray(scope, {
+  // alloc/assign array
+  const [ , pointer ] = makeArray(scope, {
     rawElements: new Array(0)
   }, global, name, true, 'i16');
 
   return [
-    // setup new/out array
-    ...newOut,
-    [ Opcodes.drop ],
+    // setup left
+    ...left,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, leftPointer ],
+
+    // setup right
+    ...right,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, rightPointer ],
+
+    // calculate length
+    ...number(0, Valtype.i32), // base 0 for store later
 
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, leftLength ],
+
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, rightLength ],
+
+    [ Opcodes.i32_add ],
+
+    // store length
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
+
+    // copy left
+    // dst = out pointer + length size
+    ...number(pointer + ValtypeSize.i32, Valtype.i32),
+
+    // src = left pointer + length size
+    [ Opcodes.local_get, leftPointer ],
+    ...number(ValtypeSize.i32, Valtype.i32),
+    [ Opcodes.i32_add ],
+
+    // size = PageSize - length size. we do not need to calculate length as init value
+    ...number(pageSize - ValtypeSize.i32, Valtype.i32),
+    [ ...Opcodes.memory_copy, 0x00, 0x00 ],
+
+    // copy right
+    // dst = out pointer + length size + left length * i16 size
+    ...number(pointer + ValtypeSize.i32, Valtype.i32),
+
+    [ Opcodes.local_get, leftLength ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    [ Opcodes.i32_add ],
+
+    // src = right pointer + length size
+    [ Opcodes.local_get, rightPointer ],
+    ...number(ValtypeSize.i32, Valtype.i32),
+    [ Opcodes.i32_add ],
+
+    // size = right length * i16 size
+    [ Opcodes.local_get, rightLength ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_mul ],
+
+    [ ...Opcodes.memory_copy, 0x00, 0x00 ],
+
+    // return new string (page)
+    ...number(pointer)
+  ];
+};
+
+const compareStrings = (scope, left, right, global, name) => {
+  // todo: this should be rewritten into a built-in/func: String.prototype.concat
+  // todo: convert left and right to strings if not
+  // todo: optimize by looking up names in arrays and using that if exists?
+  // todo: optimize this if using literals/known lengths?
+
+  scope.memory = true;
+
+  const rightPointer = localTmp(scope, 'concat_right_pointer', Valtype.i32);
+  const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
+  const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
+  const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
+
+  // alloc/assign array
+  const [ , pointer ] = makeArray(scope, {
+    rawElements: new Array(0)
+  }, global, name, true, 'i16');
+
+  return [
     // setup left
     ...left,
     Opcodes.i32_to_u,
@@ -524,11 +605,28 @@ const truthy = (scope, wasm, type) => {
   ];
 };
 
-const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$unspecified', assign = false) => {
+const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$undeclared', assign = false) => {
   if (op === '||' || op === '&&' || op === '??') {
     return performLogicOp(scope, op, left, right);
   }
 
+  if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
+
+  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
+  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
+    return [
+      ...left,
+      ...right,
+
+      // drop values
+      [ Opcodes.drop ],
+      [ Opcodes.drop ],
+
+      // return false (===)/true (!==)
+      ...number(op === '===' ? 0 : 1, Valtype.i32)
+    ];
+  }
+
   if (leftType === TYPES.string || rightType === TYPES.string) {
     if (op === '+') {
       // string concat (a + b)
@@ -539,8 +637,13 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
 
     // else leave bool ops
-    // todo: convert string to number if string and number or le/ge op
-    // todo: string equality
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string equality
+    if (op === '===') {
+
+    }
   }
 
   let ops = operatorOpcode[valtype][op];
@@ -569,13 +672,17 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
+let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
+  binaryExpDepth++;
+
   const out = [
     ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
   ];
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
+  binaryExpDepth--;
   return out;
 };
 
@@ -696,7 +803,7 @@ const getNodeType = (scope, node) => {
   if (node.type === 'CallExpression' || node.type === 'NewExpression') {
     const name = node.callee.name;
     const func = funcs.find(x => x.name === name);
-    if (func) return func.returnType ?? TYPES.number;
+    if (func) return func.returnType;
 
     if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
     if (internalConstrs[name]) return internalConstrs[name].type;
@@ -721,9 +828,7 @@ const getNodeType = (scope, node) => {
       protoFunc = prototypeFuncs[baseType]?.[func];
     }
 
-    if (protoFunc) return protoFunc.returnType ?? TYPES.number;
-
-    return TYPES.number;
+    if (protoFunc) return protoFunc.returnType;
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -755,9 +860,6 @@ const getNodeType = (scope, node) => {
 
     if (objectType === TYPES.string && node.computed) return TYPES.string;
   }
-
-  // default to number
-  return TYPES.number;
 };
 
 const generateLiteral = (scope, decl, global, name) => {
@@ -792,7 +894,7 @@ const generateLiteral = (scope, decl, global, name) => {
 
       return makeArray(scope, {
         rawElements
-      }, global, name, false, 'i16');
+      }, global, name, false, 'i16')[0];
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -941,10 +1043,9 @@ const generateCall = (scope, decl, _global, _name) => {
       if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
 
       // register array
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
-      pointer = arrays.get(baseName);
 
       const [ local, isGlobal ] = lookupName(scope, baseName);
 
@@ -980,10 +1081,9 @@ const generateCall = (scope, decl, _global, _name) => {
         set: value => arrayUtil.setLength(pointer, value),
         setI32: value => arrayUtil.setLengthI32(pointer, value)
       }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        const out = makeArray(scope, {
+        return makeArray(scope, {
           rawElements: new Array(length)
         }, _global, _name, true, itemType);
-        return [ out, arrays.get(_name ?? '$undeclared') ];
       }),
       [ Opcodes.end ]
     ];
@@ -1289,7 +1389,7 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument);
+      const type = getNodeType(scope, decl.argument) ?? TYPES.number;
 
       // for custom types, just return object
       if (type > 0xffffffffffff7) return number(TYPES.object);
@@ -1578,12 +1678,12 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
   scope.memory = true;
 
-  return out;
+  return [ out, pointer ];
 };
 
 let arrays = new Map();
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype);
+  return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
 export const generateMember = (scope, decl, _global, _name) => {
@@ -1644,10 +1744,9 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   // string
 
-  const newOut = makeArray(scope, {
+  const [ newOut, newPointer ] = makeArray(scope, {
     rawElements: new Array(1)
   }, _global, _name, true, 'i16');
-  const newPointer = arrays.get(_name ?? '$undeclared');
 
   return [
     // setup new/out array
@@ -1753,7 +1852,7 @@ const generateFunc = (scope, decl) => {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length).map(x => x.type),
     returns: innerScope.returns,
-    returnType: innerScope.returnType ?? TYPES.number,
+    returnType: innerScope.returnType,
     locals: innerScope.locals,
     memory: innerScope.memory,
     throws: innerScope.throws,
@@ -1912,10 +2011,9 @@ const internalConstrs = {
 
       // new Array(n)
 
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, global, name, true);
-      const pointer = arrays.get(name ?? '$undeclared');
 
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.0.0-0650350",
+  "version": "0.0.0-745e995",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/runner/repl.js

@@ -51,12 +51,12 @@ const memoryToString = mem => {
 let prev = '';
 const run = async (source, _context, _filename, callback, run = true) => {
   let toRun = prev + source.trim();
-  prev = toRun + ';\n';
+  // prev = toRun + ';\n';
 
   const { exports, wasm, pages } = await compile(toRun, []);
   fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
-  if (exports.$) {
+  if (run && exports.$) {
     lastMemory = exports.$;
     lastPages = [...pages.keys()];
   }
@@ -64,7 +64,7 @@ const run = async (source, _context, _filename, callback, run = true) => {
   const ret = run ? exports.main() : undefined;
   callback(null, ret);
 
-  // if (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ')) prev += source + ';\n';
+  if (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ') || source.includes('function ')) prev = toRun + ';\n';
   // prev = toRun + ';\n';
 };