\f
;;;; Lisp types used by syscalls
-(deftype unix-pathname () 'simple-base-string)
+(deftype unix-pathname () 'simple-string)
(deftype unix-fd () `(integer 0 ,most-positive-fixnum))
(deftype unix-file-mode () '(unsigned-byte 32))
`(let (,value ,errno)
(loop (multiple-value-setq (,value ,errno)
,syscall-form)
- (unless (eql ,errno sb!unix:eintr)
+ (unless #!-win32 (eql ,errno sb!unix:eintr) #!+win32 nil
(return (values ,value ,errno))))
,@body))
+
+#!+win32
+(progn
+ (defconstant espipe 29)
+ ;; For stat-wrapper hack (different-type or non-existing win32 fields).
+ (define-alien-type nlink-t short)
+ (define-alien-type uid-t short)
+ (define-alien-type gid-t short))
\f
;;;; hacking the Unix environment
+#!-win32
(define-alien-routine ("getenv" posix-getenv) c-string
"Return the \"value\" part of the environment string \"name=value\" which
corresponds to NAME, or NIL if there is none."
;;; Rename the file with string NAME1 to the string NAME2. NIL and an
;;; error code is returned if an error occurs.
+#!-win32
(defun unix-rename (name1 name2)
(declare (type unix-pathname name1 name2))
(void-syscall ("rename" c-string c-string) name1 name2))
(declare (type unix-pathname path)
(type fixnum flags)
(type unix-file-mode mode))
- (int-syscall ("open" c-string int int) path flags mode))
+ (int-syscall ("open" c-string int int) path (logior #!+win32 o_binary flags) mode))
;;; UNIX-CLOSE accepts a file descriptor and attempts to close the file
;;; associated with it.
;;; w_ok Write permission.
;;; x_ok Execute permission.
;;; f_ok Presence of file.
+
+;;; In Windows, the MODE argument to access is defined in terms of
+;;; literal magic numbers---there are no constants to grovel. X_OK
+;;; is not defined.
+#!+win32
+(progn
+ (defconstant f_ok 0)
+ (defconstant w_ok 2)
+ (defconstant r_ok 4))
+
(defun unix-access (path mode)
(declare (type unix-pathname path)
(type (mod 8) mode))
;;; value is the pipe to be read from and the second is can be written
;;; to. If an error occurred the first value is NIL and the second the
;;; unix error code.
+#!-win32
(defun unix-pipe ()
(with-alien ((fds (array int 2)))
(syscall ("pipe" (* int))
(values (deref fds 0) (deref fds 1))
(cast fds (* int)))))
+#!+win32
+(defun msvcrt-raw-pipe (fds size mode)
+ (syscall ("_pipe" (* int) int int)
+ (values (deref fds 0) (deref fds 1))
+ (cast fds (* int)) size mode))
+#!+win32
+(defun unix-pipe ()
+ (with-alien ((fds (array int 2)))
+ (msvcrt-raw-pipe fds 256 o_binary)))
+;; Windows mkdir() doesn't take the mode argument. It's cdecl, so we could
+;; actually call it passing the mode argument, but some sharp-eyed reader
+;; would put five and twenty-seven together and ask us about it, so...
+;; -- AB, 2005-12-27
+#!-win32
(defun unix-mkdir (name mode)
(declare (type unix-pathname name)
- (type unix-file-mode mode))
- (void-syscall ("mkdir" c-string int) name mode))
+ (type unix-file-mode mode)
+ #!+win32 (ignore mode))
+ (void-syscall ("mkdir" c-string #!-win32 int) name #!-win32 mode))
;;; Given a C char* pointer allocated by malloc(), free it and return a
;;; corresponding Lisp string (or return NIL if the pointer is a C NULL).
;;; Return the Unix current directory as a SIMPLE-STRING, in the
;;; style returned by getcwd() (no trailing slash character).
+#!-win32
(defun posix-getcwd ()
;; This implementation relies on a BSD/Linux extension to getcwd()
;; behavior, automatically allocating memory when a null buffer
;; a constant. Going the grovel_headers route doesn't seem to be
;; helpful, either, as Solaris doesn't export PATH_MAX from
;; unistd.h.
- #!-(or linux openbsd freebsd netbsd sunos osf1 darwin) (,stub,)
- #!+(or linux openbsd freebsd netbsd sunos osf1 darwin)
+ ;;
+ ;; FIXME: The (,stub,) nastiness produces an error message about a
+ ;; comma not inside a backquote. This error has absolutely nothing
+ ;; to do with the actual meaning of the error (and little to do with
+ ;; its location, either).
+ #!-(or linux openbsd freebsd netbsd sunos osf1 darwin win32) (,stub,)
+ #!+(or linux openbsd freebsd netbsd sunos osf1 darwin win32)
(or (newcharstar-string (alien-funcall (extern-alien "getcwd"
(function (* char)
(* char)
size-t))
nil
- #!+(or linux openbsd freebsd netbsd darwin) 0
+ #!+(or linux openbsd freebsd netbsd darwin win32) 0
#!+(or sunos osf1) 1025))
(simple-perror "getcwd")))
(defun posix-getcwd/ ()
(concatenate 'string (posix-getcwd) "/"))
-;;; Convert at the UNIX level from a possibly relative filename to
-;;; an absolute filename.
-;;;
-;;; FIXME: Do we still need this even as we switch to
-;;; *DEFAULT-PATHNAME-DEFAULTS*? I think maybe we do, since it seems
-;;; to be valid for the user to set *DEFAULT-PATHNAME-DEFAULTS* to
-;;; have a NIL directory component, and then this'd be the only way to
-;;; interpret a relative directory specification. But I don't find the
-;;; ANSI pathname documentation to be a model of clarity. Maybe
-;;; someone who understands it better can take a look at this.. -- WHN
-(defun unix-maybe-prepend-current-directory (name)
- (declare (simple-string name))
- (if (and (> (length name) 0) (char= (schar name 0) #\/))
- name
- (concatenate 'simple-string (posix-getcwd/) name)))
-
;;; Duplicate an existing file descriptor (given as the argument) and
;;; return it. If FD is not a valid file descriptor, NIL and an error
;;; number are returned.
(define-alien-routine ("getpid" unix-getpid) int)
;;; Return the real user id associated with the current process.
+#!-win32
(define-alien-routine ("getuid" unix-getuid) int)
;;; Translate a user id into a login name.
+#!-win32
(defun uid-username (uid)
(or (newcharstar-string (alien-funcall (extern-alien "uid_username"
(function (* char) int))
;;; Return the namestring of the home directory, being careful to
;;; include a trailing #\/
+#!-win32
(defun uid-homedir (uid)
(or (newcharstar-string (alien-funcall (extern-alien "uid_homedir"
(function (* char) int))
;;; Invoke readlink(2) on the file name specified by PATH. Return
;;; (VALUES LINKSTRING NIL) on success, or (VALUES NIL ERRNO) on
;;; failure.
+#!-win32
(defun unix-readlink (path)
(declare (type unix-pathname path))
(with-alien ((ptr (* char)
(values (with-alien ((c-string c-string ptr)) c-string)
nil)
(free-alien ptr)))))
+#!+win32
+;; Win32 doesn't do links, but something likes to call this anyway.
+;; Something in this file, no less. But it only takes one result, so...
+(defun unix-readlink (path)
+ (declare (ignore path))
+ nil)
;;; UNIX-UNLINK accepts a name and deletes the directory entry for that
;;; name and the file if this is the last link.
(void-syscall ("unlink" c-string) name))
;;; Return the name of the host machine as a string.
+#!-win32
(defun unix-gethostname ()
(with-alien ((buf (array char 256)))
(syscall ("gethostname" (* char) int)
(cast buf c-string)
(cast buf (* char)) 256)))
+#!-win32
(defun unix-setsid ()
(int-syscall ("setsid")))
;;; UNIX-IOCTL performs a variety of operations on open i/o
;;; descriptors. See the UNIX Programmer's Manual for more
;;; information.
+#!-win32
(defun unix-ioctl (fd cmd arg)
(declare (type unix-fd fd)
(type (signed-byte 32) cmd))
;;; user time, and returns the seconds and microseconds as separate
;;; values.
#!-sb-fluid (declaim (inline unix-fast-getrusage))
+#!-win32
(defun unix-fast-getrusage (who)
(declare (values (member t)
(unsigned-byte 31) (integer 0 1000000)
;;; (rusage_self) or all of the terminated child processes
;;; (rusage_children). NIL and an error number is returned if the call
;;; fails.
+#!-win32
(defun unix-getrusage (who)
(with-alien ((usage (struct rusage)))
(syscall ("getrusage" int (* (struct rusage)))
(seconds-west sb!alien:int :out)
(daylight-savings-p sb!alien:boolean :out))
+#!-win32
(defun nanosleep (secs nsecs)
(with-alien ((req (struct timespec))
(rem (struct timespec)))
(defconstant itimer-virtual 1)
(defconstant itimer-prof 2)
+#!-win32
(defun unix-getitimer (which)
"Unix-getitimer returns the INTERVAL and VALUE slots of one of
three system timers (:real :virtual or :profile). On success,
(slot (slot itv 'it-value) 'tv-usec))
which (alien-sap (addr itv))))))
+#!-win32
(defun unix-setitimer (which int-secs int-usec val-secs val-usec)
" Unix-setitimer sets the INTERVAL and VALUE slots of one of
three system timers (:real :virtual or :profile). A SIGALRM signal
(defun unix-file-kind (name &optional check-for-links)
#!+sb-doc
"Return either :FILE, :DIRECTORY, :LINK, :SPECIAL, or NIL."
- (declare (simple-base-string name))
+ (declare (simple-string name))
(multiple-value-bind (res dev ino mode)
(if check-for-links (unix-lstat name) (unix-stat name))
(declare (type (or fixnum null) mode)
(let ((kind (logand mode s-ifmt)))
(cond ((eql kind s-ifdir) :directory)
((eql kind s-ifreg) :file)
+ #!-win32
((eql kind s-iflnk) :link)
(t :special))))))
;;; paths have been converted to absolute paths, so we don't need to
;;; try to handle any more generality than that.
(defun unix-resolve-links (pathname)
- (declare (type simple-base-string pathname))
+ (declare (type simple-string pathname))
+ ;; KLUDGE: The Win32 platform doesn't have symbolic links, so
+ ;; short-cut this computation (and the check for being an absolute
+ ;; unix pathname...)
+ #!+win32 (return-from unix-resolve-links pathname)
(aver (not (relative-unix-pathname? pathname)))
;; KLUDGE: readlink and lstat are unreliable if given symlinks
;; ending in slashes -- fix the issue here instead of waiting for
;; libc to change...
+ ;;
+ ;; but be careful! Must not strip the final slash from "/". (This
+ ;; adjustment might be a candidate for being transferred into the C
+ ;; code in a wrap_readlink() function, too.) CSR, 2006-01-18
(let ((len (length pathname)))
- (when (and (plusp len) (eql #\/ (schar pathname (1- len))))
+ (when (and (> len 1) (eql #\/ (schar pathname (1- len))))
(setf pathname (subseq pathname 0 (1- len)))))
(/noshow "entering UNIX-RESOLVE-LINKS")
(loop with previous-pathnames = nil do
:from-end t)))
(dir (subseq pathname 0 dir-len)))
(/noshow dir)
- (concatenate 'base-string dir link))
+ (concatenate 'string dir link))
link))))
(if (unix-file-kind new-pathname)
(setf pathname new-pathname)
(push pathname previous-pathnames))))
(defun unix-simplify-pathname (src)
- (declare (type simple-base-string src))
+ (declare (type simple-string src))
(let* ((src-len (length src))
- (dst (make-string src-len :element-type 'base-char))
+ (dst (make-string src-len :element-type 'character))
(dst-len 0)
(dots 0)
(last-slash nil))
(if prev-prev-slash
(setf dst-len (1+ prev-prev-slash))
(return-from unix-simplify-pathname
- (coerce "./" 'simple-base-string))))))))
+ (coerce "./" 'simple-string))))))))
(cond ((zerop dst-len)
"./")
((= dst-len src-len)
dst)
(t
(subseq dst 0 dst-len)))))
+
+\f
+;;; UNIX specific code, that has been cleanly separated from the
+;;; Windows build.
+#!-win32
+(progn
+ (defconstant micro-seconds-per-internal-time-unit
+ (/ 1000000 sb!xc:internal-time-units-per-second))
+
+ (declaim (inline system-internal-real-time system-internal-run-time))
+ (defun system-internal-real-time ()
+ (multiple-value-bind (ignore seconds useconds) (unix-gettimeofday)
+ (declare (ignore ignore) (type (unsigned-byte 32) seconds useconds))
+ (let ((uint (truncate useconds
+ micro-seconds-per-internal-time-unit)))
+ (declare (type (unsigned-byte 32) uint))
+ (+ (* seconds sb!xc:internal-time-units-per-second)
+ uint))))
+
+ (defun system-internal-run-time ()
+ (multiple-value-bind (ignore utime-sec utime-usec stime-sec stime-usec)
+ (unix-fast-getrusage rusage_self)
+ (declare (ignore ignore)
+ (type (unsigned-byte 31) utime-sec stime-sec)
+ ;; (Classic CMU CL had these (MOD 1000000) instead, but
+ ;; at least in Linux 2.2.12, the type doesn't seem to
+ ;; be documented anywhere and the observed behavior is
+ ;; to sometimes return 1000000 exactly.)
+ (type (integer 0 1000000) utime-usec stime-usec))
+ (let ((result (+ (* (+ utime-sec stime-sec)
+ sb!xc:internal-time-units-per-second)
+ (floor (+ utime-usec
+ stime-usec
+ (floor micro-seconds-per-internal-time-unit 2))
+ micro-seconds-per-internal-time-unit))))
+ result))))
\f
;;;; A magic constant for wait3().
;;;;
`(progn
,@(loop for index upfrom 0 below (/ fd-setsize sb!vm:n-machine-word-bits)
collect `(setf (deref (slot ,fd-set 'fds-bits) ,index) 0))))
+
projects / sbcl.git / blobdiff