lib: basic array and buffer modules

candor.io.gyp

@@ -1,7 +1,9 @@
 {
   'variables': {
     'library_files': [
+      'lib/array.can',
       'lib/events.can',
+      'lib/buffer.can',
       'lib/fs.can',
       'lib/tcp.can',
       'lib/can.can',

lib/array.can

@@ -0,0 +1,42 @@
+exports = {}
+
+exports.push = (arr, items...) {
+  while (i < sizeof items) {
+    arr[sizeof arr] = items[i++]
+  }
+
+  return sizeof arr
+}
+
+exports.pop = (arr) {
+  index = sizeof arr - 1
+  item = arr[index]
+  delete arr[index]
+
+  return item
+}
+
+exports.slice = (arr, begin, end) {
+  res = []
+  len = sizeof arr
+
+  if (len < begin) return res
+
+  if (!end) end = len
+  i = 0
+  while (begin < end) {
+    res[i++] = arr[begin++]
+  }
+
+  return res
+}
+
+exports.forEach = (arr, cb) {
+  len = sizeof arr
+  while (i < len) {
+    cb(arr[i], i, arr)
+    i++
+  }
+}
+
+return exports

lib/buffer.can

@@ -0,0 +1 @@
+return global._bindings.buffer

lib/events.can

@@ -1,5 +1,6 @@
 // EventEmitter
 exports = {}
+array = global._natives.array
 
 EventEmitter = exports.EventEmitter = {}
 
@@ -9,18 +10,16 @@ EventEmitter.init = (self) {
 
 EventEmitter.on = (self, event, listener) {
   if (!self._listeners[event]) self._listeners[event] = []
-  listeners = self._listeners[event]
 
-  listeners[sizeof listeners] = listener
+  array.push(self._listeners[event], listener)
 }
 
 EventEmitter.emit = (self, event, args...) {
-  i = 0
   listeners = self._listeners[event]
-  while (i < sizeof listeners) {
-    listeners[i](args...)
-    i++
-  }
+
+  array.forEach(listeners, (listener) {
+    listener(args...)
+  })
 
   return sizeof listeners
 }

src/bindings/buffer.cc

@@ -119,12 +119,19 @@ Value* Buffer::Concat(uint32_t argc, Value** argv) {
 }
 
 
+Value* Buffer::HasInstance(uint32_t argc, Value** value) {
+  if (argc < 1) return Nil::New();
+  return Boolean::New(HasInstance(value[0]));
+}
+
+
 void Buffer::Init(Object* target) {
   target->Set("new", Function::New(Buffer::New));
   target->Set("length", Function::New(Buffer::Length));
   target->Set("stringify", Function::New(Buffer::Stringify));
   target->Set("slice", Function::New(Buffer::Slice));
   target->Set("concat", Function::New(Buffer::Concat));
+  target->Set("hasInstance", Function::New(Buffer::HasInstance));
 }
 
 } // namespace can

src/bindings/buffer.h

@@ -45,6 +45,7 @@ class Buffer : public candor::CWrapper {
   static candor::Value* Stringify(uint32_t argc, candor::Value** argv);
   static candor::Value* Slice(uint32_t argc, candor::Value** argv);
   static candor::Value* Concat(uint32_t argc, candor::Value** argv);
+  static candor::Value* HasInstance(uint32_t argc, candor::Value** value);
 
   bool allocated_;
   char* data_;