webruby 0.2.2 → 0.2.4

data/modules/emscripten/src/library.js

@@ -23,6 +23,7 @@ LibraryManager.library = {
   stdout: 'allocate(1, "i32*", ALLOC_STATIC)',
   stderr: 'allocate(1, "i32*", ALLOC_STATIC)',
   _impure_ptr: 'allocate(1, "i32*", ALLOC_STATIC)',
+  __dso_handle: 'allocate(1, "i32*", ALLOC_STATIC)',
 
   // ==========================================================================
   // dirent.h
@@ -471,6 +472,11 @@ LibraryManager.library = {
   mkstemp: function(template) {
     return _creat(_mktemp(template), 0600);
   },
+  mkdtemp__deps: ['mktemp', 'mkdir'],
+  mkdtemp: function(template) {
+    template = _mktemp(template);
+    return (_mkdir(template, 0700) === 0) ? template : 0;
+  },
   fcntl__deps: ['$FS', '__setErrNo', '$ERRNO_CODES'],
   fcntl: function(fildes, cmd, varargs, dup2) {
     // int fcntl(int fildes, int cmd, ...);
@@ -535,7 +541,7 @@ LibraryManager.library = {
     // Advise as much as you wish. We don't care.
     return 0;
   },
-  posix_madvise: 'posix_fadvise',
+  posix_madvise: function(){ return 0 }, // ditto as fadvise
   posix_fallocate__deps: ['$FS', '__setErrNo', '$ERRNO_CODES'],
   posix_fallocate: function(fd, offset, len) {
     // int posix_fallocate(int fd, off_t offset, off_t len);
@@ -847,10 +853,7 @@ LibraryManager.library = {
       ___setErrNo(ERRNO_CODES.ERANGE);
       return 0;
     } else {
-      for (var i = 0; i < cwd.length; i++) {
-        {{{ makeSetValue('buf', 'i', 'cwd.charCodeAt(i)', 'i8') }}}
-      }
-      {{{ makeSetValue('buf', 'i', '0', 'i8') }}}
+      writeAsciiToMemory(cwd, buf);
       return buf;
     }
   },
@@ -1193,7 +1196,6 @@ LibraryManager.library = {
   _exit: function(status) {
     // void _exit(int status);
     // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
-    Module.print('exit(' + status + ') called');
     Module['exit'](status);
   },
   fork__deps: ['__setErrNo', '$ERRNO_CODES'],
@@ -1293,10 +1295,7 @@ LibraryManager.library = {
     if (namesize < ret.length + 1) {
       return ___setErrNo(ERRNO_CODES.ERANGE);
     } else {
-      for (var i = 0; i < ret.length; i++) {
-        {{{ makeSetValue('name', 'i', 'ret.charCodeAt(i)', 'i8') }}}
-      }
-      {{{ makeSetValue('name', 'i', '0', 'i8') }}}
+      writeAsciiToMemory(ret, name);
       return 0;
     }
   },
@@ -1579,12 +1578,12 @@ LibraryManager.library = {
   // stdio.h
   // ==========================================================================
 
-  _isFloat: function(text) {
-    return !!(/^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?$/.exec(text));
+  _getFloat: function(text) {
+    return /^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?/.exec(text);
   },
 
   // TODO: Document.
-  _scanString__deps: ['_isFloat'],
+  _scanString__deps: ['_getFloat'],
   _scanString: function(format, get, unget, varargs) {
     if (!__scanString.whiteSpace) {
       __scanString.whiteSpace = {};
@@ -1602,12 +1601,12 @@ LibraryManager.library = {
     if (format.indexOf('%n') >= 0) {
       // need to track soFar
       var _get = get;
-      get = function() {
+      get = function get() {
         soFar++;
         return _get();
       }
       var _unget = unget;
-      unget = function() {
+      unget = function unget() {
         soFar--;
         return _unget();
       }
@@ -1743,15 +1742,13 @@ LibraryManager.library = {
         // Read characters according to the format. floats are trickier, they may be in an unfloat state in the middle, then be a valid float later
         if (type == 'f' || type == 'e' || type == 'g' ||
             type == 'F' || type == 'E' || type == 'G') {
-          var last = 0;
           next = get();
-          while (next > 0) {
+          while (next > 0 && (!(next in __scanString.whiteSpace)))  {
             buffer.push(String.fromCharCode(next));
-            if (__isFloat(buffer.join(''))) {
-              last = buffer.length;
-            }
             next = get();
           }
+          var m = __getFloat(buffer.join(''));
+          var last = m ? m[0].length : 0;
           for (var i = 0; i < buffer.length - last + 1; i++) {
             unget();
           }
@@ -1864,17 +1861,20 @@ LibraryManager.library = {
       //       int x = 4; printf("%c\n", (char)x);
       var ret;
       if (type === 'double') {
+#if TARGET_LE32 == 2
+        ret = {{{ makeGetValue('varargs', 'argIndex', 'double', undefined, undefined, true, 4) }}};
+#else
         ret = {{{ makeGetValue('varargs', 'argIndex', 'double', undefined, undefined, true) }}};
+#endif
 #if USE_TYPED_ARRAYS == 2
       } else if (type == 'i64') {
-
-#if TARGET_LE32
+#if TARGET_LE32 == 1
         ret = [{{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true) }}},
                {{{ makeGetValue('varargs', 'argIndex+8', 'i32', undefined, undefined, true) }}}];
         argIndex += {{{ STACK_ALIGN }}}; // each 32-bit chunk is in a 64-bit block
 #else
-        ret = [{{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true) }}},
-               {{{ makeGetValue('varargs', 'argIndex+4', 'i32', undefined, undefined, true) }}}];
+        ret = [{{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true, 4) }}},
+               {{{ makeGetValue('varargs', 'argIndex+4', 'i32', undefined, undefined, true, 4) }}}];
 #endif
 
 #else
@@ -1885,7 +1885,11 @@ LibraryManager.library = {
         type = 'i32'; // varargs are always i32, i64, or double
         ret = {{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true) }}};
       }
+#if TARGET_LE32 == 2
+      argIndex += Runtime.getNativeFieldSize(type);
+#else
       argIndex += Math.max(Runtime.getNativeFieldSize(type), Runtime.getAlignSize(type, null, true));
+#endif
       return ret;
     }
 
@@ -2514,6 +2518,10 @@ LibraryManager.library = {
     }
     var bytesRead = 0;
     var streamObj = FS.getStream(stream);
+    if (!streamObj) {
+      ___setErrNo(ERRNO_CODES.EBADF);
+      return 0;
+    }
     while (streamObj.ungotten.length && bytesToRead > 0) {
       {{{ makeSetValue('ptr++', '0', 'streamObj.ungotten.pop()', 'i8') }}}
       bytesToRead--;
@@ -2701,10 +2709,7 @@ LibraryManager.library = {
     var result = dir + '/' + name;
     if (!_tmpnam.buffer) _tmpnam.buffer = _malloc(256);
     if (!s) s = _tmpnam.buffer;
-    for (var i = 0; i < result.length; i++) {
-      {{{ makeSetValue('s', 'i', 'result.charCodeAt(i)', 'i8') }}};
-    }
-    {{{ makeSetValue('s', 'i', '0', 'i8') }}};
+    writeAsciiToMemory(result, s);
     return s;
   },
   tempnam__deps: ['tmpnam'],
@@ -2757,12 +2762,12 @@ LibraryManager.library = {
       return -1;
     }
     var buffer = [];
-    var get = function() {
+    function get() {
       var c = _fgetc(stream);
       buffer.push(c);
       return c;
     };
-    var unget = function() {
+    function unget() {
       _ungetc(buffer.pop(), stream);
     };
     return __scanString(format, get, unget, varargs);
@@ -2779,8 +2784,8 @@ LibraryManager.library = {
     // int sscanf(const char *restrict s, const char *restrict format, ... );
     // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html
     var index = 0;
-    var get = function() { return {{{ makeGetValue('s', 'index++', 'i8') }}}; };
-    var unget = function() { index--; };
+    function get() { return {{{ makeGetValue('s', 'index++', 'i8') }}}; };
+    function unget() { index--; };
     return __scanString(format, get, unget, varargs);
   },
   snprintf__deps: ['_formatString'],
@@ -3042,7 +3047,7 @@ LibraryManager.library = {
   },
 
   bsearch: function(key, base, num, size, compar) {
-    var cmp = function(x, y) {
+    function cmp(x, y) {
 #if ASM_JS
       return Module['dynCall_iii'](compar, x, y);
 #else
@@ -3205,7 +3210,7 @@ LibraryManager.library = {
       }
     }
     if (!finalBase) finalBase = 10;
-    start = str;
+    var start = str;
 
     // Get digits.
     var chr;
@@ -3345,10 +3350,7 @@ LibraryManager.library = {
     var ptrSize = {{{ Runtime.getNativeTypeSize('i8*') }}};
     for (var i = 0; i < strings.length; i++) {
       var line = strings[i];
-      for (var j = 0; j < line.length; j++) {
-        {{{ makeSetValue('poolPtr', 'j', 'line.charCodeAt(j)', 'i8') }}};
-      }
-      {{{ makeSetValue('poolPtr', 'j', '0', 'i8') }}};
+      writeAsciiToMemory(line, poolPtr);
       {{{ makeSetValue('envPtr', 'i * ptrSize', 'poolPtr', 'i8*') }}};
       poolPtr += line.length + 1;
     }
@@ -3537,13 +3539,15 @@ LibraryManager.library = {
   llvm_memcpy_p0i8_p0i8_i32: 'memcpy',
   llvm_memcpy_p0i8_p0i8_i64: 'memcpy',
 
-  memmove__sig: 'viii',
+  memmove__sig: 'iiii',
   memmove__asm: true,
   memmove__deps: ['memcpy'],
   memmove: function(dest, src, num) {
     dest = dest|0; src = src|0; num = num|0;
+    var ret = 0;
     if (((src|0) < (dest|0)) & ((dest|0) < ((src + num)|0))) {
       // Unlikely case: Copy backwards in a safe manner
+      ret = dest;
       src = (src + num)|0;
       dest = (dest + num)|0;
       while ((num|0) > 0) {
@@ -3552,9 +3556,11 @@ LibraryManager.library = {
         num = (num - 1)|0;
         {{{ makeSetValueAsm('dest', 0, makeGetValueAsm('src', 0, 'i8'), 'i8') }}};
       }
+      dest = ret;
     } else {
       _memcpy(dest, src, num) | 0;
     }
+    return dest | 0;
   },
   llvm_memmove_i32: 'memmove',
   llvm_memmove_i64: 'memmove',
@@ -3571,7 +3577,7 @@ LibraryManager.library = {
   memset__inline: function(ptr, value, num, align) {
     return makeSetValues(ptr, 0, value, 'null', num, align);
   },
-  memset__sig: 'viii',
+  memset__sig: 'iiii',
   memset__asm: true,
   memset: function(ptr, value, num) {
 #if USE_TYPED_ARRAYS == 2
@@ -3600,8 +3606,10 @@ LibraryManager.library = {
       {{{ makeSetValueAsm('ptr', 0, 'value', 'i8') }}};
       ptr = (ptr+1)|0;
     }
+    return (ptr-num)|0;
 #else
     {{{ makeSetValues('ptr', '0', 'value', 'null', 'num') }}};
+    return ptr;
 #endif
   },
   llvm_memset_i32: 'memset',
@@ -3978,10 +3986,7 @@ LibraryManager.library = {
         return ___setErrNo(ERRNO_CODES.ERANGE);
       } else {
         var msg = ERRNO_MESSAGES[errnum];
-        for (var i = 0; i < msg.length; i++) {
-          {{{ makeSetValue('strerrbuf', 'i', 'msg.charCodeAt(i)', 'i8') }}}
-        }
-        {{{ makeSetValue('strerrbuf', 'i', 0, 'i8') }}}
+        writeAsciiToMemory(msg, strerrbuf);
         return 0;
       }
     } else {
@@ -4165,6 +4170,11 @@ LibraryManager.library = {
     return me.ret;
   },
 
+  // ==========================================================================
+  // GCC/LLVM specifics
+  // ==========================================================================
+  __builtin_prefetch: function(){},
+
   // ==========================================================================
   // LLVM specifics
   // ==========================================================================
@@ -4670,6 +4680,10 @@ LibraryManager.library = {
 
   llvm_dbg_declare__inline: function() { throw 'llvm_debug_declare' }, // avoid warning
 
+  // llvm-nacl
+
+  llvm_nacl_atomic_store_i32__inline: true,
+
   // ==========================================================================
   // llvm-mono integration
   // ==========================================================================
@@ -5064,10 +5078,7 @@ LibraryManager.library = {
     var layout = {{{ JSON.stringify(C_STRUCTS.utsname) }}};
     function copyString(element, value) {
       var offset = layout[element];
-      for (var i = 0; i < value.length; i++) {
-        {{{ makeSetValue('name', 'offset + i', 'value.charCodeAt(i)', 'i8') }}}
-      }
-      {{{ makeSetValue('name', 'offset + i', '0', 'i8') }}}
+      writeAsciiToMemory(value, name + offset);
     }
     if (name === 0) {
       return -1;
@@ -5110,7 +5121,7 @@ LibraryManager.library = {
         table[from + i] = {};
         sigs.forEach(function(sig) { // TODO: new Function etc.
           var full = 'dynCall_' + sig;
-          table[from + i][sig] = function() {
+          table[from + i][sig] = function dynCall_sig() {
             arguments[0] -= from;
             return asm[full].apply(null, arguments);
           }
@@ -5134,7 +5145,7 @@ LibraryManager.library = {
 
       // patch js module dynCall_* to use functionTable
       sigs.forEach(function(sig) {
-        jsModule['dynCall_' + sig] = function() {
+        jsModule['dynCall_' + sig] = function dynCall_sig() {
           return table[arguments[0]][sig].apply(null, arguments);
         };
       });
@@ -5297,6 +5308,16 @@ LibraryManager.library = {
     }
   },
 
+  dladdr: function(addr, info) {
+    // report all function pointers as coming from this program itself XXX not really correct in any way
+    var fname = allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL); // XXX leak
+    {{{ makeSetValue('addr', 0, 'fname', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE, '0', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE*2, '0', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE*3, '0', 'i32') }}};
+    return 1;
+  },
+
   // ==========================================================================
   // pwd.h
   // ==========================================================================
@@ -5598,7 +5619,7 @@ LibraryManager.library = {
     var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
     var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
 
-    var leadingSomething = function(value, digits, character) {
+    function leadingSomething(value, digits, character) {
       var str = typeof value === 'number' ? value.toString() : (value || '');
       while (str.length < digits) {
         str = character[0]+str;
@@ -5606,12 +5627,12 @@ LibraryManager.library = {
       return str;
     };
 
-    var leadingNulls = function(value, digits) {
+    function leadingNulls(value, digits) {
       return leadingSomething(value, digits, '0');
     };
 
-    var compareByDay = function(date1, date2) {
-      var sgn = function(value) {
+    function compareByDay(date1, date2) {
+      function sgn(value) {
         return value < 0 ? -1 : (value > 0 ? 1 : 0);
       };
 
@@ -5624,7 +5645,7 @@ LibraryManager.library = {
       return compare;
     };
 
-    var getFirstWeekStartDate = function(janFourth) {
+    function getFirstWeekStartDate(janFourth) {
         switch (janFourth.getDay()) {
           case 0: // Sunday
             return new Date(janFourth.getFullYear()-1, 11, 29);
@@ -5643,7 +5664,7 @@ LibraryManager.library = {
         }
     };
 
-    var getWeekBasedYear = function(date) {
+    function getWeekBasedYear(date) {
         var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
 
         var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
@@ -5930,8 +5951,8 @@ LibraryManager.library = {
     var matches = new RegExp('^'+pattern).exec(Pointer_stringify(buf))
     // Module['print'](Pointer_stringify(buf)+ ' is matched by '+((new RegExp('^'+pattern)).source)+' into: '+JSON.stringify(matches));
 
-    var initDate = function() {
-      var fixup = function(value, min, max) {
+    function initDate() {
+      function fixup(value, min, max) {
         return (typeof value !== 'number' || isNaN(value)) ? min : (value>=min ? (value<=max ? value: max): min);
       };
       return {
@@ -5948,7 +5969,7 @@ LibraryManager.library = {
       var date = initDate();
       var value;
 
-      var getMatch = function(symbol) {
+      function getMatch(symbol) {
         var pos = capture.indexOf(symbol);
         // check if symbol appears in regexp
         if (pos >= 0) {
@@ -6118,16 +6139,23 @@ LibraryManager.library = {
     // int nanosleep(const struct timespec  *rqtp, struct timespec *rmtp);
     var seconds = {{{ makeGetValue('rqtp', C_STRUCTS.timespec.tv_sec, 'i32') }}};
     var nanoseconds = {{{ makeGetValue('rqtp', C_STRUCTS.timespec.tv_nsec, 'i32') }}};
-    {{{ makeSetValue('rmtp', C_STRUCTS.timespec.tv_sec, '0', 'i32') }}}
-    {{{ makeSetValue('rmtp', C_STRUCTS.timespec.tv_nsec, '0', 'i32') }}}
+    if (rmtp !== 0) {
+      {{{ makeSetValue('rmtp', C_STRUCTS.timespec.tv_sec, '0', 'i32') }}}
+      {{{ makeSetValue('rmtp', C_STRUCTS.timespec.tv_nsec, '0', 'i32') }}}
+    }
     return _usleep((seconds * 1e6) + (nanoseconds / 1000));
   },
-  // TODO: Implement these for real.
+  clock_gettime__deps: ['emscripten_get_now'],
   clock_gettime: function(clk_id, tp) {
     // int clock_gettime(clockid_t clk_id, struct timespec *tp);
-    var now = Date.now();
+    var now;
+    if (clk_id === {{{ cDefine('CLOCK_REALTIME') }}}) {
+      now = Date.now();
+    } else {
+      now = _emscripten_get_now();
+    }
     {{{ makeSetValue('tp', C_STRUCTS.timespec.tv_sec, 'Math.floor(now/1000)', 'i32') }}}; // seconds
-    {{{ makeSetValue('tp', C_STRUCTS.timespec.tv_nsec, '(now % 1000) * 1000 * 1000', 'i32') }}}; // nanoseconds (really milliseconds)
+    {{{ makeSetValue('tp', C_STRUCTS.timespec.tv_nsec, 'Math.floor((now % 1000)*1000*1000)', 'i32') }}}; // nanoseconds
     return 0;
   },
   clock_settime: function(clk_id, tp) {
@@ -6135,10 +6163,17 @@ LibraryManager.library = {
     // Nothing.
     return 0;
   },
+  clock_getres__deps: ['emscripten_get_now_res'],
   clock_getres: function(clk_id, res) {
     // int clock_getres(clockid_t clk_id, struct timespec *res);
+    var nsec;
+    if (clk_id === {{{ cDefine('CLOCK_REALTIME') }}}) {
+      nsec = 1000 * 1000;
+    } else {
+      nsec = _emscripten_get_now_res();
+    }
     {{{ makeSetValue('res', C_STRUCTS.timespec.tv_sec, '1', 'i32') }}}
-    {{{ makeSetValue('res', C_STRUCTS.timespec.tv_nsec, '1000 * 1000', 'i32') }}} // resolution is milliseconds
+    {{{ makeSetValue('res', C_STRUCTS.timespec.tv_nsec, 'nsec', 'i32') }}} // resolution is milliseconds
     return 0;
   },
 
@@ -6559,10 +6594,7 @@ LibraryManager.library = {
 
     var me = _nl_langinfo;
     if (!me.ret) me.ret = _malloc(32);
-    for (var i = 0; i < result.length; i++) {
-      {{{ makeSetValue('me.ret', 'i', 'result.charCodeAt(i)', 'i8') }}}
-    }
-    {{{ makeSetValue('me.ret', 'i', '0', 'i8') }}}
+    writeAsciiToMemory(result, me.ret);
     return me.ret;
   },
 
@@ -6878,6 +6910,10 @@ LibraryManager.library = {
   pthread_mutex_trylock: function() {
     return 0;
   },
+  pthread_mutexattr_setpshared: function(attr, pshared) {
+    // XXX implement if/when getpshared is required
+    return 0;
+  },
   pthread_cond_init: function() {},
   pthread_cond_destroy: function() {},
   pthread_cond_broadcast: function() {
@@ -6946,7 +6982,7 @@ LibraryManager.library = {
 
   pthread_setspecific__deps: ['$PTHREAD_SPECIFIC', '$ERRNO_CODES'],
   pthread_setspecific: function(key, value) {
-    if (value == 0) {
+    if (!(key in PTHREAD_SPECIFIC)) {
       return ERRNO_CODES.EINVAL;
     }
     PTHREAD_SPECIFIC[key] = value;
@@ -6973,6 +7009,10 @@ LibraryManager.library = {
     _pthread_cleanup_push.level = __ATEXIT__.length;
   },
 
+  pthread_rwlock_init: function() {
+    return 0; // XXX
+  },
+
   // ==========================================================================
   // malloc.h
   // ==========================================================================
@@ -7314,6 +7354,7 @@ LibraryManager.library = {
   // we're generating fake IP addresses with lookup_name that we can
   // resolve later on with lookup_addr.
   // We do the aliasing in 172.29.*.*, giving us 65536 possibilities.
+  $DNS__deps: ['_inet_pton4_raw', '_inet_pton6_raw'],
   $DNS: {
     address_map: {
       id: 1,
@@ -7321,7 +7362,6 @@ LibraryManager.library = {
       names: {}
     },
 
-    lookup_name__deps: ['_inet_pton4_raw', '_inet_pton6_raw'],
     lookup_name: function (name) {
       // If the name is already a valid ipv4 / ipv6 address, don't generate a fake one.
       var res = __inet_pton4_raw(name);
@@ -7412,6 +7452,9 @@ LibraryManager.library = {
 
   getaddrinfo__deps: ['$Sockets', '$DNS', '_inet_pton4_raw', '_inet_ntop4_raw', '_inet_pton6_raw', '_inet_ntop6_raw', '_write_sockaddr', 'htonl'],
   getaddrinfo: function(node, service, hint, out) {
+    // Note getaddrinfo currently only returns a single addrinfo with ai_next defaulting to NULL. When NULL
+    // hints are specified or ai_family set to AF_UNSPEC or ai_socktype or ai_protocol set to 0 then we
+    // really should provide a linked list of suitable addrinfo values.
     var addrs = [];
     var canon = null;
     var addr = 0;
@@ -7466,6 +7509,15 @@ LibraryManager.library = {
       type = proto === {{{ cDefine('IPPROTO_UDP') }}} ? {{{ cDefine('SOCK_DGRAM') }}} : {{{ cDefine('SOCK_STREAM') }}};
     }
 
+    // If type or proto are set to zero in hints we should really be returning multiple addrinfo values, but for
+    // now default to a TCP STREAM socket so we can at least return a sensible addrinfo given NULL hints.
+    if (proto === 0) {
+      proto = {{{ cDefine('IPPROTO_TCP') }}};
+    }
+    if (type === 0) {
+      type = {{{ cDefine('SOCK_STREAM') }}};
+    }
+
     if (!node && !service) {
       return {{{ cDefine('EAI_NONAME') }}};
     }
@@ -7473,14 +7525,14 @@ LibraryManager.library = {
         {{{ cDefine('AI_NUMERICSERV') }}}|{{{ cDefine('AI_V4MAPPED') }}}|{{{ cDefine('AI_ALL') }}}|{{{ cDefine('AI_ADDRCONFIG') }}})) {
       return {{{ cDefine('EAI_BADFLAGS') }}};
     }
-    if (({{{ makeGetValue('hint', C_STRUCTS.addrinfo.ai_flags, 'i32') }}} & {{{ cDefine('AI_CANONNAME') }}}) && !node) {
+    if (hint !== 0 && ({{{ makeGetValue('hint', C_STRUCTS.addrinfo.ai_flags, 'i32') }}} & {{{ cDefine('AI_CANONNAME') }}}) && !node) {
       return {{{ cDefine('EAI_BADFLAGS') }}};
     }
     if (flags & {{{ cDefine('AI_ADDRCONFIG') }}}) {
       // TODO
       return {{{ cDefine('EAI_NONAME') }}};
     }
-    if (type !== {{{ cDefine('SOCK_STREAM') }}} && type !== {{{ cDefine('SOCK_DGRAM') }}}) {
+    if (type !== 0 && type !== {{{ cDefine('SOCK_STREAM') }}} && type !== {{{ cDefine('SOCK_DGRAM') }}}) {
       return {{{ cDefine('EAI_SOCKTYPE') }}};
     }
     if (family !== {{{ cDefine('AF_UNSPEC') }}} && family !== {{{ cDefine('AF_INET') }}} && family !== {{{ cDefine('AF_INET6') }}}) {
@@ -7610,12 +7662,131 @@ LibraryManager.library = {
 
     return 0;
   },
+  // Can't use a literal for $GAI_ERRNO_MESSAGES as was done for $ERRNO_MESSAGES as the keys (e.g. EAI_BADFLAGS)
+  // are actually negative numbers and you can't have expressions as keys in JavaScript literals.
+  $GAI_ERRNO_MESSAGES: {},
 
+  gai_strerror__deps: ['$GAI_ERRNO_MESSAGES'],
   gai_strerror: function(val) {
-    if (!_gai_strerror.error) {
-      _gai_strerror.error = allocate(intArrayFromString("unknown error"), 'i8', ALLOC_NORMAL);
+    var buflen = 256;
+
+    // On first call to gai_strerror we initialise the buffer and populate the error messages.
+    if (!_gai_strerror.buffer) {
+        _gai_strerror.buffer = _malloc(buflen);
+
+        GAI_ERRNO_MESSAGES['0'] = 'Success';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_BADFLAGS') }}}] = 'Invalid value for \'ai_flags\' field';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_NONAME') }}}] = 'NAME or SERVICE is unknown';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_AGAIN') }}}] = 'Temporary failure in name resolution';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_FAIL') }}}] = 'Non-recoverable failure in name res';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_FAMILY') }}}] = '\'ai_family\' not supported';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_SOCKTYPE') }}}] = '\'ai_socktype\' not supported';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_SERVICE') }}}] = 'SERVICE not supported for \'ai_socktype\'';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_MEMORY') }}}] = 'Memory allocation failure';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_SYSTEM') }}}] = 'System error returned in \'errno\'';
+        GAI_ERRNO_MESSAGES['' + {{{ cDefine('EAI_OVERFLOW') }}}] = 'Argument buffer overflow';
+    }
+
+    var msg = 'Unknown error';
+
+    if (val in GAI_ERRNO_MESSAGES) {
+      if (GAI_ERRNO_MESSAGES[val].length > buflen - 1) {
+        msg = 'Message too long'; // EMSGSIZE message. This should never occur given the GAI_ERRNO_MESSAGES above. 
+      } else {
+        msg = GAI_ERRNO_MESSAGES[val];
+      }
+    }
+
+    writeAsciiToMemory(msg, _gai_strerror.buffer);
+    return _gai_strerror.buffer;
+  },
+
+  // Implement netdb.h protocol entry (getprotoent, getprotobyname, getprotobynumber, setprotoent, endprotoent)
+  // http://pubs.opengroup.org/onlinepubs/9699919799/functions/getprotobyname.html
+  // The Protocols object holds our 'fake' protocols 'database'.
+  $Protocols: {
+    list: [],
+    map: {}
+  },
+  setprotoent__deps: ['$Protocols'],
+  setprotoent: function(stayopen) {
+    // void setprotoent(int stayopen);
+
+    // Allocate and populate a protoent structure given a name, protocol number and array of aliases
+    function allocprotoent(name, proto, aliases) {
+      // write name into buffer
+      var nameBuf = _malloc(name.length + 1);
+      writeAsciiToMemory(name, nameBuf);
+
+      // write aliases into buffer
+      var j = 0;
+      var length = aliases.length;
+      var aliasListBuf = _malloc((length + 1) * 4); // Use length + 1 so we have space for the terminating NULL ptr.
+
+      for (var i = 0; i < length; i++, j += 4) {
+        var alias = aliases[i];
+        var aliasBuf = _malloc(alias.length + 1);
+        writeAsciiToMemory(alias, aliasBuf);
+        {{{ makeSetValue('aliasListBuf', 'j', 'aliasBuf', 'i8*') }}};
+      }
+      {{{ makeSetValue('aliasListBuf', 'j', '0', 'i8*') }}}; // Terminating NULL pointer.
+
+      // generate protoent
+      var pe = _malloc({{{ C_STRUCTS.protoent.__size__ }}});
+      {{{ makeSetValue('pe', C_STRUCTS.protoent.p_name, 'nameBuf', 'i8*') }}};
+      {{{ makeSetValue('pe', C_STRUCTS.protoent.p_aliases, 'aliasListBuf', 'i8**') }}};
+      {{{ makeSetValue('pe', C_STRUCTS.protoent.p_proto, 'proto', 'i32') }}};
+      return pe;
+    };
+
+    // Populate the protocol 'database'. The entries are limited to tcp and udp, though it is fairly trivial
+    // to add extra entries from /etc/protocols if desired - though not sure if that'd actually be useful.
+    var list = Protocols.list;
+    var map  = Protocols.map;
+    if (list.length === 0) {
+        var entry = allocprotoent('tcp', 6, ['TCP']);
+        list.push(entry);
+        map['tcp'] = map['6'] = entry;
+        entry = allocprotoent('udp', 17, ['UDP']);
+        list.push(entry);
+        map['udp'] = map['17'] = entry;
+    }
+
+    _setprotoent.index = 0;
+  },
+
+  endprotoent: function() {
+    // void endprotoent(void);
+    // We're not using a real protocol database so we don't do a real close.
+  },
+
+  getprotoent__deps: ['setprotoent', '$Protocols'],
+  getprotoent: function(number) {
+    // struct protoent *getprotoent(void);
+    // reads the  next  entry  from  the  protocols 'database' or return NULL if 'eof'
+    if (_setprotoent.index === Protocols.list.length) {
+      return 0; 
+    } else {
+      var result = Protocols.list[_setprotoent.index++];
+      return result;
     }
-    return _gai_strerror.error;
+  },
+
+  getprotobyname__deps: ['setprotoent', '$Protocols'],
+  getprotobyname: function(name) {
+    // struct protoent *getprotobyname(const char *);
+    name = Pointer_stringify(name);
+    _setprotoent(true);
+    var result = Protocols.map[name];
+    return result;
+  },
+
+  getprotobynumber__deps: ['setprotoent', '$Protocols'],
+  getprotobynumber: function(number) {
+    // struct protoent *getprotobynumber(int proto);
+    _setprotoent(true);
+    var result = Protocols.map[number];
+    return result;
   },
 
   // ==========================================================================
@@ -7683,7 +7854,7 @@ LibraryManager.library = {
       var session = Module['webrtc']['session'];
       var peer = new Peer(broker);
       var listenOptions = Module['webrtc']['hostOptions'] || {};
-      peer.onconnection = function(connection) {
+      peer.onconnection = function peer_onconnection(connection) {
         console.log('connected');
         var addr;
         /* If this peer is connecting to the host, assign 10.0.0.1 to the host so it can be
@@ -7697,7 +7868,7 @@ LibraryManager.library = {
         }
         connection['addr'] = addr;
         Sockets.connections[addr] = connection;
-        connection.ondisconnect = function() {
+        connection.ondisconnect = function connection_ondisconnect() {
           console.log('disconnect');
           // Don't return the host address (10.0.0.1) to the pool
           if (!(session && session === Sockets.connections[addr]['route'])) {
@@ -7709,12 +7880,12 @@ LibraryManager.library = {
             Module['webrtc']['ondisconnect'](peer);
           }
         };
-        connection.onerror = function(error) {
+        connection.onerror = function connection_onerror(error) {
           if (Module['webrtc']['onerror'] && 'function' === typeof Module['webrtc']['onerror']) {
             Module['webrtc']['onerror'](error);
           }
         };
-        connection.onmessage = function(label, message) {
+        connection.onmessage = function connection_onmessage(label, message) {
           if ('unreliable' === label) {
             handleMessage(addr, message.data);
           }
@@ -7724,13 +7895,13 @@ LibraryManager.library = {
           Module['webrtc']['onconnect'](peer);
         }
       };
-      peer.onpending = function(pending) {
+      peer.onpending = function peer_onpending(pending) {
         console.log('pending from: ', pending['route'], '; initiated by: ', (pending['incoming']) ? 'remote' : 'local');
       };
-      peer.onerror = function(error) {
+      peer.onerror = function peer_onerror(error) {
         console.error(error);
       };
-      peer.onroute = function(route) {
+      peer.onroute = function peer_onroute(route) {
         if (Module['webrtc']['onpeer'] && 'function' === typeof Module['webrtc']['onpeer']) {
           Module['webrtc']['onpeer'](peer, route);
         }
@@ -7746,7 +7917,7 @@ LibraryManager.library = {
           console.log("unable to deliver message: ", addr, header[1], message);
         }
       }
-      window.onbeforeunload = function() {
+      window.onbeforeunload = function window_onbeforeunload() {
         var ids = Object.keys(Sockets.connections);
         ids.forEach(function(id) {
           Sockets.connections[id].close();
@@ -7815,7 +7986,7 @@ LibraryManager.library = {
     }
     info.addr = Sockets.localAddr; // 10.0.0.254
     info.host = __inet_ntop4_raw(info.addr);
-    info.close = function() {
+    info.close = function info_close() {
       Sockets.portmap[info.port] = undefined;
     }
     Sockets.portmap[info.port] = info;
@@ -8181,7 +8352,7 @@ LibraryManager.library = {
   },
 
   accept__deps: ['$FS', '$SOCKFS', '$DNS', '$ERRNO_CODES', '__setErrNo', '_write_sockaddr'],
-  accept: function(fd, addrp, addrlen) {
+  accept: function(fd, addr, addrlen) {
     var sock = SOCKFS.getSocket(fd);
     if (!sock) {
       ___setErrNo(ERRNO_CODES.EBADF);
@@ -8189,7 +8360,7 @@ LibraryManager.library = {
     }
     try {
       var newsock = sock.sock_ops.accept(sock);
-      if (addrp) {
+      if (addr) {
         var res = __write_sockaddr(addr, newsock.family, DNS.lookup_name(newsock.daddr), newsock.dport);
         assert(!res.errno);
       }
@@ -8547,7 +8718,13 @@ LibraryManager.library = {
       return -1;
     }
     var arg = {{{ makeGetValue('varargs', '0', 'i32') }}};
-    return FS.ioctl(stream, request, arg);
+
+    try {
+      return FS.ioctl(stream, request, arg);
+    } catch (e) {
+      FS.handleFSError(e);
+      return -1;
+    }
   },
 #endif
 
@@ -8580,7 +8757,7 @@ LibraryManager.library = {
   },
 
   emscripten_run_script_string: function(ptr) {
-    var s = eval(Pointer_stringify(ptr));
+    var s = eval(Pointer_stringify(ptr)) + '';
     var me = _emscripten_run_script_string;
     if (!me.bufferSize || me.bufferSize < s.length+1) {
       if (me.bufferSize) _free(me.buffer);
@@ -8614,12 +8791,120 @@ LibraryManager.library = {
   },
 
   emscripten_asm_const: function(code) {
-    // code is a constant string on the heap, so we can cache these
-    if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
-    var func = Runtime.asmConstCache[code];
-    if (func) return func();
-    func = Runtime.asmConstCache[code] = eval('(function(){ ' + Pointer_stringify(code) + ' })'); // new Function does not allow upvars in node
-    return func();
+    Runtime.getAsmConst(code, 0)();
+  },
+
+  emscripten_asm_const_int__jsargs: true,
+  emscripten_asm_const_int: function(code) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return Runtime.getAsmConst(code, args.length).apply(null, args) | 0;
+  },
+
+  emscripten_asm_const_double__jsargs: true,
+  emscripten_asm_const_double: function(code) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return +Runtime.getAsmConst(code, args.length).apply(null, args);
+  },
+
+  emscripten_get_now: function() {
+    if (!_emscripten_get_now.actual) {
+      if (ENVIRONMENT_IS_NODE) {
+        _emscripten_get_now.actual = function _emscripten_get_now_actual() {
+          var t = process['hrtime']();
+          return t[0] * 1e3 + t[1] / 1e6;
+        }
+      } else if (typeof dateNow !== 'undefined') {
+        _emscripten_get_now.actual = dateNow;
+      } else if (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now']) {
+        _emscripten_get_now.actual = function _emscripten_get_now_actual() { return window['performance']['now'](); };
+      } else {
+        _emscripten_get_now.actual = Date.now;
+      }
+    }
+    return _emscripten_get_now.actual();
+  },
+
+  emscripten_get_now_res: function() { // return resolution of get_now, in nanoseconds
+    if (ENVIRONMENT_IS_NODE) {
+      return 1; // nanoseconds
+    } else if (typeof dateNow !== 'undefined' ||
+               (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now'])) {
+      return 1000; // microseconds (1/1000 of a millisecond)
+    } else {
+      return 1000*1000; // milliseconds
+    }
+  },
+
+  //============================
+  // emscripten vector ops
+  //============================
+
+  emscripten_float32x4_signmask__inline: function(a) {
+    return 'SIMD.float32x4.bitsToInt32x4(' + a + ').signMask';
+  },
+  
+  emscripten_float32x4_min__inline: function(a, b) {
+    return 'SIMD.float32x4.min(' + a + ', ' + b + ')';
+  },
+  
+  emscripten_float32x4_max__inline: function(a, b) {
+    return 'SIMD.float32x4.max(' + a + ', ' + b + ')';
+  },
+  
+  emscripten_float32x4_sqrt__inline: function(a) {
+    return 'SIMD.float32x4.sqrt(' + a + ')';
+  },
+  
+  emscripten_float32x4_lessThan__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.float32x4.lessThan(' + a + ', ' + b + '))';
+  },
+  
+  emscripten_float32x4_lessThanOrEqual__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.float32x4.lessThanOrEqual(' + a + ', ' + b + '))';
+  },
+  
+  emscripten_float32x4_equal__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.float32x4.equal(' + a + ', ' + b + '))';
+  },
+  
+  emscripten_float32x4_greaterThanOrEqual__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.float32x4.greaterThanOrEqual(' + a + ', ' + b + '))';
+  },
+  
+  emscripten_float32x4_greaterThan__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.float32x4.greaterThan(' + a + ', ' + b + '))';
+  },
+  
+  emscripten_float32x4_and__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.int32x4.and(SIMD.float32x4.bitsToInt32x4(' + a + '), SIMD.float32x4.bitsToInt32x4(' + b + ')))';
+  },
+  
+  emscripten_float32x4_andNot__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.int32x4.and(SIMD.int32x4.not(SIMD.float32x4.bitsToInt32x4(' + a + ')), SIMD.float32x4.bitsToInt32x4(' + b + ')))';
+  },
+  
+  emscripten_float32x4_or__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.int32x4.or(SIMD.float32x4.bitsToInt32x4(' + a + '), SIMD.float32x4.bitsToInt32x4(' + b + ')))';
+  },
+  
+  emscripten_float32x4_xor__inline: function(a, b) {
+    return 'SIMD.int32x4.bitsToFloat32x4(SIMD.int32x4.xor(SIMD.float32x4.bitsToInt32x4(' + a + '), SIMD.float32x4.bitsToInt32x4(' + b + ')))';
+  },
+  
+  emscripten_int32x4_bitsToFloat32x4__inline: function(a) {
+      return 'SIMD.int32x4.bitsToFloat32x4(' + a + ')';
+  },
+  
+  emscripten_int32x4_toFloat32x4__inline: function(a) {
+      return 'SIMD.int32x4.toFloat32x4(' + a + ')';
+  },
+  
+  emscripten_float32x4_bitsToInt32x4__inline: function(a) {
+      return 'SIMD.float32x4.bitsToInt32x4(' + a + ')';
+  },
+  
+  emscripten_float32x4_toInt32x4__inline: function(a) {
+      return 'SIMD.float32x4.toInt32x4(' + a + ')';
   },
 
   //============================
@@ -8718,6 +9003,6 @@ function autoAddDeps(object, name) {
 
 // Add aborting stubs for various libc stuff needed by libc++
 ['pthread_cond_signal', 'pthread_equal', 'wcstol', 'wcstoll', 'wcstoul', 'wcstoull', 'wcstof', 'wcstod', 'wcstold', 'pthread_join', 'pthread_detach', 'catgets', 'catopen', 'catclose', 'fputwc', '__lockfile', '__unlockfile'].forEach(function(aborter) {
-  LibraryManager.library[aborter] = function() { throw 'TODO: ' + aborter };
+  LibraryManager.library[aborter] = function aborting_stub() { throw 'TODO: ' + aborter };
 });