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 _LARGEFILE64_SOURCE /* ask for stat64 etc */
24 #define _POSIX_C_SOURCE 199506L /* for readdir_r */
36 #include "libguile/_scm.h"
37 #include "libguile/smob.h"
38 #include "libguile/feature.h"
39 #include "libguile/fports.h"
40 #include "libguile/private-gc.h" /* for SCM_MAX */
41 #include "libguile/iselect.h"
42 #include "libguile/strings.h"
43 #include "libguile/vectors.h"
44 #include "libguile/lang.h"
45 #include "libguile/dynwind.h"
47 #include "libguile/validate.h"
48 #include "libguile/filesys.h"
59 #ifdef TIME_WITH_SYS_TIME
60 # include <sys/time.h>
64 # include <sys/time.h>
74 #ifdef LIBC_H_WITH_UNISTD_H
78 #ifdef HAVE_SYS_SELECT_H
79 #include <sys/select.h>
86 #include <sys/types.h>
95 #if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
96 # include "win32-dirent.h"
97 # define NAMLEN(dirent) strlen((dirent)->d_name)
98 /* The following bits are per AC_HEADER_DIRENT doco in the autoconf manual */
101 # define NAMLEN(dirent) strlen((dirent)->d_name)
103 # define dirent direct
104 # define NAMLEN(dirent) (dirent)->d_namlen
106 # include <sys/ndir.h>
109 # include <sys/dir.h>
116 /* Ultrix has S_IFSOCK, but no S_ISSOCK. Ipe! */
117 #if defined (S_IFSOCK) && ! defined (S_ISSOCK)
118 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
121 /* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
122 compiler like BorlandC or MSVC has none of these macros defined. */
144 # define _S_IFIFO 0x1000 /* FIFO */
145 # define _S_IFCHR 0x2000 /* Character */
146 # define _S_IFBLK 0x3000 /* Block */
147 # define _S_IFDIR 0x4000 /* Directory */
148 # define _S_IFREG 0x8000 /* Regular */
149 # define _S_IFSOCK 0xC000 /* Socket */
170 # define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
171 # define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
172 # define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
173 # define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
174 # define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
175 # define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
177 #endif /* __MINGW32__ */
179 /* Some more definitions for the native Windows port. */
181 # define mkdir(path, mode) mkdir (path)
182 # define fsync(fd) _commit (fd)
183 # define fchmod(fd, mode) (-1)
184 #endif /* __MINGW32__ */
186 /* dirfd() returns the file descriptor underlying a "DIR*" directory stream.
187 Found on MacOS X for instance. The following definition is for Solaris
188 10, it's probably not right elsewhere, but that's ok, it shouldn't be
189 used elsewhere. Crib note: If we need more then gnulib has a dirfd.m4
190 figuring out how to get the fd (dirfd function, dirfd macro, dd_fd field,
193 #define dirfd(dirstream) ((dirstream)->dd_fd)
198 /* Two helper macros for an often used pattern */
200 #define STRING_SYSCALL(str,cstr,code) \
203 char *cstr = scm_to_locale_string (str); \
204 SCM_SYSCALL (code); \
205 eno = errno; free (cstr); errno = eno; \
208 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
211 char *cstr1, *cstr2; \
212 scm_dynwind_begin (0); \
213 cstr1 = scm_to_locale_string (str1); \
214 scm_dynwind_free (cstr1); \
215 cstr2 = scm_to_locale_string (str2); \
216 scm_dynwind_free (cstr2); \
217 SCM_SYSCALL (code); \
218 eno = errno; scm_dynwind_end (); errno = eno; \
227 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
228 (SCM object
, SCM owner
, SCM group
),
229 "Change the ownership and group of the file referred to by @var{object} to\n"
230 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
231 "a string containing a file name or, if the platform\n"
232 "supports fchown, a port or integer file descriptor\n"
233 "which is open on the file. The return value\n"
234 "is unspecified.\n\n"
235 "If @var{object} is a symbolic link, either the\n"
236 "ownership of the link or the ownership of the referenced file will be\n"
237 "changed depending on the operating system (lchown is\n"
238 "unsupported at present). If @var{owner} or @var{group} is specified\n"
239 "as @code{-1}, then that ID is not changed.")
240 #define FUNC_NAME s_scm_chown
244 object
= SCM_COERCE_OUTPORT (object
);
247 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
249 int fdes
= (SCM_OPFPORTP (object
)?
250 SCM_FPORT_FDES (object
) : scm_to_int (object
));
252 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
257 STRING_SYSCALL (object
, c_object
,
258 rv
= chown (c_object
,
259 scm_to_int (owner
), scm_to_int (group
)));
263 return SCM_UNSPECIFIED
;
266 #endif /* HAVE_CHOWN */
269 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
270 (SCM object
, SCM mode
),
271 "Changes the permissions of the file referred to by @var{obj}.\n"
272 "@var{obj} can be a string containing a file name or a port or integer file\n"
273 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
274 "as the underlying system call).\n"
275 "@var{mode} specifies\n"
276 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
277 "The return value is unspecified.")
278 #define FUNC_NAME s_scm_chmod
283 object
= SCM_COERCE_OUTPORT (object
);
285 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
287 if (scm_is_integer (object
))
288 fdes
= scm_to_int (object
);
290 fdes
= SCM_FPORT_FDES (object
);
291 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
295 STRING_SYSCALL (object
, c_object
,
296 rv
= chmod (c_object
, scm_to_int (mode
)));
300 return SCM_UNSPECIFIED
;
304 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
306 "If @var{mode} is omitted, returns a decimal number representing the current\n"
307 "file creation mask. Otherwise the file creation mask is set to\n"
308 "@var{mode} and the previous value is returned.\n\n"
309 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
310 #define FUNC_NAME s_scm_umask
313 if (SCM_UNBNDP (mode
))
320 mask
= umask (scm_to_uint (mode
));
322 return scm_from_uint (mask
);
328 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
329 (SCM path
, SCM flags
, SCM mode
),
330 "Similar to @code{open} but return a file descriptor instead of\n"
332 #define FUNC_NAME s_scm_open_fdes
338 iflags
= SCM_NUM2INT (2, flags
);
339 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
340 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
343 return scm_from_int (fd
);
347 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
348 (SCM path
, SCM flags
, SCM mode
),
349 "Open the file named by @var{path} for reading and/or writing.\n"
350 "@var{flags} is an integer specifying how the file should be opened.\n"
351 "@var{mode} is an integer specifying the permission bits of the file, if\n"
352 "it needs to be created, before the umask is applied. The default is 666\n"
353 "(Unix itself has no default).\n\n"
354 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
355 "Basic flags are:\n\n"
357 "Open the file read-only.\n"
360 "Open the file write-only.\n"
363 "Open the file read/write.\n"
366 "Append to the file instead of truncating.\n"
369 "Create the file if it does not already exist.\n"
371 "See the Unix documentation of the @code{open} system call\n"
372 "for additional flags.")
373 #define FUNC_NAME s_scm_open
380 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
381 iflags
= SCM_NUM2INT (2, flags
);
384 if (iflags
& O_APPEND
)
386 else if (iflags
& O_CREAT
)
392 if (iflags
& O_APPEND
)
394 else if (iflags
& O_WRONLY
)
399 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
404 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
406 "Similar to close-port (@pxref{Closing, close-port}),\n"
407 "but also works on file descriptors. A side\n"
408 "effect of closing a file descriptor is that any ports using that file\n"
409 "descriptor are moved to a different file descriptor and have\n"
410 "their revealed counts set to zero.")
411 #define FUNC_NAME s_scm_close
416 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
418 if (SCM_PORTP (fd_or_port
))
419 return scm_close_port (fd_or_port
);
420 fd
= scm_to_int (fd_or_port
);
421 scm_evict_ports (fd
); /* see scsh manual. */
422 SCM_SYSCALL (rv
= close (fd
));
423 /* following scsh, closing an already closed file descriptor is
425 if (rv
< 0 && errno
!= EBADF
)
427 return scm_from_bool (rv
>= 0);
431 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
433 "A simple wrapper for the @code{close} system call.\n"
434 "Close file descriptor @var{fd}, which must be an integer.\n"
435 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
436 "the file descriptor will be closed even if a port is using it.\n"
437 "The return value is unspecified.")
438 #define FUNC_NAME s_scm_close_fdes
443 c_fd
= scm_to_int (fd
);
444 SCM_SYSCALL (rv
= close (c_fd
));
447 return SCM_UNSPECIFIED
;
455 SCM_SYMBOL (scm_sym_regular
, "regular");
456 SCM_SYMBOL (scm_sym_directory
, "directory");
458 SCM_SYMBOL (scm_sym_symlink
, "symlink");
460 SCM_SYMBOL (scm_sym_block_special
, "block-special");
461 SCM_SYMBOL (scm_sym_char_special
, "char-special");
462 SCM_SYMBOL (scm_sym_fifo
, "fifo");
463 SCM_SYMBOL (scm_sym_sock
, "socket");
464 SCM_SYMBOL (scm_sym_unknown
, "unknown");
467 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
469 SCM ans
= scm_c_make_vector (15, SCM_UNSPECIFIED
);
471 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
472 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
473 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
474 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
475 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
476 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
477 #ifdef HAVE_STRUCT_STAT_ST_RDEV
478 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
480 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
482 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
483 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
484 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
485 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
486 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
487 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
489 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
491 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
492 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
494 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
497 int mode
= stat_temp
->st_mode
;
500 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
501 else if (S_ISDIR (mode
))
502 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
504 /* systems without symlinks probably don't have S_ISLNK */
505 else if (S_ISLNK (mode
))
506 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
508 else if (S_ISBLK (mode
))
509 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
510 else if (S_ISCHR (mode
))
511 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
512 else if (S_ISFIFO (mode
))
513 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
515 else if (S_ISSOCK (mode
))
516 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
519 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
521 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
523 /* the layout of the bits in ve[14] is intended to be portable.
524 If there are systems that don't follow the usual convention,
525 the following could be used:
528 if (S_ISUID & mode) tmp += 1;
530 if (S_IRGRP & mode) tmp += 1;
532 if (S_ISVTX & mode) tmp += 1;
534 if (S_IRUSR & mode) tmp += 1;
536 if (S_IWUSR & mode) tmp += 1;
538 if (S_IXUSR & mode) tmp += 1;
540 if (S_IWGRP & mode) tmp += 1;
542 if (S_IXGRP & mode) tmp += 1;
544 if (S_IROTH & mode) tmp += 1;
546 if (S_IWOTH & mode) tmp += 1;
548 if (S_IXOTH & mode) tmp += 1;
550 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
560 * Try getting the appropiate stat buffer for a given file descriptor
561 * under Windows. It differentiates between file, pipe and socket
564 static int fstat_Win32 (int fdes
, struct stat
*buf
)
566 int error
, optlen
= sizeof (int);
568 memset (buf
, 0, sizeof (struct stat
));
570 /* Is this a socket ? */
571 if (getsockopt (fdes
, SOL_SOCKET
, SO_ERROR
, (void *) &error
, &optlen
) >= 0)
573 buf
->st_mode
= _S_IFSOCK
| _S_IREAD
| _S_IWRITE
| _S_IEXEC
;
575 buf
->st_atime
= buf
->st_ctime
= buf
->st_mtime
= time (NULL
);
578 /* Maybe a regular file or pipe ? */
579 return fstat (fdes
, buf
);
581 #endif /* __MINGW32__ */
583 SCM_DEFINE (scm_stat
, "stat", 1, 0, 0,
585 "Return an object containing various information about the file\n"
586 "determined by @var{obj}. @var{obj} can be a string containing\n"
587 "a file name or a port or integer file descriptor which is open\n"
588 "on a file (in which case @code{fstat} is used as the underlying\n"
591 "The object returned by @code{stat} can be passed as a single\n"
592 "parameter to the following procedures, all of which return\n"
597 "The device containing the file.\n"
599 "The file serial number, which distinguishes this file from all\n"
600 "other files on the same device.\n"
602 "The mode of the file. This includes file type information and\n"
603 "the file permission bits. See @code{stat:type} and\n"
604 "@code{stat:perms} below.\n"
606 "The number of hard links to the file.\n"
608 "The user ID of the file's owner.\n"
610 "The group ID of the file.\n"
612 "Device ID; this entry is defined only for character or block\n"
615 "The size of a regular file in bytes.\n"
617 "The last access time for the file.\n"
619 "The last modification time for the file.\n"
621 "The last modification time for the attributes of the file.\n"
622 "@item stat:blksize\n"
623 "The optimal block size for reading or writing the file, in\n"
625 "@item stat:blocks\n"
626 "The amount of disk space that the file occupies measured in\n"
627 "units of 512 byte blocks.\n"
630 "In addition, the following procedures return the information\n"
631 "from stat:mode in a more convenient form:\n"
635 "A symbol representing the type of file. Possible values are\n"
636 "regular, directory, symlink, block-special, char-special, fifo,\n"
637 "socket and unknown\n"
639 "An integer representing the access permission bits.\n"
641 #define FUNC_NAME s_scm_stat
645 struct stat_or_stat64 stat_temp
;
647 if (scm_is_integer (object
))
650 SCM_SYSCALL (rv
= fstat_Win32 (scm_to_int (object
), &stat_temp
));
652 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
655 else if (scm_is_string (object
))
657 char *file
= scm_to_locale_string (object
);
660 p
= file
+ strlen (file
) - 1;
661 while (p
> file
&& (*p
== '/' || *p
== '\\'))
664 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
669 object
= SCM_COERCE_OUTPORT (object
);
670 SCM_VALIDATE_OPFPORT (1, object
);
671 fdes
= SCM_FPORT_FDES (object
);
673 SCM_SYSCALL (rv
= fstat_Win32 (fdes
, &stat_temp
));
675 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
683 SCM_SYSERROR_MSG ("~A: ~S",
684 scm_list_2 (scm_strerror (scm_from_int (en
)),
688 return scm_stat2scm (&stat_temp
);
693 /* {Modifying Directories}
697 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
698 (SCM oldpath
, SCM newpath
),
699 "Creates a new name @var{newpath} in the file system for the\n"
700 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
701 "link, the link may or may not be followed depending on the\n"
703 #define FUNC_NAME s_scm_link
707 STRING2_SYSCALL (oldpath
, c_oldpath
,
709 val
= link (c_oldpath
, c_newpath
));
712 return SCM_UNSPECIFIED
;
715 #endif /* HAVE_LINK */
718 #define my_rename rename
721 my_rename (const char *oldname
, const char *newname
)
725 SCM_SYSCALL (rv
= link (oldname
, newname
));
728 SCM_SYSCALL (rv
= unlink (oldname
));
730 /* unlink failed. remove new name */
731 SCM_SYSCALL (unlink (newname
));
737 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
738 (SCM oldname
, SCM newname
),
739 "Renames the file specified by @var{oldname} to @var{newname}.\n"
740 "The return value is unspecified.")
741 #define FUNC_NAME s_scm_rename
745 STRING2_SYSCALL (oldname
, c_oldname
,
747 rv
= my_rename (c_oldname
, c_newname
));
750 return SCM_UNSPECIFIED
;
755 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
757 "Deletes (or \"unlinks\") the file specified by @var{path}.")
758 #define FUNC_NAME s_scm_delete_file
761 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
764 return SCM_UNSPECIFIED
;
769 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
770 (SCM path
, SCM mode
),
771 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
772 "then the permissions of the directory file are set using the current\n"
773 "umask. Otherwise they are set to the decimal value specified with\n"
774 "@var{mode}. The return value is unspecified.")
775 #define FUNC_NAME s_scm_mkdir
780 if (SCM_UNBNDP (mode
))
784 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
788 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
792 return SCM_UNSPECIFIED
;
795 #endif /* HAVE_MKDIR */
798 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
800 "Remove the existing directory named by @var{path}. The directory must\n"
801 "be empty for this to succeed. The return value is unspecified.")
802 #define FUNC_NAME s_scm_rmdir
806 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
809 return SCM_UNSPECIFIED
;
816 /* {Examining Directories}
819 scm_t_bits scm_tc16_dir
;
822 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
824 "Return a boolean indicating whether @var{object} is a directory\n"
825 "stream as returned by @code{opendir}.")
826 #define FUNC_NAME s_scm_directory_stream_p
828 return scm_from_bool (SCM_DIRP (obj
));
833 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
835 "Open the directory specified by @var{path} and return a directory\n"
837 #define FUNC_NAME s_scm_opendir
840 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
843 SCM_RETURN_NEWSMOB (scm_tc16_dir
| SCM_DIR_FLAG_OPEN
, ds
);
848 /* FIXME: The glibc manual has a portability note that readdir_r may not
849 null-terminate its return string. The circumstances outlined for this
850 are not clear, nor is it clear what should be done about it. Lets use
851 NAMLEN and worry about what else should be done if/when someone can
854 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
856 "Return (as a string) the next directory entry from the directory stream\n"
857 "@var{stream}. If there is no remaining entry to be read then the\n"
858 "end of file object is returned.")
859 #define FUNC_NAME s_scm_readdir
861 struct dirent_or_dirent64
*rdent
;
863 SCM_VALIDATE_DIR (1, port
);
864 if (!SCM_DIR_OPEN_P (port
))
865 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
868 /* As noted in the glibc manual, on various systems (such as Solaris) the
869 d_name[] field is only 1 char and you're expected to size the dirent
870 buffer for readdir_r based on NAME_MAX. The SCM_MAX expressions below
871 effectively give either sizeof(d_name) or NAME_MAX+1, whichever is
874 On solaris 10 there's no NAME_MAX constant, it's necessary to use
875 pathconf(). We prefer NAME_MAX though, since it should be a constant
876 and will therefore save a system call. We also prefer it since dirfd()
877 is not available everywhere.
879 An alternative to dirfd() would be to open() the directory and then use
880 fdopendir(), if the latter is available. That'd let us hold the fd
881 somewhere in the smob, or just the dirent size calculated once. */
883 struct dirent_or_dirent64 de
; /* just for sizeof */
884 DIR *ds
= (DIR *) SCM_CELL_WORD_1 (port
);
887 char buf
[SCM_MAX (sizeof (de
),
888 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
891 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
894 buf
= alloca (SCM_MAX (sizeof (de
),
895 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
899 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
905 namlen
= NAMLEN (rdent
);
907 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
913 scm_dynwind_begin (0);
914 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
917 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_CELL_WORD_1 (port
)));
921 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
932 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
934 "Reset the directory port @var{stream} so that the next call to\n"
935 "@code{readdir} will return the first directory entry.")
936 #define FUNC_NAME s_scm_rewinddir
938 SCM_VALIDATE_DIR (1, port
);
939 if (!SCM_DIR_OPEN_P (port
))
940 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
942 rewinddir ((DIR *) SCM_CELL_WORD_1 (port
));
944 return SCM_UNSPECIFIED
;
949 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
951 "Close the directory stream @var{stream}.\n"
952 "The return value is unspecified.")
953 #define FUNC_NAME s_scm_closedir
955 SCM_VALIDATE_DIR (1, port
);
957 if (SCM_DIR_OPEN_P (port
))
961 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_CELL_WORD_1 (port
)));
965 SCM_SET_CELL_WORD_0 (port
, scm_tc16_dir
);
968 return SCM_UNSPECIFIED
;
974 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
976 scm_puts ("#<", port
);
977 if (!SCM_DIR_OPEN_P (exp
))
978 scm_puts ("closed: ", port
);
979 scm_puts ("directory stream ", port
);
980 scm_uintprint (SCM_CELL_WORD_1 (exp
), 16, port
);
981 scm_putc ('>', port
);
989 if (SCM_DIR_OPEN_P (p
))
990 closedir ((DIR *) SCM_CELL_WORD_1 (p
));
995 /* {Navigating Directories}
999 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
1001 "Change the current working directory to @var{path}.\n"
1002 "The return value is unspecified.")
1003 #define FUNC_NAME s_scm_chdir
1007 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
1010 return SCM_UNSPECIFIED
;
1015 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1017 "Return the name of the current working directory.")
1018 #define FUNC_NAME s_scm_getcwd
1025 wd
= scm_malloc (size
);
1026 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1030 wd
= scm_malloc (size
);
1034 int save_errno
= errno
;
1039 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1044 #endif /* HAVE_GETCWD */
1050 /* check that element is a port or file descriptor. if it's a port
1051 and its buffer is ready for use, add it to the ports_ready list.
1052 otherwise add its file descriptor to *set. the type of list can be
1053 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1054 SCM_ARG3 for excepts. */
1056 set_element (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM element
, int pos
)
1060 if (scm_is_integer (element
))
1062 fd
= scm_to_int (element
);
1068 element
= SCM_COERCE_OUTPORT (element
);
1069 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
1070 if (pos
== SCM_ARG1
)
1072 /* check whether port has buffered input. */
1073 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1075 if (pt
->read_pos
< pt
->read_end
)
1078 else if (pos
== SCM_ARG2
)
1080 /* check whether port's output buffer has room. */
1081 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1083 /* > 1 since writing the last byte in the buffer causes flush. */
1084 if (pt
->write_end
- pt
->write_pos
> 1)
1087 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
1090 *ports_ready
= scm_cons (element
, *ports_ready
);
1096 /* check list_or_vec, a list or vector of ports or file descriptors,
1097 adding each member to either the ports_ready list (if it's a port
1098 with a usable buffer) or to *set. the kind of list_or_vec can be
1099 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1100 SCM_ARG3 for excepts. */
1102 fill_select_type (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
1106 if (scm_is_simple_vector (list_or_vec
))
1108 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
1112 int fd
= set_element (set
, ports_ready
,
1113 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
1121 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1123 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
1127 list_or_vec
= SCM_CDR (list_or_vec
);
1134 /* if element (a file descriptor or port) appears in *set, cons it to
1135 list. return list. */
1137 get_element (SELECT_TYPE
*set
, SCM element
, SCM list
)
1141 if (scm_is_integer (element
))
1143 fd
= scm_to_int (element
);
1147 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
1149 if (FD_ISSET (fd
, set
))
1150 list
= scm_cons (element
, list
);
1154 /* construct component of scm_select return value.
1155 set: pointer to set of file descriptors found by select to be ready
1156 ports_ready: ports ready due to buffering
1157 list_or_vec: original list/vector handed to scm_select.
1158 the return value is a list/vector of ready ports/file descriptors.
1159 works by finding the objects in list which correspond to members of
1160 *set and appending them to ports_ready. result is converted to a
1161 vector if list_or_vec is a vector. */
1163 retrieve_select_type (SELECT_TYPE
*set
, SCM ports_ready
, SCM list_or_vec
)
1165 SCM answer_list
= ports_ready
;
1167 if (scm_is_simple_vector (list_or_vec
))
1169 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
1173 answer_list
= get_element (set
,
1174 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
1177 return scm_vector (answer_list
);
1181 /* list_or_vec must be a list. */
1182 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1184 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
1185 list_or_vec
= SCM_CDR (list_or_vec
);
1191 /* Static helper functions above refer to s_scm_select directly as s_select */
1192 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
1193 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
1194 "This procedure has a variety of uses: waiting for the ability\n"
1195 "to provide input, accept output, or the existence of\n"
1196 "exceptional conditions on a collection of ports or file\n"
1197 "descriptors, or waiting for a timeout to occur.\n"
1198 "It also returns if interrupted by a signal.\n\n"
1199 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
1200 "vectors, with each member a port or a file descriptor.\n"
1201 "The value returned is a list of three corresponding\n"
1202 "lists or vectors containing only the members which meet the\n"
1203 "specified requirement. The ability of port buffers to\n"
1204 "provide input or accept output is taken into account.\n"
1205 "Ordering of the input lists or vectors is not preserved.\n\n"
1206 "The optional arguments @var{secs} and @var{usecs} specify the\n"
1207 "timeout. Either @var{secs} can be specified alone, as\n"
1208 "either an integer or a real number, or both @var{secs} and\n"
1209 "@var{usecs} can be specified as integers, in which case\n"
1210 "@var{usecs} is an additional timeout expressed in\n"
1211 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
1212 "select will wait for as long as it takes for one of the other\n"
1213 "conditions to be satisfied.\n\n"
1214 "The scsh version of @code{select} differs as follows:\n"
1215 "Only vectors are accepted for the first three arguments.\n"
1216 "The @var{usecs} argument is not supported.\n"
1217 "Multiple values are returned instead of a list.\n"
1218 "Duplicates in the input vectors appear only once in output.\n"
1219 "An additional @code{select!} interface is provided.")
1220 #define FUNC_NAME s_scm_select
1222 struct timeval timeout
;
1223 struct timeval
* time_ptr
;
1224 SELECT_TYPE read_set
;
1225 SELECT_TYPE write_set
;
1226 SELECT_TYPE except_set
;
1230 /* these lists accumulate ports which are ready due to buffering.
1231 their file descriptors don't need to be added to the select sets. */
1232 SCM read_ports_ready
= SCM_EOL
;
1233 SCM write_ports_ready
= SCM_EOL
;
1236 if (scm_is_simple_vector (reads
))
1238 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
1242 read_count
= scm_ilength (reads
);
1243 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
1245 if (scm_is_simple_vector (writes
))
1247 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
1251 write_count
= scm_ilength (writes
);
1252 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
1254 if (scm_is_simple_vector (excepts
))
1256 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
1260 except_count
= scm_ilength (excepts
);
1261 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
1264 FD_ZERO (&read_set
);
1265 FD_ZERO (&write_set
);
1266 FD_ZERO (&except_set
);
1268 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
1271 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
1273 int except_max
= fill_select_type (&except_set
, NULL
,
1276 if (write_max
> max_fd
)
1278 if (except_max
> max_fd
)
1279 max_fd
= except_max
;
1282 /* if there's a port with a ready buffer, don't block, just
1283 check for ready file descriptors. */
1284 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
1287 timeout
.tv_usec
= 0;
1288 time_ptr
= &timeout
;
1290 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
1294 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
1296 timeout
.tv_sec
= scm_to_ulong (secs
);
1297 if (SCM_UNBNDP (usecs
))
1298 timeout
.tv_usec
= 0;
1300 timeout
.tv_usec
= scm_to_long (usecs
);
1304 double fl
= scm_to_double (secs
);
1306 if (!SCM_UNBNDP (usecs
))
1307 SCM_WRONG_TYPE_ARG (4, secs
);
1309 SCM_OUT_OF_RANGE (4, secs
);
1310 timeout
.tv_sec
= (long) fl
;
1311 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
1313 time_ptr
= &timeout
;
1317 int rv
= scm_std_select (max_fd
+ 1,
1318 &read_set
, &write_set
, &except_set
,
1323 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
1324 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
1325 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
1328 #endif /* HAVE_SELECT */
1333 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
1334 (SCM object
, SCM cmd
, SCM value
),
1335 "Apply @var{command} to the specified file descriptor or the underlying\n"
1336 "file descriptor of the specified port. @var{value} is an optional\n"
1337 "integer argument.\n\n"
1338 "Values for @var{command} are:\n\n"
1341 "Duplicate a file descriptor\n"
1343 "Get flags associated with the file descriptor.\n"
1345 "Set flags associated with the file descriptor to @var{value}.\n"
1347 "Get flags associated with the open file.\n"
1349 "Set flags associated with the open file to @var{value}\n"
1351 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
1353 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
1354 "@item FD_CLOEXEC\n"
1355 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
1358 #define FUNC_NAME s_scm_fcntl
1364 object
= SCM_COERCE_OUTPORT (object
);
1366 if (SCM_OPFPORTP (object
))
1367 fdes
= SCM_FPORT_FDES (object
);
1369 fdes
= scm_to_int (object
);
1371 if (SCM_UNBNDP (value
))
1374 ivalue
= scm_to_int (value
);
1376 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
1379 return scm_from_int (rv
);
1382 #endif /* HAVE_FCNTL */
1384 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
1386 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1387 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1388 "file descriptor is fsync'd.\n"
1389 "The return value is unspecified.")
1390 #define FUNC_NAME s_scm_fsync
1394 object
= SCM_COERCE_OUTPORT (object
);
1396 if (SCM_OPFPORTP (object
))
1399 fdes
= SCM_FPORT_FDES (object
);
1402 fdes
= scm_to_int (object
);
1404 if (fsync (fdes
) == -1)
1406 return SCM_UNSPECIFIED
;
1411 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1412 (SCM oldpath
, SCM newpath
),
1413 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1414 "@var{path-from}. The return value is unspecified.")
1415 #define FUNC_NAME s_scm_symlink
1419 STRING2_SYSCALL (oldpath
, c_oldpath
,
1421 val
= symlink (c_oldpath
, c_newpath
));
1424 return SCM_UNSPECIFIED
;
1427 #endif /* HAVE_SYMLINK */
1429 #ifdef HAVE_READLINK
1430 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1432 "Return the value of the symbolic link named by @var{path} (a\n"
1433 "string), i.e., the file that the link points to.")
1434 #define FUNC_NAME s_scm_readlink
1442 scm_dynwind_begin (0);
1444 c_path
= scm_to_locale_string (path
);
1445 scm_dynwind_free (c_path
);
1447 buf
= scm_malloc (size
);
1449 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1453 buf
= scm_malloc (size
);
1457 int save_errno
= errno
;
1462 result
= scm_take_locale_stringn (buf
, rv
);
1468 #endif /* HAVE_READLINK */
1471 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
1473 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
1474 "it will return information about a symbolic link itself, not the\n"
1475 "file it points to. @var{path} must be a string.")
1476 #define FUNC_NAME s_scm_lstat
1479 struct stat_or_stat64 stat_temp
;
1481 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
1486 SCM_SYSERROR_MSG ("~A: ~S",
1487 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
1490 return scm_stat2scm (&stat_temp
);
1493 #endif /* HAVE_LSTAT */
1495 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1496 (SCM oldfile
, SCM newfile
),
1497 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1498 "The return value is unspecified.")
1499 #define FUNC_NAME s_scm_copy_file
1501 char *c_oldfile
, *c_newfile
;
1505 struct stat_or_stat64 oldstat
;
1507 scm_dynwind_begin (0);
1509 c_oldfile
= scm_to_locale_string (oldfile
);
1510 scm_dynwind_free (c_oldfile
);
1511 c_newfile
= scm_to_locale_string (newfile
);
1512 scm_dynwind_free (c_newfile
);
1514 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
);
1519 SCM_SYSCALL (rv
= fstat_Win32 (oldfd
, &oldstat
));
1521 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1524 goto err_close_oldfd
;
1526 /* use POSIX flags instead of 07777?. */
1527 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1528 oldstat
.st_mode
& 07777);
1536 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1537 if (write (newfd
, buf
, n
) != n
)
1544 if (close (newfd
) == -1)
1548 return SCM_UNSPECIFIED
;
1553 /* Filename manipulation */
1557 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1559 "Return the directory name component of the file name\n"
1560 "@var{filename}. If @var{filename} does not contain a directory\n"
1561 "component, @code{.} is returned.")
1562 #define FUNC_NAME s_scm_dirname
1566 unsigned long int len
;
1568 SCM_VALIDATE_STRING (1, filename
);
1570 s
= scm_i_string_chars (filename
);
1571 len
= scm_i_string_length (filename
);
1575 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1576 while (i
>= 0 && (s
[i
] != '/' && s
[i
] != '\\')) --i
;
1577 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1579 while (i
>= 0 && s
[i
] == '/') --i
;
1580 while (i
>= 0 && s
[i
] != '/') --i
;
1581 while (i
>= 0 && s
[i
] == '/') --i
;
1582 #endif /* ndef __MINGW32__ */
1586 if (len
> 0 && (s
[0] == '/' || s
[0] == '\\'))
1588 if (len
> 0 && s
[0] == '/')
1589 #endif /* ndef __MINGW32__ */
1590 return scm_c_substring (filename
, 0, 1);
1592 return scm_dot_string
;
1595 return scm_c_substring (filename
, 0, i
+ 1);
1599 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1600 (SCM filename
, SCM suffix
),
1601 "Return the base name of the file name @var{filename}. The\n"
1602 "base name is the file name without any directory components.\n"
1603 "If @var{suffix} is provided, and is equal to the end of\n"
1604 "@var{basename}, it is removed also.")
1605 #define FUNC_NAME s_scm_basename
1607 const char *f
, *s
= 0;
1610 SCM_VALIDATE_STRING (1, filename
);
1611 f
= scm_i_string_chars (filename
);
1612 len
= scm_i_string_length (filename
);
1614 if (SCM_UNBNDP (suffix
))
1618 SCM_VALIDATE_STRING (2, suffix
);
1619 s
= scm_i_string_chars (suffix
);
1620 j
= scm_i_string_length (suffix
) - 1;
1624 while (i
>= 0 && (f
[i
] == '/' || f
[i
] == '\\')) --i
;
1626 while (i
>= 0 && f
[i
] == '/') --i
;
1627 #endif /* ndef __MINGW32__ */
1629 while (i
>= 0 && j
>= 0 && f
[i
] == s
[j
]) --i
, --j
;
1633 while (i
>= 0 && f
[i
] != '/' && f
[i
] != '\\') --i
;
1635 while (i
>= 0 && f
[i
] != '/') --i
;
1636 #endif /* ndef __MINGW32__ */
1640 if (len
> 0 && (f
[0] == '/' || f
[0] == '\\'))
1642 if (len
> 0 && f
[0] == '/')
1643 #endif /* ndef __MINGW32__ */
1644 return scm_c_substring (filename
, 0, 1);
1646 return scm_dot_string
;
1649 return scm_c_substring (filename
, i
+1, end
+1);
1660 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1661 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1662 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1664 scm_dot_string
= scm_permanent_object (scm_from_locale_string ("."));
1667 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1670 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1673 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1676 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1679 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1682 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1685 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1688 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1691 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1694 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1697 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1700 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1704 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1707 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1710 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1713 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1716 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1719 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1722 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1725 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1728 #include "libguile/filesys.x"