1 /* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002, 2004, 2006 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 /* See stime.c for comments on why _POSIX_C_SOURCE is not always defined. */
22 #define _GNU_SOURCE /* ask glibc for everything */
23 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
25 #define _POSIX_C_SOURCE 199506L /* for readdir_r */
32 /* This blob per the Autoconf manual (under "Particular Functions"). */
35 #elif defined __GNUC__
36 # define alloca __builtin_alloca
38 # define alloca __alloca
39 #elif defined _MSC_VER
41 # define alloca _alloca
47 void *alloca (size_t);
53 #include "libguile/_scm.h"
54 #include "libguile/smob.h"
55 #include "libguile/feature.h"
56 #include "libguile/fports.h"
57 #include "libguile/private-gc.h" /* for SCM_MAX */
58 #include "libguile/iselect.h"
59 #include "libguile/strings.h"
60 #include "libguile/vectors.h"
61 #include "libguile/lang.h"
62 #include "libguile/dynwind.h"
64 #include "libguile/validate.h"
65 #include "libguile/filesys.h"
76 #ifdef TIME_WITH_SYS_TIME
77 # include <sys/time.h>
81 # include <sys/time.h>
91 #ifdef LIBC_H_WITH_UNISTD_H
95 #ifdef HAVE_SYS_SELECT_H
96 #include <sys/select.h>
103 #include <sys/types.h>
104 #include <sys/stat.h>
112 #if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
113 # include "win32-dirent.h"
114 # define NAMLEN(dirent) strlen((dirent)->d_name)
115 /* The following bits are per AC_HEADER_DIRENT doco in the autoconf manual */
118 # define NAMLEN(dirent) strlen((dirent)->d_name)
120 # define dirent direct
121 # define NAMLEN(dirent) (dirent)->d_namlen
123 # include <sys/ndir.h>
126 # include <sys/dir.h>
133 /* Ultrix has S_IFSOCK, but no S_ISSOCK. Ipe! */
134 #if defined (S_IFSOCK) && ! defined (S_ISSOCK)
135 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
138 /* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
139 compiler like BorlandC or MSVC has none of these macros defined. */
161 # define _S_IFIFO 0x1000 /* FIFO */
162 # define _S_IFCHR 0x2000 /* Character */
163 # define _S_IFBLK 0x3000 /* Block */
164 # define _S_IFDIR 0x4000 /* Directory */
165 # define _S_IFREG 0x8000 /* Regular */
166 # define _S_IFSOCK 0xC000 /* Socket */
187 # define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
188 # define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
189 # define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
190 # define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
191 # define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
192 # define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
194 #endif /* __MINGW32__ */
196 /* Some more definitions for the native Windows port. */
198 # define mkdir(path, mode) mkdir (path)
199 # define fsync(fd) _commit (fd)
200 # define fchmod(fd, mode) (-1)
201 #endif /* __MINGW32__ */
203 /* dirfd() returns the file descriptor underlying a "DIR*" directory stream.
204 Found on MacOS X for instance. The following definition is for Solaris
205 10, it's probably not right elsewhere, but that's ok, it shouldn't be
206 used elsewhere. Crib note: If we need more then gnulib has a dirfd.m4
207 figuring out how to get the fd (dirfd function, dirfd macro, dd_fd field,
210 #define dirfd(dirstream) ((dirstream)->dd_fd)
215 /* Two helper macros for an often used pattern */
217 #define STRING_SYSCALL(str,cstr,code) \
220 char *cstr = scm_to_locale_string (str); \
221 SCM_SYSCALL (code); \
222 eno = errno; free (cstr); errno = eno; \
225 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
228 char *cstr1, *cstr2; \
229 scm_dynwind_begin (0); \
230 cstr1 = scm_to_locale_string (str1); \
231 scm_dynwind_free (cstr1); \
232 cstr2 = scm_to_locale_string (str2); \
233 scm_dynwind_free (cstr2); \
234 SCM_SYSCALL (code); \
235 eno = errno; scm_dynwind_end (); errno = eno; \
244 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
245 (SCM object
, SCM owner
, SCM group
),
246 "Change the ownership and group of the file referred to by @var{object} to\n"
247 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
248 "a string containing a file name or, if the platform\n"
249 "supports fchown, a port or integer file descriptor\n"
250 "which is open on the file. The return value\n"
251 "is unspecified.\n\n"
252 "If @var{object} is a symbolic link, either the\n"
253 "ownership of the link or the ownership of the referenced file will be\n"
254 "changed depending on the operating system (lchown is\n"
255 "unsupported at present). If @var{owner} or @var{group} is specified\n"
256 "as @code{-1}, then that ID is not changed.")
257 #define FUNC_NAME s_scm_chown
261 object
= SCM_COERCE_OUTPORT (object
);
264 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
266 int fdes
= (SCM_OPFPORTP (object
)?
267 SCM_FPORT_FDES (object
) : scm_to_int (object
));
269 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
274 STRING_SYSCALL (object
, c_object
,
275 rv
= chown (c_object
,
276 scm_to_int (owner
), scm_to_int (group
)));
280 return SCM_UNSPECIFIED
;
283 #endif /* HAVE_CHOWN */
286 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
287 (SCM object
, SCM mode
),
288 "Changes the permissions of the file referred to by @var{obj}.\n"
289 "@var{obj} can be a string containing a file name or a port or integer file\n"
290 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
291 "as the underlying system call).\n"
292 "@var{mode} specifies\n"
293 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
294 "The return value is unspecified.")
295 #define FUNC_NAME s_scm_chmod
300 object
= SCM_COERCE_OUTPORT (object
);
302 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
304 if (scm_is_integer (object
))
305 fdes
= scm_to_int (object
);
307 fdes
= SCM_FPORT_FDES (object
);
308 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
312 STRING_SYSCALL (object
, c_object
,
313 rv
= chmod (c_object
, scm_to_int (mode
)));
317 return SCM_UNSPECIFIED
;
321 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
323 "If @var{mode} is omitted, returns a decimal number representing the current\n"
324 "file creation mask. Otherwise the file creation mask is set to\n"
325 "@var{mode} and the previous value is returned.\n\n"
326 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
327 #define FUNC_NAME s_scm_umask
330 if (SCM_UNBNDP (mode
))
337 mask
= umask (scm_to_uint (mode
));
339 return scm_from_uint (mask
);
345 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
346 (SCM path
, SCM flags
, SCM mode
),
347 "Similar to @code{open} but return a file descriptor instead of\n"
349 #define FUNC_NAME s_scm_open_fdes
355 iflags
= SCM_NUM2INT (2, flags
);
356 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
357 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
360 return scm_from_int (fd
);
364 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
365 (SCM path
, SCM flags
, SCM mode
),
366 "Open the file named by @var{path} for reading and/or writing.\n"
367 "@var{flags} is an integer specifying how the file should be opened.\n"
368 "@var{mode} is an integer specifying the permission bits of the file, if\n"
369 "it needs to be created, before the umask is applied. The default is 666\n"
370 "(Unix itself has no default).\n\n"
371 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
372 "Basic flags are:\n\n"
374 "Open the file read-only.\n"
377 "Open the file write-only.\n"
380 "Open the file read/write.\n"
383 "Append to the file instead of truncating.\n"
386 "Create the file if it does not already exist.\n"
388 "See the Unix documentation of the @code{open} system call\n"
389 "for additional flags.")
390 #define FUNC_NAME s_scm_open
397 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
398 iflags
= SCM_NUM2INT (2, flags
);
401 if (iflags
& O_APPEND
)
403 else if (iflags
& O_CREAT
)
409 if (iflags
& O_APPEND
)
411 else if (iflags
& O_WRONLY
)
416 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
421 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
423 "Similar to close-port (@pxref{Closing, close-port}),\n"
424 "but also works on file descriptors. A side\n"
425 "effect of closing a file descriptor is that any ports using that file\n"
426 "descriptor are moved to a different file descriptor and have\n"
427 "their revealed counts set to zero.")
428 #define FUNC_NAME s_scm_close
433 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
435 if (SCM_PORTP (fd_or_port
))
436 return scm_close_port (fd_or_port
);
437 fd
= scm_to_int (fd_or_port
);
438 scm_evict_ports (fd
); /* see scsh manual. */
439 SCM_SYSCALL (rv
= close (fd
));
440 /* following scsh, closing an already closed file descriptor is
442 if (rv
< 0 && errno
!= EBADF
)
444 return scm_from_bool (rv
>= 0);
448 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
450 "A simple wrapper for the @code{close} system call.\n"
451 "Close file descriptor @var{fd}, which must be an integer.\n"
452 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
453 "the file descriptor will be closed even if a port is using it.\n"
454 "The return value is unspecified.")
455 #define FUNC_NAME s_scm_close_fdes
460 c_fd
= scm_to_int (fd
);
461 SCM_SYSCALL (rv
= close (c_fd
));
464 return SCM_UNSPECIFIED
;
472 SCM_SYMBOL (scm_sym_regular
, "regular");
473 SCM_SYMBOL (scm_sym_directory
, "directory");
475 SCM_SYMBOL (scm_sym_symlink
, "symlink");
477 SCM_SYMBOL (scm_sym_block_special
, "block-special");
478 SCM_SYMBOL (scm_sym_char_special
, "char-special");
479 SCM_SYMBOL (scm_sym_fifo
, "fifo");
480 SCM_SYMBOL (scm_sym_sock
, "socket");
481 SCM_SYMBOL (scm_sym_unknown
, "unknown");
484 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
486 SCM ans
= scm_c_make_vector (15, SCM_UNSPECIFIED
);
488 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
489 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
490 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
491 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
492 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
493 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
494 #ifdef HAVE_STRUCT_STAT_ST_RDEV
495 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
497 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
499 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
500 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
501 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
502 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
503 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
504 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
506 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
508 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
509 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
511 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
514 int mode
= stat_temp
->st_mode
;
517 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
518 else if (S_ISDIR (mode
))
519 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
521 /* systems without symlinks probably don't have S_ISLNK */
522 else if (S_ISLNK (mode
))
523 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
525 else if (S_ISBLK (mode
))
526 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
527 else if (S_ISCHR (mode
))
528 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
529 else if (S_ISFIFO (mode
))
530 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
532 else if (S_ISSOCK (mode
))
533 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
536 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
538 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
540 /* the layout of the bits in ve[14] is intended to be portable.
541 If there are systems that don't follow the usual convention,
542 the following could be used:
545 if (S_ISUID & mode) tmp += 1;
547 if (S_IRGRP & mode) tmp += 1;
549 if (S_ISVTX & mode) tmp += 1;
551 if (S_IRUSR & mode) tmp += 1;
553 if (S_IWUSR & mode) tmp += 1;
555 if (S_IXUSR & mode) tmp += 1;
557 if (S_IWGRP & mode) tmp += 1;
559 if (S_IXGRP & mode) tmp += 1;
561 if (S_IROTH & mode) tmp += 1;
563 if (S_IWOTH & mode) tmp += 1;
565 if (S_IXOTH & mode) tmp += 1;
567 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
577 * Try getting the appropiate stat buffer for a given file descriptor
578 * under Windows. It differentiates between file, pipe and socket
581 static int fstat_Win32 (int fdes
, struct stat
*buf
)
583 int error
, optlen
= sizeof (int);
585 memset (buf
, 0, sizeof (struct stat
));
587 /* Is this a socket ? */
588 if (getsockopt (fdes
, SOL_SOCKET
, SO_ERROR
, (void *) &error
, &optlen
) >= 0)
590 buf
->st_mode
= _S_IFSOCK
| _S_IREAD
| _S_IWRITE
| _S_IEXEC
;
592 buf
->st_atime
= buf
->st_ctime
= buf
->st_mtime
= time (NULL
);
595 /* Maybe a regular file or pipe ? */
596 return fstat (fdes
, buf
);
598 #endif /* __MINGW32__ */
600 SCM_DEFINE (scm_stat
, "stat", 1, 0, 0,
602 "Return an object containing various information about the file\n"
603 "determined by @var{obj}. @var{obj} can be a string containing\n"
604 "a file name or a port or integer file descriptor which is open\n"
605 "on a file (in which case @code{fstat} is used as the underlying\n"
608 "The object returned by @code{stat} can be passed as a single\n"
609 "parameter to the following procedures, all of which return\n"
614 "The device containing the file.\n"
616 "The file serial number, which distinguishes this file from all\n"
617 "other files on the same device.\n"
619 "The mode of the file. This includes file type information and\n"
620 "the file permission bits. See @code{stat:type} and\n"
621 "@code{stat:perms} below.\n"
623 "The number of hard links to the file.\n"
625 "The user ID of the file's owner.\n"
627 "The group ID of the file.\n"
629 "Device ID; this entry is defined only for character or block\n"
632 "The size of a regular file in bytes.\n"
634 "The last access time for the file.\n"
636 "The last modification time for the file.\n"
638 "The last modification time for the attributes of the file.\n"
639 "@item stat:blksize\n"
640 "The optimal block size for reading or writing the file, in\n"
642 "@item stat:blocks\n"
643 "The amount of disk space that the file occupies measured in\n"
644 "units of 512 byte blocks.\n"
647 "In addition, the following procedures return the information\n"
648 "from stat:mode in a more convenient form:\n"
652 "A symbol representing the type of file. Possible values are\n"
653 "regular, directory, symlink, block-special, char-special, fifo,\n"
654 "socket and unknown\n"
656 "An integer representing the access permission bits.\n"
658 #define FUNC_NAME s_scm_stat
662 struct stat_or_stat64 stat_temp
;
664 if (scm_is_integer (object
))
667 SCM_SYSCALL (rv
= fstat_Win32 (scm_to_int (object
), &stat_temp
));
669 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
672 else if (scm_is_string (object
))
674 char *file
= scm_to_locale_string (object
);
677 p
= file
+ strlen (file
) - 1;
678 while (p
> file
&& (*p
== '/' || *p
== '\\'))
681 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
686 object
= SCM_COERCE_OUTPORT (object
);
687 SCM_VALIDATE_OPFPORT (1, object
);
688 fdes
= SCM_FPORT_FDES (object
);
690 SCM_SYSCALL (rv
= fstat_Win32 (fdes
, &stat_temp
));
692 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
700 SCM_SYSERROR_MSG ("~A: ~S",
701 scm_list_2 (scm_strerror (scm_from_int (en
)),
705 return scm_stat2scm (&stat_temp
);
710 /* {Modifying Directories}
714 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
715 (SCM oldpath
, SCM newpath
),
716 "Creates a new name @var{newpath} in the file system for the\n"
717 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
718 "link, the link may or may not be followed depending on the\n"
720 #define FUNC_NAME s_scm_link
724 STRING2_SYSCALL (oldpath
, c_oldpath
,
726 val
= link (c_oldpath
, c_newpath
));
729 return SCM_UNSPECIFIED
;
732 #endif /* HAVE_LINK */
735 #define my_rename rename
738 my_rename (const char *oldname
, const char *newname
)
742 SCM_SYSCALL (rv
= link (oldname
, newname
));
745 SCM_SYSCALL (rv
= unlink (oldname
));
747 /* unlink failed. remove new name */
748 SCM_SYSCALL (unlink (newname
));
754 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
755 (SCM oldname
, SCM newname
),
756 "Renames the file specified by @var{oldname} to @var{newname}.\n"
757 "The return value is unspecified.")
758 #define FUNC_NAME s_scm_rename
762 STRING2_SYSCALL (oldname
, c_oldname
,
764 rv
= my_rename (c_oldname
, c_newname
));
767 return SCM_UNSPECIFIED
;
772 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
774 "Deletes (or \"unlinks\") the file specified by @var{path}.")
775 #define FUNC_NAME s_scm_delete_file
778 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
781 return SCM_UNSPECIFIED
;
786 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
787 (SCM path
, SCM mode
),
788 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
789 "then the permissions of the directory file are set using the current\n"
790 "umask. Otherwise they are set to the decimal value specified with\n"
791 "@var{mode}. The return value is unspecified.")
792 #define FUNC_NAME s_scm_mkdir
797 if (SCM_UNBNDP (mode
))
801 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
805 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
809 return SCM_UNSPECIFIED
;
812 #endif /* HAVE_MKDIR */
815 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
817 "Remove the existing directory named by @var{path}. The directory must\n"
818 "be empty for this to succeed. The return value is unspecified.")
819 #define FUNC_NAME s_scm_rmdir
823 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
826 return SCM_UNSPECIFIED
;
833 /* {Examining Directories}
836 scm_t_bits scm_tc16_dir
;
839 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
841 "Return a boolean indicating whether @var{object} is a directory\n"
842 "stream as returned by @code{opendir}.")
843 #define FUNC_NAME s_scm_directory_stream_p
845 return scm_from_bool (SCM_DIRP (obj
));
850 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
852 "Open the directory specified by @var{path} and return a directory\n"
854 #define FUNC_NAME s_scm_opendir
857 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
860 SCM_RETURN_NEWSMOB (scm_tc16_dir
| SCM_DIR_FLAG_OPEN
, ds
);
865 /* FIXME: The glibc manual has a portability note that readdir_r may not
866 null-terminate its return string. The circumstances outlined for this
867 are not clear, nor is it clear what should be done about it. Lets use
868 NAMLEN and worry about what else should be done if/when someone can
871 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
873 "Return (as a string) the next directory entry from the directory stream\n"
874 "@var{stream}. If there is no remaining entry to be read then the\n"
875 "end of file object is returned.")
876 #define FUNC_NAME s_scm_readdir
878 struct dirent_or_dirent64
*rdent
;
880 SCM_VALIDATE_DIR (1, port
);
881 if (!SCM_DIR_OPEN_P (port
))
882 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
885 /* As noted in the glibc manual, on various systems (such as Solaris) the
886 d_name[] field is only 1 char and you're expected to size the dirent
887 buffer for readdir_r based on NAME_MAX. The SCM_MAX expressions below
888 effectively give either sizeof(d_name) or NAME_MAX+1, whichever is
891 On solaris 10 there's no NAME_MAX constant, it's necessary to use
892 pathconf(). We prefer NAME_MAX though, since it should be a constant
893 and will therefore save a system call. We also prefer it since dirfd()
894 is not available everywhere.
896 An alternative to dirfd() would be to open() the directory and then use
897 fdopendir(), if the latter is available. That'd let us hold the fd
898 somewhere in the smob, or just the dirent size calculated once. */
900 struct dirent_or_dirent64 de
; /* just for sizeof */
901 DIR *ds
= (DIR *) SCM_CELL_WORD_1 (port
);
904 char buf
[SCM_MAX (sizeof (de
),
905 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
908 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
911 buf
= alloca (SCM_MAX (sizeof (de
),
912 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
916 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
922 namlen
= NAMLEN (rdent
);
924 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
930 scm_dynwind_begin (0);
931 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
934 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_CELL_WORD_1 (port
)));
938 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
949 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
951 "Reset the directory port @var{stream} so that the next call to\n"
952 "@code{readdir} will return the first directory entry.")
953 #define FUNC_NAME s_scm_rewinddir
955 SCM_VALIDATE_DIR (1, port
);
956 if (!SCM_DIR_OPEN_P (port
))
957 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
959 rewinddir ((DIR *) SCM_CELL_WORD_1 (port
));
961 return SCM_UNSPECIFIED
;
966 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
968 "Close the directory stream @var{stream}.\n"
969 "The return value is unspecified.")
970 #define FUNC_NAME s_scm_closedir
972 SCM_VALIDATE_DIR (1, port
);
974 if (SCM_DIR_OPEN_P (port
))
978 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_CELL_WORD_1 (port
)));
982 SCM_SET_CELL_WORD_0 (port
, scm_tc16_dir
);
985 return SCM_UNSPECIFIED
;
991 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
993 scm_puts ("#<", port
);
994 if (!SCM_DIR_OPEN_P (exp
))
995 scm_puts ("closed: ", port
);
996 scm_puts ("directory stream ", port
);
997 scm_uintprint (SCM_CELL_WORD_1 (exp
), 16, port
);
998 scm_putc ('>', port
);
1004 scm_dir_free (SCM p
)
1006 if (SCM_DIR_OPEN_P (p
))
1007 closedir ((DIR *) SCM_CELL_WORD_1 (p
));
1012 /* {Navigating Directories}
1016 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
1018 "Change the current working directory to @var{path}.\n"
1019 "The return value is unspecified.")
1020 #define FUNC_NAME s_scm_chdir
1024 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
1027 return SCM_UNSPECIFIED
;
1032 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1034 "Return the name of the current working directory.")
1035 #define FUNC_NAME s_scm_getcwd
1042 wd
= scm_malloc (size
);
1043 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1047 wd
= scm_malloc (size
);
1051 int save_errno
= errno
;
1056 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1061 #endif /* HAVE_GETCWD */
1067 /* check that element is a port or file descriptor. if it's a port
1068 and its buffer is ready for use, add it to the ports_ready list.
1069 otherwise add its file descriptor to *set. the type of list can be
1070 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1071 SCM_ARG3 for excepts. */
1073 set_element (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM element
, int pos
)
1077 if (scm_is_integer (element
))
1079 fd
= scm_to_int (element
);
1085 element
= SCM_COERCE_OUTPORT (element
);
1086 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
1087 if (pos
== SCM_ARG1
)
1089 /* check whether port has buffered input. */
1090 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1092 if (pt
->read_pos
< pt
->read_end
)
1095 else if (pos
== SCM_ARG2
)
1097 /* check whether port's output buffer has room. */
1098 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1100 /* > 1 since writing the last byte in the buffer causes flush. */
1101 if (pt
->write_end
- pt
->write_pos
> 1)
1104 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
1107 *ports_ready
= scm_cons (element
, *ports_ready
);
1113 /* check list_or_vec, a list or vector of ports or file descriptors,
1114 adding each member to either the ports_ready list (if it's a port
1115 with a usable buffer) or to *set. the kind of list_or_vec can be
1116 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1117 SCM_ARG3 for excepts. */
1119 fill_select_type (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
1123 if (scm_is_simple_vector (list_or_vec
))
1125 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
1129 int fd
= set_element (set
, ports_ready
,
1130 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
1138 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1140 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
1144 list_or_vec
= SCM_CDR (list_or_vec
);
1151 /* if element (a file descriptor or port) appears in *set, cons it to
1152 list. return list. */
1154 get_element (SELECT_TYPE
*set
, SCM element
, SCM list
)
1158 if (scm_is_integer (element
))
1160 fd
= scm_to_int (element
);
1164 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
1166 if (FD_ISSET (fd
, set
))
1167 list
= scm_cons (element
, list
);
1171 /* construct component of scm_select return value.
1172 set: pointer to set of file descriptors found by select to be ready
1173 ports_ready: ports ready due to buffering
1174 list_or_vec: original list/vector handed to scm_select.
1175 the return value is a list/vector of ready ports/file descriptors.
1176 works by finding the objects in list which correspond to members of
1177 *set and appending them to ports_ready. result is converted to a
1178 vector if list_or_vec is a vector. */
1180 retrieve_select_type (SELECT_TYPE
*set
, SCM ports_ready
, SCM list_or_vec
)
1182 SCM answer_list
= ports_ready
;
1184 if (scm_is_simple_vector (list_or_vec
))
1186 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
1190 answer_list
= get_element (set
,
1191 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
1194 return scm_vector (answer_list
);
1198 /* list_or_vec must be a list. */
1199 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1201 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
1202 list_or_vec
= SCM_CDR (list_or_vec
);
1208 /* Static helper functions above refer to s_scm_select directly as s_select */
1209 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
1210 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
1211 "This procedure has a variety of uses: waiting for the ability\n"
1212 "to provide input, accept output, or the existence of\n"
1213 "exceptional conditions on a collection of ports or file\n"
1214 "descriptors, or waiting for a timeout to occur.\n"
1215 "It also returns if interrupted by a signal.\n\n"
1216 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
1217 "vectors, with each member a port or a file descriptor.\n"
1218 "The value returned is a list of three corresponding\n"
1219 "lists or vectors containing only the members which meet the\n"
1220 "specified requirement. The ability of port buffers to\n"
1221 "provide input or accept output is taken into account.\n"
1222 "Ordering of the input lists or vectors is not preserved.\n\n"
1223 "The optional arguments @var{secs} and @var{usecs} specify the\n"
1224 "timeout. Either @var{secs} can be specified alone, as\n"
1225 "either an integer or a real number, or both @var{secs} and\n"
1226 "@var{usecs} can be specified as integers, in which case\n"
1227 "@var{usecs} is an additional timeout expressed in\n"
1228 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
1229 "select will wait for as long as it takes for one of the other\n"
1230 "conditions to be satisfied.\n\n"
1231 "The scsh version of @code{select} differs as follows:\n"
1232 "Only vectors are accepted for the first three arguments.\n"
1233 "The @var{usecs} argument is not supported.\n"
1234 "Multiple values are returned instead of a list.\n"
1235 "Duplicates in the input vectors appear only once in output.\n"
1236 "An additional @code{select!} interface is provided.")
1237 #define FUNC_NAME s_scm_select
1239 struct timeval timeout
;
1240 struct timeval
* time_ptr
;
1241 SELECT_TYPE read_set
;
1242 SELECT_TYPE write_set
;
1243 SELECT_TYPE except_set
;
1247 /* these lists accumulate ports which are ready due to buffering.
1248 their file descriptors don't need to be added to the select sets. */
1249 SCM read_ports_ready
= SCM_EOL
;
1250 SCM write_ports_ready
= SCM_EOL
;
1253 if (scm_is_simple_vector (reads
))
1255 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
1259 read_count
= scm_ilength (reads
);
1260 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
1262 if (scm_is_simple_vector (writes
))
1264 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
1268 write_count
= scm_ilength (writes
);
1269 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
1271 if (scm_is_simple_vector (excepts
))
1273 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
1277 except_count
= scm_ilength (excepts
);
1278 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
1281 FD_ZERO (&read_set
);
1282 FD_ZERO (&write_set
);
1283 FD_ZERO (&except_set
);
1285 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
1288 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
1290 int except_max
= fill_select_type (&except_set
, NULL
,
1293 if (write_max
> max_fd
)
1295 if (except_max
> max_fd
)
1296 max_fd
= except_max
;
1299 /* if there's a port with a ready buffer, don't block, just
1300 check for ready file descriptors. */
1301 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
1304 timeout
.tv_usec
= 0;
1305 time_ptr
= &timeout
;
1307 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
1311 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
1313 timeout
.tv_sec
= scm_to_ulong (secs
);
1314 if (SCM_UNBNDP (usecs
))
1315 timeout
.tv_usec
= 0;
1317 timeout
.tv_usec
= scm_to_long (usecs
);
1321 double fl
= scm_to_double (secs
);
1323 if (!SCM_UNBNDP (usecs
))
1324 SCM_WRONG_TYPE_ARG (4, secs
);
1326 SCM_OUT_OF_RANGE (4, secs
);
1327 timeout
.tv_sec
= (long) fl
;
1328 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
1330 time_ptr
= &timeout
;
1334 int rv
= scm_std_select (max_fd
+ 1,
1335 &read_set
, &write_set
, &except_set
,
1340 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
1341 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
1342 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
1345 #endif /* HAVE_SELECT */
1350 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
1351 (SCM object
, SCM cmd
, SCM value
),
1352 "Apply @var{command} to the specified file descriptor or the underlying\n"
1353 "file descriptor of the specified port. @var{value} is an optional\n"
1354 "integer argument.\n\n"
1355 "Values for @var{command} are:\n\n"
1358 "Duplicate a file descriptor\n"
1360 "Get flags associated with the file descriptor.\n"
1362 "Set flags associated with the file descriptor to @var{value}.\n"
1364 "Get flags associated with the open file.\n"
1366 "Set flags associated with the open file to @var{value}\n"
1368 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
1370 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
1371 "@item FD_CLOEXEC\n"
1372 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
1375 #define FUNC_NAME s_scm_fcntl
1381 object
= SCM_COERCE_OUTPORT (object
);
1383 if (SCM_OPFPORTP (object
))
1384 fdes
= SCM_FPORT_FDES (object
);
1386 fdes
= scm_to_int (object
);
1388 if (SCM_UNBNDP (value
))
1391 ivalue
= scm_to_int (value
);
1393 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
1396 return scm_from_int (rv
);
1399 #endif /* HAVE_FCNTL */
1401 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
1403 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1404 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1405 "file descriptor is fsync'd.\n"
1406 "The return value is unspecified.")
1407 #define FUNC_NAME s_scm_fsync
1411 object
= SCM_COERCE_OUTPORT (object
);
1413 if (SCM_OPFPORTP (object
))
1416 fdes
= SCM_FPORT_FDES (object
);
1419 fdes
= scm_to_int (object
);
1421 if (fsync (fdes
) == -1)
1423 return SCM_UNSPECIFIED
;
1428 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1429 (SCM oldpath
, SCM newpath
),
1430 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1431 "@var{path-from}. The return value is unspecified.")
1432 #define FUNC_NAME s_scm_symlink
1436 STRING2_SYSCALL (oldpath
, c_oldpath
,
1438 val
= symlink (c_oldpath
, c_newpath
));
1441 return SCM_UNSPECIFIED
;
1444 #endif /* HAVE_SYMLINK */
1446 #ifdef HAVE_READLINK
1447 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1449 "Return the value of the symbolic link named by @var{path} (a\n"
1450 "string), i.e., the file that the link points to.")
1451 #define FUNC_NAME s_scm_readlink
1459 scm_dynwind_begin (0);
1461 c_path
= scm_to_locale_string (path
);
1462 scm_dynwind_free (c_path
);
1464 buf
= scm_malloc (size
);
1466 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1470 buf
= scm_malloc (size
);
1474 int save_errno
= errno
;
1479 result
= scm_take_locale_stringn (buf
, rv
);
1485 #endif /* HAVE_READLINK */
1488 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
1490 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
1491 "it will return information about a symbolic link itself, not the\n"
1492 "file it points to. @var{path} must be a string.")
1493 #define FUNC_NAME s_scm_lstat
1496 struct stat_or_stat64 stat_temp
;
1498 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
1503 SCM_SYSERROR_MSG ("~A: ~S",
1504 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
1507 return scm_stat2scm (&stat_temp
);
1510 #endif /* HAVE_LSTAT */
1512 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1513 (SCM oldfile
, SCM newfile
),
1514 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1515 "The return value is unspecified.")
1516 #define FUNC_NAME s_scm_copy_file
1518 char *c_oldfile
, *c_newfile
;
1522 struct stat_or_stat64 oldstat
;
1524 scm_dynwind_begin (0);
1526 c_oldfile
= scm_to_locale_string (oldfile
);
1527 scm_dynwind_free (c_oldfile
);
1528 c_newfile
= scm_to_locale_string (newfile
);
1529 scm_dynwind_free (c_newfile
);
1531 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
);
1536 SCM_SYSCALL (rv
= fstat_Win32 (oldfd
, &oldstat
));
1538 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1541 goto err_close_oldfd
;
1543 /* use POSIX flags instead of 07777?. */
1544 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1545 oldstat
.st_mode
& 07777);
1553 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1554 if (write (newfd
, buf
, n
) != n
)
1561 if (close (newfd
) == -1)
1565 return SCM_UNSPECIFIED
;
1570 /* Filename manipulation */
1574 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1576 "Return the directory name component of the file name\n"
1577 "@var{filename}. If @var{filename} does not contain a directory\n"
1578 "component, @code{.} is returned.")
1579 #define FUNC_NAME s_scm_dirname
1583 unsigned long int len
;
1585 SCM_VALIDATE_STRING (1, filename
);
1587 s
= scm_i_string_chars (filename
);
1588 len
= scm_i_string_length (filename
);
1592 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1593 while (i
>= 0 && (s
[i
] != '/' && s
[i
] != '\\')) --i
;
1594 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1596 while (i
>= 0 && s
[i
] == '/') --i
;
1597 while (i
>= 0 && s
[i
] != '/') --i
;
1598 while (i
>= 0 && s
[i
] == '/') --i
;
1599 #endif /* ndef __MINGW32__ */
1603 if (len
> 0 && (s
[0] == '/' || s
[0] == '\\'))
1605 if (len
> 0 && s
[0] == '/')
1606 #endif /* ndef __MINGW32__ */
1607 return scm_c_substring (filename
, 0, 1);
1609 return scm_dot_string
;
1612 return scm_c_substring (filename
, 0, i
+ 1);
1616 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1617 (SCM filename
, SCM suffix
),
1618 "Return the base name of the file name @var{filename}. The\n"
1619 "base name is the file name without any directory components.\n"
1620 "If @var{suffix} is provided, and is equal to the end of\n"
1621 "@var{basename}, it is removed also.")
1622 #define FUNC_NAME s_scm_basename
1624 const char *f
, *s
= 0;
1627 SCM_VALIDATE_STRING (1, filename
);
1628 f
= scm_i_string_chars (filename
);
1629 len
= scm_i_string_length (filename
);
1631 if (SCM_UNBNDP (suffix
))
1635 SCM_VALIDATE_STRING (2, suffix
);
1636 s
= scm_i_string_chars (suffix
);
1637 j
= scm_i_string_length (suffix
) - 1;
1641 while (i
>= 0 && (f
[i
] == '/' || f
[i
] == '\\')) --i
;
1643 while (i
>= 0 && f
[i
] == '/') --i
;
1644 #endif /* ndef __MINGW32__ */
1646 while (i
>= 0 && j
>= 0 && f
[i
] == s
[j
]) --i
, --j
;
1650 while (i
>= 0 && f
[i
] != '/' && f
[i
] != '\\') --i
;
1652 while (i
>= 0 && f
[i
] != '/') --i
;
1653 #endif /* ndef __MINGW32__ */
1657 if (len
> 0 && (f
[0] == '/' || f
[0] == '\\'))
1659 if (len
> 0 && f
[0] == '/')
1660 #endif /* ndef __MINGW32__ */
1661 return scm_c_substring (filename
, 0, 1);
1663 return scm_dot_string
;
1666 return scm_c_substring (filename
, i
+1, end
+1);
1677 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1678 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1679 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1681 scm_dot_string
= scm_permanent_object (scm_from_locale_string ("."));
1684 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1687 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1690 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1693 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1696 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1699 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1702 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1705 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1708 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1711 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1714 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1717 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1721 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1724 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1727 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1730 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1733 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1736 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1739 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1742 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1745 #include "libguile/filesys.x"