Memory improvements + Type analysis

compiler/allocators.js

@@ -36,6 +36,7 @@ export class StaticAllocator {
 
   alloc({ scope, pages }, name, { itemType }) {
     const reason = `${this.allocType(itemType)}: ${Prefs.scopedPageNames ? (scope.name + '/') : ''}${name}`;
+    if (Prefs.allocLog) console.log(reason)
 
     if (pages.has(reason)) return number(this.ptr(pages.get(reason).ind), Valtype.i32);
 
@@ -52,6 +53,51 @@ export class StaticAllocator {
 
     return number(this.ptr(ind), Valtype.i32);
   }
+
+  stringPageIndex = 0;
+
+  allocString(pages, str) {
+    let page = { ind: -1, strs: [], strIndex: new Map(), byteSize: 0 }
+    let size = Prefs.bytestring ? 1 : 2;
+    for (let i = 0; i < str.length; i++) {
+      if (str.charCodeAt(i) > 0xFF) {
+        size = 2;
+        break;
+      }
+    }
+    pages.hasAnyString = true;
+    if (size == 1) pages.hasByteString = true;
+    else pages.hasString = true;
+
+    for (let i = 0; i < this.stringPageIndex; i++) {
+      if (pages.has(`strings${i}`)) {
+        const p = pages.get(`strings${i}`);
+        const index = p.strIndex.get(str);
+        if (index) {
+          if (Prefs.allocLog) console.log("cstr/ref: "+ str)
+          return [p.strs[index].ptr, true];
+        }
+        if ((p.byteSize + (4 + str.length * size)) >= pageSize) {
+          page = p;
+          break;
+        }
+      }
+    }
+    if (page.ind == -1) {
+      const ind = pages.size;
+      page.ind = ind;
+      pages.set(`strings${this.stringPageIndex}`, page);
+      this.stringPageIndex++;
+    }
+
+    let ptr = this.ptr(page.ind) + page.byteSize;
+    page.byteSize += 4 + str.length * size; // u32 + u16[len] (or u8)
+    const index = page.strs.push({ str, ptr, size }) - 1;
+    page.strIndex.set(str, index);
+
+    if (Prefs.allocLog) console.log("cstr/init: "+ str)
+    return [ptr, false];
+  }
 }
 
 export class GrowAllocator {

compiler/builtins/string_f64.ts

@@ -5,4 +5,154 @@ import type {} from './porffor.d.ts';
 export const String = function (value: any): bytestring {
   if (!new.target && Porffor.rawType(value) == Porffor.TYPES.symbol) return __Symbol_prototype_toString(value);
   return __ecma262_ToString(value);
-};
+};
+
+export const __String_prototype_concat = (_this: string, arg: string) => {
+  // 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?
+  let out: string = Porffor.s``;
+  Porffor.wasm`
+  local leftLength i32
+  local leftPtr i32
+  local rightLength i32
+  local rightPtr i32
+  local outPtr i32
+
+  local.get ${_this}
+  i32.to_u
+  local.set leftPtr
+
+  local.get ${arg}
+  i32.to_u
+  local.set rightPtr
+
+  local.get ${out}
+  i32.to_u
+  local.set outPtr
+
+  ;; calculate length
+  local.get outPtr
+
+  local.get leftPtr
+  i32.load 0 0 
+  local.tee leftLength
+  local.get rightPtr
+
+  i32.load 0 0 
+  local.tee rightLength
+  i32.add
+  ;; store out length
+  i32.store 0 0
+  ;; copy left
+  ;; dst = out pointer + length size
+  local.get outPtr
+  i32.const 4 
+  i32.add
+  ;; src = left pointer + length size
+  local.get leftPtr
+  i32.const 4 
+  i32.add
+
+  local.get leftLength
+  i32.const 
+  i32.mul
+  memory_copy 0 0
+
+  ;; copy right
+  ;; dst = out pointer + length size + left length * sizeof valtype
+  local.get outPtr
+  i32.const 4 
+  i32.add
+  local.get leftLength
+  i32.const 2
+  i32.mul
+  i32.add
+  ;; src = right pointer + length size
+  local.get rightPtr
+  i32.const 4 
+  i32.add
+  ;; size = right length * sizeof valtype
+  local.get rightLength
+  i32.const 2
+  i32.mul
+  memory_copy 0 0
+  `;
+
+  return out;
+};
+
+export const __ByteString_prototype_concat = (_this: bytestring, arg: bytestring) => {
+  // 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?
+  let out: bytestring = Porffor.bs``;
+  Porffor.wasm`
+  local leftLength i32
+  local leftPtr i32
+  local rightLength i32
+  local rightPtr i32
+  local outPtr i32
+
+  local.get ${_this}
+  i32.to_u
+  local.set leftPtr
+
+  local.get ${arg}
+  i32.to_u
+  local.set rightPtr
+
+  local.get ${out}
+  i32.to_u
+  local.set outPtr
+
+  ;; calculate length
+  local.get outPtr
+
+  local.get leftPtr
+  i32.load 0 0 
+  local.tee leftLength
+  local.get rightPtr
+
+  i32.load 0 0 
+  local.tee rightLength
+  i32.add
+  ;; store out length
+  i32.store 0 0
+  ;; copy left
+  ;; dst = out pointer + length size
+  local.get outPtr
+  i32.const 4 
+  i32.add
+  ;; src = left pointer + length size
+  local.get leftPtr
+  i32.const 4 
+  i32.add
+
+  local.get leftLength
+  ;; i32.const 1
+  ;; i32.mul
+  memory_copy 0 0
+
+  ;; copy right
+  ;; dst = out pointer + length size + left length * sizeof valtype
+  local.get outPtr
+  i32.const 4 
+  i32.add
+  local.get leftLength
+  ;; i32.const 1
+  ;; i32.mul
+  i32.add
+  ;; src = right pointer + length size
+  local.get rightPtr
+  i32.const 4 
+  i32.add
+  ;; size = right length * sizeof valtype
+  local.get rightLength
+  ;; i32.const 1
+  ;; i32.mul
+  memory_copy 0 0
+  `;
+  return out;
+};
+