/* 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_FRSIZE,
                        "f_frsize", 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);
}
