add lazy array getters, string pool and hashmap tests

Author: phpnode

.babelrc

@@ -12,7 +12,11 @@
         }
       }
     }],
-    ["trace", {strip: true}]
+    ["trace", {strip: true}],
+    ["transform-async-to-module-method", {
+      "module": "bluebird",
+      "method": "coroutine"
+    }]
   ],
   "passPerPreset": true
 }

package.json

@@ -17,6 +17,7 @@
     "babel-core": "^6.5.1",
     "babel-plugin-contracts": "^1.1.1",
     "babel-plugin-trace": "^1.0.0",
+    "babel-plugin-transform-async-to-module-method": "^6.5.2",
     "babel-plugin-typecheck": "^3.6.1",
     "babel-polyfill": "^6.5.0",
     "babel-preset-es2015": "^6.5.0",

src/builtins/index.js

@@ -15,6 +15,7 @@ import {make as makeFloat64} from "./float64";
 //import {make as makeNumber} from "./number";
 
 import {make as makeBoolean} from "./boolean";
+import {make as makeString} from "./string";
 
 
 export function registerBuiltins (realm: Realm): TypeRegistry {
@@ -31,6 +32,7 @@ export function registerBuiltins (realm: Realm): TypeRegistry {
   registry.add(makeFloat64(realm, 8));
   //registry.add(makeNumber(realm, 9));
   registry.add(makeBoolean(realm, 10));
+  registry.add(makeString(realm, 11));
 
   return registry;
 }

src/builtins/string/index.js

@@ -0,0 +1,11 @@
+/* @flow */
+
+import type Backing from "backing";
+import type {Realm} from "../..";
+
+import {$StringPool} from "../../symbols";
+
+export function make (realm: Realm, typeId: uint32): Type<string> {
+  const pool = realm[$StringPool];
+  return pool.makeStringType('String', typeId);
+}

src/builtins/string/test.js

@@ -0,0 +1,91 @@
+describeRealm('Builtin: String', function (options) {
+  let realm;
+  let backing;
+  let T;
+  let address;
+
+  before(() => {
+    realm = options.realm;
+    backing = realm.backing;
+    T = realm.T;
+    address = backing.alloc(T.String.byteLength);
+  });
+
+  after(() => {
+    backing.free(address);
+  });
+
+  describe('Cast', function () {
+    it('should return an empty value for empty input', function () {
+      T.String().should.equal('');
+    });
+
+  });
+
+  it('should not create a new instance', function () {
+    (() => new T.String('wat')).should.throw(TypeError);
+  });
+
+  describe('.emptyValue()', function () {
+    it('should return an empty value', function () {
+      T.String.emptyValue().should.equal('');
+    });
+  });
+
+  describe('.randomValue()', function () {
+    it('should return a random value', function () {
+      const value = T.String.randomValue();
+      (typeof value).should.equal('string');
+    });
+
+    it('should accept a random value', function () {
+      T.String.accepts(T.String.randomValue()).should.equal(true);
+    });
+  });
+
+  describe('.initialize(), .store(), .load() and .clear()', function () {
+    let input;
+    before(() => {
+      input = T.String.randomValue();
+    });
+
+    it('should initialize an address', function () {
+      T.String.initialize(backing, address);
+    });
+
+    it('should load an empty value from a just-initialized address', function () {
+      T.String.load(backing, address).should.equal(T.String.emptyValue());
+    });
+
+    it('should store a value at an address', function () {
+      T.String.store(backing, address, input);
+    });
+
+    it('should load a value from an address', function () {
+      T.String.load(backing, address).should.equal(input);
+    });
+
+    it('should clear a value from an address', function () {
+      T.String.clear(backing, address);
+    });
+
+    it('should load an empty value from a cleaned up address', function () {
+      (T.String.load(backing, address) === T.String.emptyValue()).should.equal(true);
+    });
+  });
+
+  describe('.hashValue()', function () {
+    it('should hash a value', function () {
+      T.String.hashValue(123).should.be.above(-1);
+    });
+
+    it('should hash a random value', function () {
+      T.String.hashValue(T.String.randomValue()).should.be.above(-1);
+    });
+
+    it('should hash an empty value', function () {
+      T.String.hashValue(T.String.emptyValue()).should.be.above(-1);
+    });
+
+  });
+});

src/index.js

@@ -1,17 +1,28 @@
 /* @flow */
 import {make as makeTypeClass} from "./type-class";
 import {make as makePrimitiveType} from "./type-class/primitive-type";
+import {make as makeStringType} from "./type-class/string-type";
 import {make as makeReferenceType} from "./type-class/reference-type";
 import {make as makeStructType} from "./type-class/struct-type";
 import {make as makeArrayType} from "./type-class/array-type";
 import {make as makeHashMapType} from "./type-class/hash-map-type";
 
+import {make as makeStringPool} from "./string-pool";
+
 
 import {registerBuiltins} from "./builtins";
+import {$StringPool} from "./symbols";
+
 
 import type Backing from "backing";
 import type TypeRegistry from "type-registry";
 
+const HEADER_ADDRESS = 336; // First usable block in the backing store.
+const VERSION_ADDRESS = HEADER_ADDRESS;
+const STRING_POOL_POINTER_ADDRESS = VERSION_ADDRESS + 8;
+const HEADER_CHECKSUM_ADDRESS = STRING_POOL_POINTER_ADDRESS + 16;
+const HEADER_SIZE = (HEADER_CHECKSUM_ADDRESS + 8) - HEADER_ADDRESS;
+const FIRST_ADDRESS = HEADER_ADDRESS + HEADER_SIZE;
 
 export class Realm {
 
@@ -44,9 +55,9 @@ export class Realm {
     this.ReferenceType = makeReferenceType(this);
     this.StructType = makeStructType(this);
     this.ArrayType = makeArrayType(this);
+    this.StringType = makeStringType(this);
     this.HashMapType = makeHashMapType(this);
     this.isInitialized = false;
-    registerBuiltins(this);
   }
 
   /**
@@ -56,11 +67,43 @@ export class Realm {
     if (this.isInitialized) {
       throw new Error(`Realm cannot be initialized twice.`);
     }
+    trace: `Initializing the realm.`
     if (!this.backing.isInitialized) {
       await this.backing.init();
     }
+    verifyHeader(this);
+    this[$StringPool] = makeStringPool(this, STRING_POOL_POINTER_ADDRESS);
+    registerBuiltins(this);
     this.isInitialized = true;
     Object.freeze(this);
     return this;
   }
-}
+
+  /**
+   * Ensure that the given value is aligned to the given number of bytes.
+   */
+  alignTo (value: number, numberOfBytes: number): number {
+    const rem = value % numberOfBytes;
+    return rem === 0 ? value : value + (numberOfBytes - rem);
+  }
+}
+
+
+function verifyHeader (realm: Realm) {
+  const backing: Backing = realm.backing;
+  if (
+    backing.getUint32(HEADER_ADDRESS) !== HEADER_ADDRESS ||
+    backing.getUint32(HEADER_CHECKSUM_ADDRESS) !== HEADER_CHECKSUM_ADDRESS
+  ) {
+    const address = backing.calloc(HEADER_SIZE);
+
+    /* istanbul ignore if  */
+    if (address !== HEADER_ADDRESS) {
+      throw new TypeError(`Allocator returned an invalid backing header address, got ${address} expected ${HEADER_ADDRESS}.`);
+    }
+    backing.setUint32(HEADER_ADDRESS, HEADER_ADDRESS);
+    backing.setUint32(HEADER_CHECKSUM_ADDRESS, HEADER_CHECKSUM_ADDRESS);
+    backing.setFloat64(STRING_POOL_POINTER_ADDRESS, 0);
+  }
+}
+