Add m-esr52 at 52.6.0

1 files changed, 735 insertions, 0 deletions

diff --git a/toolkit/components/osfile/modules/osfile_unix_back.jsm b/toolkit/components/osfile/modules/osfile_unix_back.jsm
new file mode 100644
index 000000000..a028dda7d
--- /dev/null
+++ b/toolkit/components/osfile/modules/osfile_unix_back.jsm
@@ -0,0 +1,735 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+{
+  if (typeof Components != "undefined") {
+    // We do not wish osfile_unix_back.jsm to be used directly as a main thread
+    // module yet. When time comes, it will be loaded by a combination of
+    // a main thread front-end/worker thread implementation that makes sure
+    // that we are not executing synchronous IO code in the main thread.
+
+    throw new Error("osfile_unix_back.jsm cannot be used from the main thread yet");
+  }
+  (function(exports) {
+     "use strict";
+     if (exports.OS && exports.OS.Unix && exports.OS.Unix.File) {
+       return; // Avoid double initialization
+     }
+
+     let SharedAll =
+       require("resource://gre/modules/osfile/osfile_shared_allthreads.jsm");
+     let SysAll =
+       require("resource://gre/modules/osfile/osfile_unix_allthreads.jsm");
+     let LOG = SharedAll.LOG.bind(SharedAll, "Unix", "back");
+     let libc = SysAll.libc;
+     let Const = SharedAll.Constants.libc;
+
+     /**
+      * Initialize the Unix module.
+      *
+      * @param {function=} declareFFI
+      */
+     // FIXME: Both |init| and |aDeclareFFI| are deprecated, we should remove them
+     let init = function init(aDeclareFFI) {
+       let declareFFI;
+       if (aDeclareFFI) {
+         declareFFI = aDeclareFFI.bind(null, libc);
+       } else {
+         declareFFI = SysAll.declareFFI;
+       }
+       let declareLazyFFI = SharedAll.declareLazyFFI;
+
+       // Initialize types that require additional OS-specific
+       // support - either finalization or matching against
+       // OS-specific constants.
+       let Type = Object.create(SysAll.Type);
+       let SysFile = exports.OS.Unix.File = { Type: Type };
+
+       /**
+        * A file descriptor.
+        */
+       Type.fd = Type.int.withName("fd");
+       Type.fd.importFromC = function importFromC(fd_int) {
+         return ctypes.CDataFinalizer(fd_int, SysFile._close);
+       };
+
+
+       /**
+        * A C integer holding -1 in case of error or a file descriptor
+        * in case of success.
+        */
+       Type.negativeone_or_fd = Type.fd.withName("negativeone_or_fd");
+       Type.negativeone_or_fd.importFromC =
+         function importFromC(fd_int) {
+           if (fd_int == -1) {
+             return -1;
+           }
+           return ctypes.CDataFinalizer(fd_int, SysFile._close);
+         };
+
+       /**
+        * A C integer holding -1 in case of error or a meaningless value
+        * in case of success.
+        */
+       Type.negativeone_or_nothing =
+         Type.int.withName("negativeone_or_nothing");
+
+       /**
+        * A C integer holding -1 in case of error or a positive integer
+        * in case of success.
+        */
+       Type.negativeone_or_ssize_t =
+         Type.ssize_t.withName("negativeone_or_ssize_t");
+
+       /**
+        * Various libc integer types
+        */
+       Type.mode_t =
+         Type.intn_t(Const.OSFILE_SIZEOF_MODE_T).withName("mode_t");
+       Type.uid_t =
+         Type.intn_t(Const.OSFILE_SIZEOF_UID_T).withName("uid_t");
+       Type.gid_t =
+         Type.intn_t(Const.OSFILE_SIZEOF_GID_T).withName("gid_t");
+
+       /**
+        * Type |time_t|
+        */
+       Type.time_t =
+         Type.intn_t(Const.OSFILE_SIZEOF_TIME_T).withName("time_t");
+
+       // Structure |dirent|
+       // Building this type is rather complicated, as its layout varies between
+       // variants of Unix. For this reason, we rely on a number of constants
+       // (computed in C from the C data structures) that give us the layout.
+       // The structure we compute looks like
+       //  { int8_t[...] before_d_type; // ignored content
+       //    int8_t      d_type       ;
+       //    int8_t[...] before_d_name; // ignored content
+       //    char[...]   d_name;
+       //    };
+       {
+         let d_name_extra_size = 0;
+         if (Const.OSFILE_SIZEOF_DIRENT_D_NAME < 8) {
+           // d_name is defined like "char d_name[1];" on some platforms
+           // (e.g. Solaris), we need to give it more size for our structure.
+           d_name_extra_size = 256;
+         }
+
+         let dirent = new SharedAll.HollowStructure("dirent",
+           Const.OSFILE_SIZEOF_DIRENT + d_name_extra_size);
+         if (Const.OSFILE_OFFSETOF_DIRENT_D_TYPE != undefined) {
+           // |dirent| doesn't have d_type on some platforms (e.g. Solaris).
+           dirent.add_field_at(Const.OSFILE_OFFSETOF_DIRENT_D_TYPE,
+             "d_type", ctypes.uint8_t);
+         }
+         dirent.add_field_at(Const.OSFILE_OFFSETOF_DIRENT_D_NAME,
+           "d_name", ctypes.ArrayType(ctypes.char,
+             Const.OSFILE_SIZEOF_DIRENT_D_NAME + d_name_extra_size));
+
+         // We now have built |dirent|.
+         Type.dirent = dirent.getType();
+       }
+       Type.null_or_dirent_ptr =
+         new SharedAll.Type("null_of_dirent",
+                  Type.dirent.out_ptr.implementation);
+
+       // Structure |stat|
+       // Same technique
+       {
+         let stat = new SharedAll.HollowStructure("stat",
+           Const.OSFILE_SIZEOF_STAT);
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_MODE,
+                        "st_mode", Type.mode_t.implementation);
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_UID,
+                          "st_uid", Type.uid_t.implementation);
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_GID,
+                          "st_gid", Type.gid_t.implementation);
+
+         // Here, things get complicated with different data structures.
+         // Some platforms have |time_t st_atime| and some platforms have
+         // |timespec st_atimespec|. However, since |timespec| starts with
+         // a |time_t|, followed by nanoseconds, we just cheat and pretend
+         // that everybody has |time_t st_atime|, possibly followed by padding
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_ATIME,
+                          "st_atime", Type.time_t.implementation);
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_MTIME,
+                          "st_mtime", Type.time_t.implementation);
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_CTIME,
+                          "st_ctime", Type.time_t.implementation);
+
+         // To complicate further, MacOS and some BSDs have a field |birthtime|
+         if ("OSFILE_OFFSETOF_STAT_ST_BIRTHTIME" in Const) {
+           stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_BIRTHTIME,
+                             "st_birthtime", Type.time_t.implementation);
+         }
+
+         stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_SIZE,
+                        "st_size", Type.off_t.implementation);
+         Type.stat = stat.getType();
+       }
+
+       // Structure |DIR|
+       if ("OSFILE_SIZEOF_DIR" in Const) {
+         // On platforms for which we need to access the fields of DIR
+         // directly (e.g. because certain functions are implemented
+         // as macros), we need to define DIR as a hollow structure.
+         let DIR = new SharedAll.HollowStructure(
+           "DIR",
+           Const.OSFILE_SIZEOF_DIR);
+
+         DIR.add_field_at(
+           Const.OSFILE_OFFSETOF_DIR_DD_FD,
+           "dd_fd",
+           Type.fd.implementation);
+
+         Type.DIR = DIR.getType();
+       } else {
+         // On other platforms, we keep DIR as a blackbox
+         Type.DIR =
+           new SharedAll.Type("DIR",
+             ctypes.StructType("DIR"));
+       }
+
+       Type.null_or_DIR_ptr =
+         Type.DIR.out_ptr.withName("null_or_DIR*");
+       Type.null_or_DIR_ptr.importFromC = function importFromC(dir) {
+         if (dir == null || dir.isNull()) {
+           return null;
+         }
+         return ctypes.CDataFinalizer(dir, SysFile._close_dir);
+       };
+
+       // Structure |timeval|
+       {
+         let timeval = new SharedAll.HollowStructure(
+           "timeval",
+           Const.OSFILE_SIZEOF_TIMEVAL);
+         timeval.add_field_at(
+           Const.OSFILE_OFFSETOF_TIMEVAL_TV_SEC,
+           "tv_sec",
+           Type.long.implementation);
+         timeval.add_field_at(
+           Const.OSFILE_OFFSETOF_TIMEVAL_TV_USEC,
+           "tv_usec",
+           Type.long.implementation);
+         Type.timeval = timeval.getType();
+         Type.timevals = new SharedAll.Type("two timevals",
+           ctypes.ArrayType(Type.timeval.implementation, 2));
+       }
+
+       // Types fsblkcnt_t and fsfilcnt_t, used by structure |statvfs|
+       Type.fsblkcnt_t =
+         Type.uintn_t(Const.OSFILE_SIZEOF_FSBLKCNT_T).withName("fsblkcnt_t");
+
+       // Structure |statvfs|
+       // Use an hollow structure
+       {
+         let statvfs = new SharedAll.HollowStructure("statvfs",
+           Const.OSFILE_SIZEOF_STATVFS);
+
+         statvfs.add_field_at(Const.OSFILE_OFFSETOF_STATVFS_F_BSIZE,
+                        "f_bsize", Type.unsigned_long.implementation);
+         statvfs.add_field_at(Const.OSFILE_OFFSETOF_STATVFS_F_BAVAIL,
+                        "f_bavail", Type.fsblkcnt_t.implementation);
+
+         Type.statvfs = statvfs.getType();
+       }
+
+       // Declare libc functions as functions of |OS.Unix.File|
+
+       // Finalizer-related functions
+       libc.declareLazy(SysFile, "_close",
+                        "close", ctypes.default_abi,
+                        /*return */ctypes.int,
+                        /*fd*/     ctypes.int);
+
+       SysFile.close = function close(fd) {
+         // Detach the finalizer and call |_close|.
+         return fd.dispose();
+       };
+
+       libc.declareLazy(SysFile, "_close_dir",
+                        "closedir", ctypes.default_abi,
+                        /*return */ctypes.int,
+                        /*dirp*/   Type.DIR.in_ptr.implementation);
+
+       SysFile.closedir = function closedir(fd) {
+         // Detach the finalizer and call |_close_dir|.
+         return fd.dispose();
+       };
+
+       {
+         // Symbol free() is special.
+         // We override the definition of free() on several platforms.
+         let default_lib = new SharedAll.Library("default_lib",
+                                                 "a.out");
+
+         // On platforms for which we override free(), nspr defines
+         // a special library name "a.out" that will resolve to the
+         // correct implementation free().
+         // If it turns out we don't have an a.out library or a.out
+         // doesn't contain free, use the ordinary libc free.
+
+         default_lib.declareLazyWithFallback(libc, SysFile, "free",
+           "free", ctypes.default_abi,
+           /*return*/ ctypes.void_t,
+           /*ptr*/    ctypes.voidptr_t);
+       }
+
+
+       // Other functions
+       libc.declareLazyFFI(SysFile,  "access",
+                           "access", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path,
+                           /*mode*/   Type.int);
+
+       libc.declareLazyFFI(SysFile,  "chdir",
+                           "chdir", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path);
+
+       libc.declareLazyFFI(SysFile,  "chmod",
+                           "chmod", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path,
+                           /*mode*/   Type.mode_t);
+
+       libc.declareLazyFFI(SysFile,  "chown",
+                           "chown", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path,
+                           /*uid*/    Type.uid_t,
+                           /*gid*/    Type.gid_t);
+
+       libc.declareLazyFFI(SysFile,  "copyfile",
+                           "copyfile", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*source*/ Type.path,
+                           /*dest*/   Type.path,
+                           /*state*/  Type.void_t.in_ptr, // Ignored atm
+                           /*flags*/  Type.uint32_t);
+
+       libc.declareLazyFFI(SysFile,  "dup",
+                           "dup", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_fd,
+                           /*fd*/     Type.fd);
+
+       if ("OSFILE_SIZEOF_DIR" in Const) {
+         // On platforms for which |dirfd| is a macro
+         SysFile.dirfd =
+           function dirfd(DIRp) {
+             return Type.DIR.in_ptr.implementation(DIRp).contents.dd_fd;
+           };
+       } else {
+         // On platforms for which |dirfd| is a function
+         libc.declareLazyFFI(SysFile,  "dirfd",
+                             "dirfd", ctypes.default_abi,
+                             /*return*/ Type.negativeone_or_fd,
+                             /*dir*/    Type.DIR.in_ptr);
+       }
+
+       libc.declareLazyFFI(SysFile,  "chdir",
+                           "chdir", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path);
+
+       libc.declareLazyFFI(SysFile,  "fchdir",
+                           "fchdir", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd);
+
+       libc.declareLazyFFI(SysFile,  "fchmod",
+                           "fchmod", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd,
+                           /*mode*/   Type.mode_t);
+
+       libc.declareLazyFFI(SysFile,  "fchown",
+                           "fchown", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd,
+                           /*uid_t*/  Type.uid_t,
+                           /*gid_t*/  Type.gid_t);
+
+       libc.declareLazyFFI(SysFile,  "fsync",
+                           "fsync", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd);
+
+       libc.declareLazyFFI(SysFile,  "getcwd",
+                           "getcwd", ctypes.default_abi,
+                           /*return*/ Type.out_path,
+                           /*buf*/    Type.out_path,
+                           /*size*/   Type.size_t);
+
+       libc.declareLazyFFI(SysFile,  "getwd",
+                           "getwd", ctypes.default_abi,
+                           /*return*/ Type.out_path,
+                           /*buf*/    Type.out_path);
+
+       // Two variants of |getwd| which allocate the memory
+       // dynamically.
+
+       // Linux/Android version
+       libc.declareLazyFFI(SysFile,  "get_current_dir_name",
+                           "get_current_dir_name", ctypes.default_abi,
+                           /*return*/ Type.out_path.releaseWithLazy(() =>
+                             SysFile.free
+                           ));
+
+       // MacOS/BSD version (will return NULL on Linux/Android)
+       libc.declareLazyFFI(SysFile,  "getwd_auto",
+                           "getwd", ctypes.default_abi,
+                           /*return*/ Type.out_path.releaseWithLazy(() =>
+                             SysFile.free
+                           ),
+                           /*buf*/    Type.void_t.out_ptr);
+
+       libc.declareLazyFFI(SysFile,  "fdatasync",
+                           "fdatasync", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd); // Note: MacOS/BSD-specific
+
+       libc.declareLazyFFI(SysFile,  "ftruncate",
+                           "ftruncate", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*fd*/     Type.fd,
+                           /*length*/ Type.off_t);
+
+
+       libc.declareLazyFFI(SysFile,  "lchown",
+                           "lchown", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*path*/   Type.path,
+                           /*uid_t*/  Type.uid_t,
+                           /*gid_t*/  Type.gid_t);
+
+       libc.declareLazyFFI(SysFile,  "link",
+                           "link", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_nothing,
+                           /*source*/ Type.path,
+                           /*dest*/   Type.path);
+
+       libc.declareLazyFFI(SysFile,  "lseek",
+                           "lseek", ctypes.default_abi,
+                           /*return*/ Type.off_t,
+                           /*fd*/     Type.fd,
+                           /*offset*/ Type.off_t,
+                           /*whence*/ Type.int);
+
+       libc.declareLazyFFI(SysFile,  "mkdir",
+                           "mkdir", ctypes.default_abi,
+                           /*return*/ Type.int,
+                           /*path*/ Type.path,
+                           /*mode*/ Type.int);
+
+       libc.declareLazyFFI(SysFile,  "mkstemp",
+                           "mkstemp", ctypes.default_abi,
+                           /*return*/   Type.fd,
+                           /*template*/ Type.out_path);
+
+       libc.declareLazyFFI(SysFile,  "open",
+                           "open", ctypes.default_abi,
+                           /*return*/ Type.negativeone_or_fd,
+                           /*path*/   Type.path,
+                           /*oflags*/ Type.int,
+                           /*mode*/   Type.int);
+
+       if (OS.Constants.Sys.Name == "NetBSD") {
+          libc.declareLazyFFI(SysFile,  "opendir",
+                              "__opendir30", ctypes.default_abi,
+                   /*return*/ Type.null_or_DIR_ptr,
+                   /*path*/   Type.path);
+       } else {
+          libc.declareLazyFFI(SysFile,  "opendir",
+                              "opendir", ctypes.default_abi,
+                    /*return*/ Type.null_or_DIR_ptr,
+                    /*path*/   Type.path);
+       }
+
+       libc.declareLazyFFI(SysFile,  "pread",
+                               "pread", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_ssize_t,
+                    /*fd*/     Type.fd,
+                    /*buf*/    Type.void_t.out_ptr,
+                    /*nbytes*/ Type.size_t,
+                    /*offset*/ Type.off_t);
+
+       libc.declareLazyFFI(SysFile,  "pwrite",
+                               "pwrite", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_ssize_t,
+                    /*fd*/     Type.fd,
+                    /*buf*/    Type.void_t.in_ptr,
+                    /*nbytes*/ Type.size_t,
+                    /*offset*/ Type.off_t);
+
+       libc.declareLazyFFI(SysFile,  "read",
+                              "read", ctypes.default_abi,
+                    /*return*/Type.negativeone_or_ssize_t,
+                    /*fd*/    Type.fd,
+                    /*buf*/   Type.void_t.out_ptr,
+                    /*nbytes*/Type.size_t);
+
+       libc.declareLazyFFI(SysFile,  "posix_fadvise",
+                               "posix_fadvise", ctypes.default_abi,
+                    /*return*/ Type.int,
+                    /*fd*/     Type.fd,
+                    /*offset*/ Type.off_t,
+                    /*len*/    Type.off_t,
+                    /*advise*/ Type.int);
+
+       if (Const._DARWIN_FEATURE_64_BIT_INODE) {
+         // Special case for MacOS X 10.5+
+         // Symbol name "readdir" still exists but is used for a
+         // deprecated function that does not match the
+         // constants of |Const|.
+         libc.declareLazyFFI(SysFile,  "readdir",
+                                "readdir$INODE64", ctypes.default_abi,
+                     /*return*/ Type.null_or_dirent_ptr,
+                      /*dir*/   Type.DIR.in_ptr); // For MacOS X
+       } else if (OS.Constants.Sys.Name == "NetBSD") {
+         libc.declareLazyFFI(SysFile,  "readdir",
+                                "__readdir30", ctypes.default_abi,
+                      /*return*/Type.null_or_dirent_ptr,
+                      /*dir*/   Type.DIR.in_ptr); // Other Unices
+       } else {
+         libc.declareLazyFFI(SysFile,  "readdir",
+                                "readdir", ctypes.default_abi,
+                      /*return*/Type.null_or_dirent_ptr,
+                      /*dir*/   Type.DIR.in_ptr); // Other Unices
+       }
+
+       libc.declareLazyFFI(SysFile,  "rename",
+                               "rename", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_nothing,
+                    /*old*/    Type.path,
+                    /*new*/    Type.path);
+
+       libc.declareLazyFFI(SysFile,  "rmdir",
+                               "rmdir", ctypes.default_abi,
+                    /*return*/ Type.int,
+                    /*path*/   Type.path);
+
+       libc.declareLazyFFI(SysFile,  "splice",
+                               "splice", ctypes.default_abi,
+                    /*return*/ Type.long,
+                    /*fd_in*/  Type.fd,
+                    /*off_in*/ Type.off_t.in_ptr,
+                    /*fd_out*/ Type.fd,
+                    /*off_out*/Type.off_t.in_ptr,
+                    /*len*/    Type.size_t,
+                    /*flags*/  Type.unsigned_int); // Linux/Android-specific
+
+       libc.declareLazyFFI(SysFile,  "statfs",
+                               "statfs", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_nothing,
+                    /*path*/   Type.path,
+                    /*buf*/    Type.statvfs.out_ptr); // Android,B2G
+
+       libc.declareLazyFFI(SysFile,  "statvfs",
+                               "statvfs", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_nothing,
+                    /*path*/   Type.path,
+                    /*buf*/    Type.statvfs.out_ptr); // Other platforms
+
+       libc.declareLazyFFI(SysFile,  "symlink",
+                               "symlink", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_nothing,
+                    /*source*/ Type.path,
+                    /*dest*/   Type.path);
+
+       libc.declareLazyFFI(SysFile,  "truncate",
+                              "truncate", ctypes.default_abi,
+                    /*return*/Type.negativeone_or_nothing,
+                    /*path*/  Type.path,
+                    /*length*/ Type.off_t);
+
+       libc.declareLazyFFI(SysFile,  "unlink",
+                           "unlink", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_nothing,
+                    /*path*/ Type.path);
+
+       libc.declareLazyFFI(SysFile,  "write",
+                           "write", ctypes.default_abi,
+                    /*return*/ Type.negativeone_or_ssize_t,
+                    /*fd*/     Type.fd,
+                    /*buf*/    Type.void_t.in_ptr,
+                    /*nbytes*/ Type.size_t);
+
+       // Weird cases that require special treatment
+
+       // OSes use a variety of hacks to differentiate between
+       // 32-bits and 64-bits versions of |stat|, |lstat|, |fstat|.
+       if (Const._DARWIN_FEATURE_64_BIT_INODE) {
+         // MacOS X 64-bits
+         libc.declareLazyFFI(SysFile,  "stat",
+                             "stat$INODE64", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "lstat",
+                             "lstat$INODE64", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "fstat",
+                             "fstat$INODE64", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.fd,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+       } else if (Const._STAT_VER != undefined) {
+         const ver = Const._STAT_VER;
+         let xstat_name, lxstat_name, fxstat_name;
+         if (OS.Constants.Sys.Name == "SunOS") {
+           // Solaris
+           xstat_name = "_xstat";
+           lxstat_name = "_lxstat";
+           fxstat_name = "_fxstat";
+         } else {
+           // Linux, all widths
+           xstat_name = "__xstat";
+           lxstat_name = "__lxstat";
+           fxstat_name = "__fxstat";
+         }
+
+         let Stat = {};
+         libc.declareLazyFFI(Stat,  "xstat",
+                             xstat_name, ctypes.default_abi,
+                      /*return*/    Type.negativeone_or_nothing,
+                      /*_stat_ver*/ Type.int,
+                      /*path*/      Type.path,
+                      /*buf*/       Type.stat.out_ptr);
+         libc.declareLazyFFI(Stat,  "lxstat",
+                             lxstat_name, ctypes.default_abi,
+                      /*return*/    Type.negativeone_or_nothing,
+                      /*_stat_ver*/ Type.int,
+                      /*path*/      Type.path,
+                      /*buf*/       Type.stat.out_ptr);
+         libc.declareLazyFFI(Stat, "fxstat",
+                             fxstat_name, ctypes.default_abi,
+                      /*return*/    Type.negativeone_or_nothing,
+                      /*_stat_ver*/ Type.int,
+                      /*fd*/        Type.fd,
+                      /*buf*/       Type.stat.out_ptr);
+
+
+         SysFile.stat = function stat(path, buf) {
+           return Stat.xstat(ver, path, buf);
+         };
+
+         SysFile.lstat = function lstat(path, buf) {
+           return Stat.lxstat(ver, path, buf);
+         };
+
+         SysFile.fstat = function fstat(fd, buf) {
+           return Stat.fxstat(ver, fd, buf);
+         };
+       } else if (OS.Constants.Sys.Name == "NetBSD") {
+         // NetBSD 5.0 and newer
+         libc.declareLazyFFI(SysFile,  "stat",
+                             "__stat50", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "lstat",
+                             "__lstat50", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "fstat",
+                             "__fstat50", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*fd*/     Type.fd,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+       } else {
+         // Mac OS X 32-bits, other Unix
+         libc.declareLazyFFI(SysFile,  "stat",
+                             "stat", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "lstat",
+                             "lstat", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*path*/   Type.path,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+         libc.declareLazyFFI(SysFile,  "fstat",
+                             "fstat", ctypes.default_abi,
+                      /*return*/ Type.negativeone_or_nothing,
+                      /*fd*/     Type.fd,
+                      /*buf*/    Type.stat.out_ptr
+                     );
+       }
+
+       // We cannot make a C array of CDataFinalizer, so
+       // pipe cannot be directly defined as a C function.
+
+       let Pipe = {};
+       libc.declareLazyFFI(Pipe, "_pipe",
+         "pipe", ctypes.default_abi,
+         /*return*/ Type.negativeone_or_nothing,
+         /*fds*/    new SharedAll.Type("two file descriptors",
+             ctypes.ArrayType(ctypes.int, 2)));
+
+       // A shared per-thread buffer used to communicate with |pipe|
+       let _pipebuf = new (ctypes.ArrayType(ctypes.int, 2))();
+
+       SysFile.pipe = function pipe(array) {
+         let result = Pipe._pipe(_pipebuf);
+         if (result == -1) {
+           return result;
+         }
+         array[0] = ctypes.CDataFinalizer(_pipebuf[0], SysFile._close);
+         array[1] = ctypes.CDataFinalizer(_pipebuf[1], SysFile._close);
+         return result;
+       };
+
+       if (OS.Constants.Sys.Name == "NetBSD") {
+           libc.declareLazyFFI(SysFile, "utimes",
+                               "__utimes50", ctypes.default_abi,
+                      /*return*/     Type.negativeone_or_nothing,
+                      /*path*/       Type.path,
+                      /*timeval[2]*/ Type.timevals.out_ptr
+                      );
+       } else {
+           libc.declareLazyFFI(SysFile, "utimes",
+                               "utimes", ctypes.default_abi,
+                      /*return*/     Type.negativeone_or_nothing,
+                      /*path*/       Type.path,
+                      /*timeval[2]*/ Type.timevals.out_ptr
+                      );
+       }
+       if (OS.Constants.Sys.Name == "NetBSD") {
+           libc.declareLazyFFI(SysFile, "futimes",
+                               "__futimes50", ctypes.default_abi,
+                      /*return*/     Type.negativeone_or_nothing,
+                      /*fd*/         Type.fd,
+                      /*timeval[2]*/ Type.timevals.out_ptr
+                      );
+       } else {
+           libc.declareLazyFFI(SysFile, "futimes",
+                               "futimes", ctypes.default_abi,
+                      /*return*/     Type.negativeone_or_nothing,
+                      /*fd*/         Type.fd,
+                      /*timeval[2]*/ Type.timevals.out_ptr
+                      );
+       }
+     };
+
+     exports.OS.Unix = {
+       File: {
+         _init: init
+       }
+     };
+   })(this);
+}