spade-packager 0.1.0

data/packages/ivory/lib/main.js

@@ -0,0 +1,13 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+/*globals process Buffer $fs $path $util */
+
+process = require('./ruby/process');
+Buffer  = require('./buffer').Buffer ;
+
+$fs   = require('./fs');
+$path = require('./path');
+$util = require('./util');

data/packages/ivory/lib/path.js

@@ -0,0 +1,158 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+var process = require('./ruby/process');
+
+function validPathPart(p, keepBlanks) {
+  return typeof p === 'string' && (p || keepBlanks);
+}
+
+exports.cwd = function() { return process.cwd(); };
+
+exports.join = function() {
+  var args = Array.prototype.slice.call(arguments);
+  // edge case flag to switch into url-resolve-mode
+  var keepBlanks = false;
+  if (args[args.length - 1] === true) {
+    keepBlanks = args.pop();
+  }
+  // return exports.split(args.join("/"), keepBlanks).join("/");
+  var joined = exports.normalizeArray(args, keepBlanks).join('/');
+  return joined;
+};
+
+
+exports.split = function(path, keepBlanks) {
+  // split based on /, but only if that / is not at the start or end.
+  return exports.normalizeArray(path.split(/^|\/(?!$)/), keepBlanks);
+};
+
+
+function cleanArray(parts, keepBlanks) {
+  var i = 0;
+  var l = parts.length - 1;
+  var stripped = false;
+
+  // strip leading empty args
+  while (i < l && !validPathPart(parts[i], keepBlanks)) {
+    stripped = true;
+    i++;
+  }
+
+  // strip tailing empty args
+  while (l >= i && !validPathPart(parts[l], keepBlanks)) {
+    stripped = true;
+    l--;
+  }
+
+  if (stripped) {
+    // if l chopped all the way back to i, then this is empty
+    parts = Array.prototype.slice.call(parts, i, l + 1);
+  }
+
+  return parts.filter(function(p) { return validPathPart(p, keepBlanks); })
+              .join('/')
+              .split(/^|\/(?!$)/);
+}
+
+
+exports.normalizeArray = function(original, keepBlanks) {
+  var parts = cleanArray(original, keepBlanks);
+  if (!parts.length || (parts.length === 1 && !parts[0])) return ['.'];
+
+  // now we're fully ready to rock.
+  // leading/trailing invalids have been stripped off.
+  // if it comes in starting with a slash, or ending with a slash,
+  var leadingSlash = (parts[0].charAt(0) === '/');
+
+  if (leadingSlash) parts[0] = parts[0].substr(1);
+  var last = parts.slice(-1)[0];
+  var tailingSlash = (last.substr(-1) === '/');
+  if (tailingSlash) parts[parts.length - 1] = last.slice(0, -1);
+  var directories = [];
+  var prev;
+  for (var i = 0, l = parts.length - 1; i <= l; i++) {
+    var directory = parts[i];
+
+    // if it's blank, and we're not keeping blanks, then skip it.
+    if (directory === '' && !keepBlanks) continue;
+
+    // if it's a dot, then skip it
+    if (directory === '.' && (directories.length ||
+        (i === 0 && !(tailingSlash && i === l)) ||
+        (i === 0 && leadingSlash))) continue;
+
+    // if we're dealing with an absolute path, then discard ..s that go
+    // above that the base.
+    if (leadingSlash && directories.length === 0 && directory === '..') {
+      continue;
+    }
+    // trying to go up a dir
+    if (directory === '..' && directories.length && prev !== '..' &&
+        prev !== undefined) {
+      directories.pop();
+      prev = directories.slice(-1)[0];
+    } else {
+      directories.push(directory);
+      prev = directory;
+    }
+  }
+  if (!directories.length) {
+    directories = [leadingSlash || tailingSlash ? '' : '.'];
+  }
+  
+  last = directories.slice(-1)[0];
+  if (tailingSlash && last.substr(-1) !== '/') {
+    directories[directories.length - 1] += '/';
+  }
+  if (leadingSlash && directories[0].charAt(0) !== '/') {
+    if (directories[0] === '.') directories[0] = '';
+    directories[0] = '/' + directories[0];
+  }
+  return directories;
+};
+
+
+exports.normalize = function(path, keepBlanks) {
+  return exports.join(path, keepBlanks || false);
+};
+
+
+exports.dirname = function(path) {
+  if (path.length > 1 && '/' === path[path.length - 1]) {
+    path = path.replace(/\/+$/, '');
+  }
+  var lastSlash = path.lastIndexOf('/');
+  switch (lastSlash) {
+    case -1:
+      return '.';
+    case 0:
+      return '/';
+    default:
+      return path.substring(0, lastSlash);
+  }
+};
+
+
+exports.basename = function(path, ext) {
+  var f = path.substr(path.lastIndexOf('/') + 1);
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+exports.extname = function(path) {
+  var dot = path.lastIndexOf('.'),
+      slash = path.lastIndexOf('/');
+  // The last dot must be in the last path component, and it (the last dot) must
+  // not start the last path component (i.e. be a dot that signifies a hidden
+  // file in UNIX).
+  return dot <= slash + 1 ? '' : path.substring(dot);
+};
+
+exports.exists = require('./fs').exists;

data/packages/ivory/lib/ruby/buffer.rb

@@ -0,0 +1,145 @@
+# ==========================================================================
+# Project:   Ivory
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'v8'
+
+module Ivory
+  class BufferModule < Spade::Runtime::Exports
+    
+    class SlowBuffer
+      attr_reader :data
+      protected :data
+
+      def initialize(opt, *args)
+        case opt
+        when Numeric
+          @data = Array.new(opt.to_i, 0)
+        when V8::Array
+          @data = opt.to_a
+        when String
+          encoding = *args
+          @data = case encoding
+          when 'ascii'                        then opt.unpack('U*')
+          when 'utf8','utf-8','binary',nil    then opt.unpack('C*')
+          when 'base64'
+            (opt + "=" * (4 - opt.length % 4)).unpack('m').first.unpack('C*')
+          else
+            raise "Unknown encoding"
+          end
+        when self.class
+          start, stop = *args
+          @data = opt.send(:data)[start..stop-1]
+        else
+          raise "Bad argument"
+        end
+      end
+      
+      def length
+        @data.length
+      end
+
+      def [](index)
+        index.kind_of?(Numeric) ? @data[index] : yield
+      end
+
+      def []=(index, value)
+        index.kind_of?(Numeric) ? @data[index] = value : yield
+      end
+
+      def slice(start, stop)
+        SlowBuffer.new(self, start, stop)
+      end
+
+      def unpack(format, index)
+        raise ArgumentError, "Argument must be a string" unless format.kind_of?(String)
+        @data[index..-1].pack('C*').unpack(format).tap do |array|
+          raise ArgumentError, "Out of bounds" if array.last.nil?
+        end
+      end
+
+      def utf8Slice(start, stop)
+        @data[start..stop-1].pack('C*')
+      end
+
+      def asciiSlice(start, stop)
+        raise ArgumentError, "Bad argument." unless start.kind_of?(Numeric) && stop.kind_of?(Numeric)
+        raise ArgumentError, "Bad argument." if start < 0 || stop < 0
+        raise ArgumentError, "Must have start <= end" unless start <= stop
+        raise ArgumentError, "end cannot be longer than parent" if stop > @data.length
+
+        @data[start..stop-1].pack('C*').tap do |slice|
+          # puts "Buffer(#{self.length}).asciiSlice(#{start}, #{stop}) -> #{slice}"
+        end
+      end
+
+      def binarySlice(start, stop)
+        @data[start..stop-1]
+      end
+
+      def base64Slice(start, stop)
+        [@data[start..stop-1].pack('C*')].pack('m').gsub(/\n/,'')
+      end
+
+      def utf8Write(string, offset)
+        written = 0
+        string.scan(/./mu) do |codepoint|
+          bytes = codepoint.unpack('C*')
+          if bytes.length <= self.length - offset - written
+            @data[offset + written, bytes.length] = bytes
+            written += bytes.length
+          end
+        end
+        return written
+      end
+
+      def asciiWrite(string, offset)
+        raise "Argument must be a string" unless string.kind_of?(String)
+        raise "Offset is out of bounds" if string.length > 0 && offset >= self.length
+        to_write = [string.length, self.length - offset].min
+        @data[offset, to_write] = string.unpack('C*')
+        to_write
+      end
+
+      def binaryWrite(string, offset)
+        raise "Argument must be a string" unless string.kind_of?(String)
+        0
+      end
+
+      def base64Write(string, offset)
+        return 0 if offset == 0 && self.length == 0
+        raise "Offset is out of bounds" if offset >= self.length
+        bytes = string.unpack('m').first.unpack('C*')
+        raise "Buffer too small" if bytes.length > (self.length - offset)
+        @data[offset, bytes.length] = bytes
+        bytes.length
+      end
+
+      def copy(target, position, start, finish = self.length)
+        raise "First arg should be a Buffer" unless target.kind_of?(self.class)
+        raise "sourceEnd < sourceStart" if finish < start
+        return 0 if start == finish
+
+        raise "targetStart out of bounds" if position < 0 || position >= target.length
+        raise "sourceStart out of bounds" if start < 0 || start >= self.length
+        raise "sourceEnd out of bounds" if finish < 0 || finish > self.length
+
+        to_copy = [finish - start, target.length - position].min.tap do |bytes|
+          for i in 0..bytes - 1
+            target[i] = self[i]
+          end
+        end
+      end
+      
+      def to_s
+        @data.pack("C*")
+      end
+      
+    end
+  end
+end
+
+Spade.exports = Ivory::BufferModule
+

data/packages/ivory/lib/ruby/constants.rb

@@ -0,0 +1,585 @@
+# ==========================================================================
+# Project:   Ivory
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+module Ivory
+  class Constants < Spade::Runtime::Exports
+    
+    def self.defc(name, value)
+      self.send(:define_method, name) do ||
+        value
+      end
+    end
+
+    #   NODE_DEFINE_CONSTANT(target, EV_MINPRI);
+    #   NODE_DEFINE_CONSTANT(target, EV_MAXPRI);
+    # 
+    #   // file access modes
+    #   NODE_DEFINE_CONSTANT(target, O_RDONLY);
+    #   NODE_DEFINE_CONSTANT(target, O_WRONLY);
+    #   NODE_DEFINE_CONSTANT(target, O_RDWR);
+
+    defc :O_RDONLY, File::RDONLY
+    defc :O_WRONLY, File::WRONLY
+    defc :O_RDWR, File::RDWR
+
+    # 
+    #   NODE_DEFINE_CONSTANT(target, S_IFMT);
+    #   NODE_DEFINE_CONSTANT(target, S_IFREG);
+    #   NODE_DEFINE_CONSTANT(target, S_IFDIR);
+    #   NODE_DEFINE_CONSTANT(target, S_IFCHR);
+    #   NODE_DEFINE_CONSTANT(target, S_IFBLK);
+    #   NODE_DEFINE_CONSTANT(target, S_IFIFO);
+    #   NODE_DEFINE_CONSTANT(target, S_IFLNK);
+    #   NODE_DEFINE_CONSTANT(target, S_IFSOCK);
+    # 
+    # #ifdef O_CREAT
+    #   NODE_DEFINE_CONSTANT(target, O_CREAT);
+    # #endif
+    defc :O_CREAT, File::CREAT
+    # 
+    # #ifdef O_EXCL
+    #   NODE_DEFINE_CONSTANT(target, O_EXCL);
+    # #endif
+    defc :OEXCL, File::EXCL
+    # 
+    # #ifdef O_NOCTTY
+    #   NODE_DEFINE_CONSTANT(target, O_NOCTTY);
+    # #endif
+    defc :OEXCL, File::EXCL
+    # 
+    # #ifdef O_TRUNC
+    #   NODE_DEFINE_CONSTANT(target, O_TRUNC);
+    # #endif
+    defc :O_TRUNC, File::TRUNC
+    # 
+    # #ifdef O_APPEND
+    #   NODE_DEFINE_CONSTANT(target, O_APPEND);
+    # #endif
+    # 
+    # #ifdef O_DIRECTORY
+    #   NODE_DEFINE_CONSTANT(target, O_DIRECTORY);
+    # #endif
+    # 
+    # #ifdef O_EXCL
+    #   NODE_DEFINE_CONSTANT(target, O_EXCL);
+    # #endif
+    # 
+    # #ifdef O_NOFOLLOW
+    #   NODE_DEFINE_CONSTANT(target, O_NOFOLLOW);
+    # #endif
+    # 
+    # #ifdef O_SYNC
+    #   NODE_DEFINE_CONSTANT(target, O_SYNC);
+    # #endif
+    # 
+    # #ifdef S_IRWXU
+    #   NODE_DEFINE_CONSTANT(target, S_IRWXU);
+    # #endif
+    # 
+    # 
+    # #ifdef S_IRUSR
+    #   NODE_DEFINE_CONSTANT(target, S_IRUSR);
+    # #endif
+    # 
+    # #ifdef S_IWUSR
+    #   NODE_DEFINE_CONSTANT(target, S_IWUSR);
+    # #endif
+    # 
+    # #ifdef S_IXUSR
+    #   NODE_DEFINE_CONSTANT(target, S_IXUSR);
+    # #endif
+    # 
+    # 
+    # #ifdef S_IRWXG
+    #   NODE_DEFINE_CONSTANT(target, S_IRWXG);
+    # #endif
+    # 
+    # 
+    # #ifdef S_IRGRP
+    #   NODE_DEFINE_CONSTANT(target, S_IRGRP);
+    # #endif
+    # 
+    # #ifdef S_IWGRP
+    #   NODE_DEFINE_CONSTANT(target, S_IWGRP);
+    # #endif
+    # 
+    # #ifdef S_IXGRP
+    #   NODE_DEFINE_CONSTANT(target, S_IXGRP);
+    # #endif
+    # 
+    # 
+    # #ifdef S_IRWXO
+    #   NODE_DEFINE_CONSTANT(target, S_IRWXO);
+    # #endif
+    # 
+    # 
+    # #ifdef S_IROTH
+    #   NODE_DEFINE_CONSTANT(target, S_IROTH);
+    # #endif
+    # 
+    # #ifdef S_IWOTH
+    #   NODE_DEFINE_CONSTANT(target, S_IWOTH);
+    # #endif
+    # 
+    # #ifdef S_IXOTH
+    #   NODE_DEFINE_CONSTANT(target, S_IXOTH);
+    # #endif
+    # 
+    # #ifdef E2BIG
+    #   NODE_DEFINE_CONSTANT(target, E2BIG);
+    # #endif
+    # 
+    # #ifdef EACCES
+    #   NODE_DEFINE_CONSTANT(target, EACCES);
+    # #endif
+    # 
+    # #ifdef EADDRINUSE
+    #   NODE_DEFINE_CONSTANT(target, EADDRINUSE);
+    # #endif
+    # 
+    # #ifdef EADDRNOTAVAIL
+    #   NODE_DEFINE_CONSTANT(target, EADDRNOTAVAIL);
+    # #endif
+    # 
+    # #ifdef EAFNOSUPPORT
+    #   NODE_DEFINE_CONSTANT(target, EAFNOSUPPORT);
+    # #endif
+    # 
+    # #ifdef EAGAIN
+    #   NODE_DEFINE_CONSTANT(target, EAGAIN);
+    # #endif
+    # 
+    # #ifdef EALREADY
+    #   NODE_DEFINE_CONSTANT(target, EALREADY);
+    # #endif
+    # 
+    # #ifdef EBADF
+    #   NODE_DEFINE_CONSTANT(target, EBADF);
+    # #endif
+    # 
+    # #ifdef EBADMSG
+    #   NODE_DEFINE_CONSTANT(target, EBADMSG);
+    # #endif
+    # 
+    # #ifdef EBUSY
+    #   NODE_DEFINE_CONSTANT(target, EBUSY);
+    # #endif
+    # 
+    # #ifdef ECANCELED
+    #   NODE_DEFINE_CONSTANT(target, ECANCELED);
+    # #endif
+    # 
+    # #ifdef ECHILD
+    #   NODE_DEFINE_CONSTANT(target, ECHILD);
+    # #endif
+    # 
+    # #ifdef ECONNABORTED
+    #   NODE_DEFINE_CONSTANT(target, ECONNABORTED);
+    # #endif
+    # 
+    # #ifdef ECONNREFUSED
+    #   NODE_DEFINE_CONSTANT(target, ECONNREFUSED);
+    # #endif
+    # 
+    # #ifdef ECONNRESET
+    #   NODE_DEFINE_CONSTANT(target, ECONNRESET);
+    # #endif
+    # 
+    # #ifdef EDEADLK
+    #   NODE_DEFINE_CONSTANT(target, EDEADLK);
+    # #endif
+    # 
+    # #ifdef EDESTADDRREQ
+    #   NODE_DEFINE_CONSTANT(target, EDESTADDRREQ);
+    # #endif
+    # 
+    # #ifdef EDOM
+    #   NODE_DEFINE_CONSTANT(target, EDOM);
+    # #endif
+    # 
+    # #ifdef EDQUOT
+    #   NODE_DEFINE_CONSTANT(target, EDQUOT);
+    # #endif
+    # 
+    # #ifdef EEXIST
+    #   NODE_DEFINE_CONSTANT(target, EEXIST);
+    # #endif
+    # 
+    # #ifdef EFAULT
+    #   NODE_DEFINE_CONSTANT(target, EFAULT);
+    # #endif
+    # 
+    # #ifdef EFBIG
+    #   NODE_DEFINE_CONSTANT(target, EFBIG);
+    # #endif
+    # 
+    # #ifdef EHOSTUNREACH
+    #   NODE_DEFINE_CONSTANT(target, EHOSTUNREACH);
+    # #endif
+    # 
+    # #ifdef EIDRM
+    #   NODE_DEFINE_CONSTANT(target, EIDRM);
+    # #endif
+    # 
+    # #ifdef EILSEQ
+    #   NODE_DEFINE_CONSTANT(target, EILSEQ);
+    # #endif
+    # 
+    # #ifdef EINPROGRESS
+    #   NODE_DEFINE_CONSTANT(target, EINPROGRESS);
+    # #endif
+    # 
+    # #ifdef EINTR
+    #   NODE_DEFINE_CONSTANT(target, EINTR);
+    # #endif
+    # 
+    # #ifdef EINVAL
+    #   NODE_DEFINE_CONSTANT(target, EINVAL);
+    # #endif
+    # 
+    # #ifdef EIO
+    #   NODE_DEFINE_CONSTANT(target, EIO);
+    # #endif
+    # 
+    # #ifdef EISCONN
+    #   NODE_DEFINE_CONSTANT(target, EISCONN);
+    # #endif
+    # 
+    # #ifdef EISDIR
+    #   NODE_DEFINE_CONSTANT(target, EISDIR);
+    # #endif
+    # 
+    # #ifdef ELOOP
+    #   NODE_DEFINE_CONSTANT(target, ELOOP);
+    # #endif
+    # 
+    # #ifdef EMFILE
+    #   NODE_DEFINE_CONSTANT(target, EMFILE);
+    # #endif
+    # 
+    # #ifdef EMLINK
+    #   NODE_DEFINE_CONSTANT(target, EMLINK);
+    # #endif
+    # 
+    # #ifdef EMSGSIZE
+    #   NODE_DEFINE_CONSTANT(target, EMSGSIZE);
+    # #endif
+    # 
+    # #ifdef EMULTIHOP
+    #   NODE_DEFINE_CONSTANT(target, EMULTIHOP);
+    # #endif
+    # 
+    # #ifdef ENAMETOOLONG
+    #   NODE_DEFINE_CONSTANT(target, ENAMETOOLONG);
+    # #endif
+    # 
+    # #ifdef ENETDOWN
+    #   NODE_DEFINE_CONSTANT(target, ENETDOWN);
+    # #endif
+    # 
+    # #ifdef ENETRESET
+    #   NODE_DEFINE_CONSTANT(target, ENETRESET);
+    # #endif
+    # 
+    # #ifdef ENETUNREACH
+    #   NODE_DEFINE_CONSTANT(target, ENETUNREACH);
+    # #endif
+    # 
+    # #ifdef ENFILE
+    #   NODE_DEFINE_CONSTANT(target, ENFILE);
+    # #endif
+    # 
+    # #ifdef ENOBUFS
+    #   NODE_DEFINE_CONSTANT(target, ENOBUFS);
+    # #endif
+    # 
+    # #ifdef ENODATA
+    #   NODE_DEFINE_CONSTANT(target, ENODATA);
+    # #endif
+    # 
+    # #ifdef ENODEV
+    #   NODE_DEFINE_CONSTANT(target, ENODEV);
+    # #endif
+    # 
+    # #ifdef ENOENT
+    #   NODE_DEFINE_CONSTANT(target, ENOENT);
+    # #endif
+    # 
+    # #ifdef ENOEXEC
+    #   NODE_DEFINE_CONSTANT(target, ENOEXEC);
+    # #endif
+    # 
+    # #ifdef ENOLCK
+    #   NODE_DEFINE_CONSTANT(target, ENOLCK);
+    # #endif
+    # 
+    # #ifdef ENOLINK
+    #   NODE_DEFINE_CONSTANT(target, ENOLINK);
+    # #endif
+    # 
+    # #ifdef ENOMEM
+    #   NODE_DEFINE_CONSTANT(target, ENOMEM);
+    # #endif
+    # 
+    # #ifdef ENOMSG
+    #   NODE_DEFINE_CONSTANT(target, ENOMSG);
+    # #endif
+    # 
+    # #ifdef ENOPROTOOPT
+    #   NODE_DEFINE_CONSTANT(target, ENOPROTOOPT);
+    # #endif
+    # 
+    # #ifdef ENOSPC
+    #   NODE_DEFINE_CONSTANT(target, ENOSPC);
+    # #endif
+    # 
+    # #ifdef ENOSR
+    #   NODE_DEFINE_CONSTANT(target, ENOSR);
+    # #endif
+    # 
+    # #ifdef ENOSTR
+    #   NODE_DEFINE_CONSTANT(target, ENOSTR);
+    # #endif
+    # 
+    # #ifdef ENOSYS
+    #   NODE_DEFINE_CONSTANT(target, ENOSYS);
+    # #endif
+    # 
+    # #ifdef ENOTCONN
+    #   NODE_DEFINE_CONSTANT(target, ENOTCONN);
+    # #endif
+    # 
+    # #ifdef ENOTDIR
+    #   NODE_DEFINE_CONSTANT(target, ENOTDIR);
+    # #endif
+    # 
+    # #ifdef ENOTEMPTY
+    #   NODE_DEFINE_CONSTANT(target, ENOTEMPTY);
+    # #endif
+    # 
+    # #ifdef ENOTSOCK
+    #   NODE_DEFINE_CONSTANT(target, ENOTSOCK);
+    # #endif
+    # 
+    # #ifdef ENOTSUP
+    #   NODE_DEFINE_CONSTANT(target, ENOTSUP);
+    # #endif
+    # 
+    # #ifdef ENOTTY
+    #   NODE_DEFINE_CONSTANT(target, ENOTTY);
+    # #endif
+    # 
+    # #ifdef ENXIO
+    #   NODE_DEFINE_CONSTANT(target, ENXIO);
+    # #endif
+    # 
+    # #ifdef EOPNOTSUPP
+    #   NODE_DEFINE_CONSTANT(target, EOPNOTSUPP);
+    # #endif
+    # 
+    # #ifdef EOVERFLOW
+    #   NODE_DEFINE_CONSTANT(target, EOVERFLOW);
+    # #endif
+    # 
+    # #ifdef EPERM
+    #   NODE_DEFINE_CONSTANT(target, EPERM);
+    # #endif
+    # 
+    # #ifdef EPIPE
+    #   NODE_DEFINE_CONSTANT(target, EPIPE);
+    # #endif
+    # 
+    # #ifdef EPROTO
+    #   NODE_DEFINE_CONSTANT(target, EPROTO);
+    # #endif
+    # 
+    # #ifdef EPROTONOSUPPORT
+    #   NODE_DEFINE_CONSTANT(target, EPROTONOSUPPORT);
+    # #endif
+    # 
+    # #ifdef EPROTOTYPE
+    #   NODE_DEFINE_CONSTANT(target, EPROTOTYPE);
+    # #endif
+    # 
+    # #ifdef ERANGE
+    #   NODE_DEFINE_CONSTANT(target, ERANGE);
+    # #endif
+    # 
+    # #ifdef EROFS
+    #   NODE_DEFINE_CONSTANT(target, EROFS);
+    # #endif
+    # 
+    # #ifdef ESPIPE
+    #   NODE_DEFINE_CONSTANT(target, ESPIPE);
+    # #endif
+    # 
+    # #ifdef ESRCH
+    #   NODE_DEFINE_CONSTANT(target, ESRCH);
+    # #endif
+    # 
+    # #ifdef ESTALE
+    #   NODE_DEFINE_CONSTANT(target, ESTALE);
+    # #endif
+    # 
+    # #ifdef ETIME
+    #   NODE_DEFINE_CONSTANT(target, ETIME);
+    # #endif
+    # 
+    # #ifdef ETIMEDOUT
+    #   NODE_DEFINE_CONSTANT(target, ETIMEDOUT);
+    # #endif
+    # 
+    # #ifdef ETXTBSY
+    #   NODE_DEFINE_CONSTANT(target, ETXTBSY);
+    # #endif
+    # 
+    # #ifdef EWOULDBLOCK
+    #   NODE_DEFINE_CONSTANT(target, EWOULDBLOCK);
+    # #endif
+    # 
+    # #ifdef EXDEV
+    #   NODE_DEFINE_CONSTANT(target, EXDEV);
+    # #endif
+    # 
+    # #ifdef SIGHUP
+    #   NODE_DEFINE_CONSTANT(target, SIGHUP);
+    # #endif
+    # 
+    # #ifdef SIGINT
+    #   NODE_DEFINE_CONSTANT(target, SIGINT);
+    # #endif
+    # 
+    # #ifdef SIGQUIT
+    #   NODE_DEFINE_CONSTANT(target, SIGQUIT);
+    # #endif
+    # 
+    # #ifdef SIGILL
+    #   NODE_DEFINE_CONSTANT(target, SIGILL);
+    # #endif
+    # 
+    # #ifdef SIGTRAP
+    #   NODE_DEFINE_CONSTANT(target, SIGTRAP);
+    # #endif
+    # 
+    # #ifdef SIGABRT
+    #   NODE_DEFINE_CONSTANT(target, SIGABRT);
+    # #endif
+    # 
+    # #ifdef SIGIOT
+    #   NODE_DEFINE_CONSTANT(target, SIGIOT);
+    # #endif
+    # 
+    # #ifdef SIGBUS
+    #   NODE_DEFINE_CONSTANT(target, SIGBUS);
+    # #endif
+    # 
+    # #ifdef SIGFPE
+    #   NODE_DEFINE_CONSTANT(target, SIGFPE);
+    # #endif
+    # 
+    # #ifdef SIGKILL
+    #   NODE_DEFINE_CONSTANT(target, SIGKILL);
+    # #endif
+    # 
+    # #ifdef SIGUSR1
+    #   NODE_DEFINE_CONSTANT(target, SIGUSR1);
+    # #endif
+    # 
+    # #ifdef SIGSEGV
+    #   NODE_DEFINE_CONSTANT(target, SIGSEGV);
+    # #endif
+    # 
+    # #ifdef SIGUSR2
+    #   NODE_DEFINE_CONSTANT(target, SIGUSR2);
+    # #endif
+    # 
+    # #ifdef SIGPIPE
+    #   NODE_DEFINE_CONSTANT(target, SIGPIPE);
+    # #endif
+    # 
+    # #ifdef SIGALRM
+    #   NODE_DEFINE_CONSTANT(target, SIGALRM);
+    # #endif
+    # 
+    #   NODE_DEFINE_CONSTANT(target, SIGTERM);
+    #   NODE_DEFINE_CONSTANT(target, SIGCHLD);
+    # 
+    # #ifdef SIGSTKFLT
+    #   NODE_DEFINE_CONSTANT(target, SIGSTKFLT);
+    # #endif
+    # 
+    # 
+    # #ifdef SIGCONT
+    #   NODE_DEFINE_CONSTANT(target, SIGCONT);
+    # #endif
+    # 
+    # #ifdef SIGSTOP
+    #   NODE_DEFINE_CONSTANT(target, SIGSTOP);
+    # #endif
+    # 
+    # #ifdef SIGTSTP
+    #   NODE_DEFINE_CONSTANT(target, SIGTSTP);
+    # #endif
+    # 
+    # #ifdef SIGTTIN
+    #   NODE_DEFINE_CONSTANT(target, SIGTTIN);
+    # #endif
+    # 
+    # #ifdef SIGTTOU
+    #   NODE_DEFINE_CONSTANT(target, SIGTTOU);
+    # #endif
+    # 
+    # #ifdef SIGURG
+    #   NODE_DEFINE_CONSTANT(target, SIGURG);
+    # #endif
+    # 
+    # #ifdef SIGXCPU
+    #   NODE_DEFINE_CONSTANT(target, SIGXCPU);
+    # #endif
+    # 
+    # #ifdef SIGXFSZ
+    #   NODE_DEFINE_CONSTANT(target, SIGXFSZ);
+    # #endif
+    # 
+    # #ifdef SIGVTALRM
+    #   NODE_DEFINE_CONSTANT(target, SIGVTALRM);
+    # #endif
+    # 
+    # #ifdef SIGPROF
+    #   NODE_DEFINE_CONSTANT(target, SIGPROF);
+    # #endif
+    # 
+    # #ifdef SIGWINCH
+    #   NODE_DEFINE_CONSTANT(target, SIGWINCH);
+    # #endif
+    # 
+    # #ifdef SIGIO
+    #   NODE_DEFINE_CONSTANT(target, SIGIO);
+    # #endif
+    # 
+    # #ifdef SIGPOLL
+    #   NODE_DEFINE_CONSTANT(target, SIGPOLL);
+    # #endif
+    # 
+    # #ifdef SIGLOST
+    #   NODE_DEFINE_CONSTANT(target, SIGLOST);
+    # #endif
+    # 
+    # #ifdef SIGPWR
+    #   NODE_DEFINE_CONSTANT(target, SIGPWR);
+    # #endif
+    # 
+    # #ifdef SIGSYS
+    #   NODE_DEFINE_CONSTANT(target, SIGSYS);
+    # #endif
+    # 
+    # #ifdef SIGUNUSED
+    #   NODE_DEFINE_CONSTANT(target, SIGUNUSED);
+    # #endif
+  end
+end
+
+Spade.exports = Ivory::Constants