wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-19 06:47:35 +09:00
Code Issues Projects Releases Packages Wiki Activity
Dactyloidae/toolkit/components/osfile/modules/osfile_unix_back.jsm

736 lines
29 KiB
JavaScript
Raw Normal View History

import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
2018-01-19 03:59:58 +08:00
/* 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;
MoonchildProductions#1251 - Part 1: Restore initial Solaris support, fixed up. Compared with what Pale Moon had for Solaris originally, this is mostly the same zero point I started patching from, but I've made the following changes here after reviewing all this initial code I never looked at closely before. 1. In package-manifest.in for both Basilisk and Pale Moon, I've made the SPARC code for libfreebl not interefere with the x86 code, use the proper build flags, and also updated it to allow a SPARC64 build which is more likely to be used than the 32-bit SPARC code we had there. 2. See Mozilla bug #832272 and the old rules.mk patch from around Firefox 30 in oracle/solaris-userland. I believe they screwed up NSINSTALL on Solaris when they were trying to streamline the NSS buildsystem, because they started having unexplained issues with it around that time after Firefox 22 that they never properly resolved until Mozilla began building NSS with gyp files. I'm actually not even sure how relevant the thing they broke actually is to Solaris at this point, bug 665509 is so old it predates Firefox itself and goes back to the Mozilla suite days. I believe $(INSTALL) -t was wrong, and they meant $(NSINSTALL) -t because that makes more sense and is closer to what was there originally. It's what they have for WINNT, and it's possible a fix more like that could serve for Solaris as well. Alternatively, we could get rid of all these half-broken Makefiles and start building NSS with gyp files like Mozilla did. 3. I've completely cut out support for the Sun compiler and taken into account the reality that everyone builds Firefox (and therefore its forks) with GCC now on Solaris. This alone helped clean up a lot of the uglier parts of the code. 4. I've updated all remaining SOLARIS build flags to the newer XP_SOLARIS, because the SOLARIS flag is no longer set when building Solaris. 5. I've confirmed the workaround in gtxFontconfigFonts.cpp is no longer necessary. The Solaris people got impatient about implementing a half-baked patch for a fontconfig feature that wasn't ready yet back in 2009, and somehow convinced Mozilla to patch their software to work around it when really they should have just fixed or removed their broken fontconfig patch. The feature they wanted has since been implemented properly, and no version of Solaris still uses the broken patch that required this fix. If anyone had ever properly audited this code, it would have been removed a long time ago.
2019-10-01 06:07:31 -05:00
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";
}
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
2018-01-19 03:59:58 +08:00
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);
}
Reference in a new issue Copy permalink