1 /* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002, 2004 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #define _GNU_SOURCE /* ask glibc for everything */
21 #define _POSIX_C_SOURCE 199506L /* for readdir_r elsewhere */
30 #include "libguile/_scm.h"
31 #include "libguile/smob.h"
32 #include "libguile/feature.h"
33 #include "libguile/fports.h"
34 #include "libguile/iselect.h"
35 #include "libguile/strings.h"
36 #include "libguile/vectors.h"
37 #include "libguile/lang.h"
39 #include "libguile/validate.h"
40 #include "libguile/filesys.h"
51 #ifdef TIME_WITH_SYS_TIME
52 # include <sys/time.h>
56 # include <sys/time.h>
66 #ifdef LIBC_H_WITH_UNISTD_H
70 #ifdef HAVE_SYS_SELECT_H
71 #include <sys/select.h>
78 #include <sys/types.h>
87 #if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
88 # include "win32-dirent.h"
89 # define NAMLEN(dirent) strlen((dirent)->d_name)
92 # define NAMLEN(dirent) strlen((dirent)->d_name)
94 # define dirent direct
95 # define NAMLEN(dirent) (dirent)->d_namlen
97 # include <sys/ndir.h>
100 # include <sys/dir.h>
107 /* Ultrix has S_IFSOCK, but no S_ISSOCK. Ipe! */
108 #if defined (S_IFSOCK) && ! defined (S_ISSOCK)
109 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
112 /* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
113 compiler like BorlandC or MSVC has none of these macros defined. */
135 # define _S_IFIFO 0x1000 /* FIFO */
136 # define _S_IFCHR 0x2000 /* Character */
137 # define _S_IFBLK 0x3000 /* Block */
138 # define _S_IFDIR 0x4000 /* Directory */
139 # define _S_IFREG 0x8000 /* Regular */
140 # define _S_IFSOCK 0xC000 /* Socket */
161 # define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
162 # define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
163 # define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
164 # define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
165 # define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
166 # define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
168 #endif /* __MINGW32__ */
170 /* Some more definitions for the native Windows port. */
172 # define mkdir(path, mode) mkdir (path)
173 # define fsync(fd) _commit (fd)
174 # define fchmod(fd, mode) (-1)
175 #endif /* __MINGW32__ */
185 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
186 (SCM object
, SCM owner
, SCM group
),
187 "Change the ownership and group of the file referred to by @var{object} to\n"
188 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
189 "a string containing a file name or, if the platform\n"
190 "supports fchown, a port or integer file descriptor\n"
191 "which is open on the file. The return value\n"
192 "is unspecified.\n\n"
193 "If @var{object} is a symbolic link, either the\n"
194 "ownership of the link or the ownership of the referenced file will be\n"
195 "changed depending on the operating system (lchown is\n"
196 "unsupported at present). If @var{owner} or @var{group} is specified\n"
197 "as @code{-1}, then that ID is not changed.")
198 #define FUNC_NAME s_scm_chown
202 object
= SCM_COERCE_OUTPORT (object
);
205 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
207 int fdes
= (SCM_OPFPORTP (object
)?
208 SCM_FPORT_FDES (object
) : scm_to_int (object
));
210 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
215 SCM_VALIDATE_STRING (1, object
);
216 SCM_SYSCALL (rv
= chown (SCM_STRING_CHARS (object
),
217 scm_to_int (owner
), scm_to_int (group
)));
221 return SCM_UNSPECIFIED
;
224 #endif /* HAVE_CHOWN */
227 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
228 (SCM object
, SCM mode
),
229 "Changes the permissions of the file referred to by @var{obj}.\n"
230 "@var{obj} can be a string containing a file name or a port or integer file\n"
231 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
232 "as the underlying system call).\n"
233 "@var{mode} specifies\n"
234 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
235 "The return value is unspecified.")
236 #define FUNC_NAME s_scm_chmod
241 object
= SCM_COERCE_OUTPORT (object
);
243 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
245 if (scm_is_integer (object
))
246 fdes
= scm_to_int (object
);
248 fdes
= SCM_FPORT_FDES (object
);
249 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
253 SCM_VALIDATE_STRING (1, object
);
254 SCM_SYSCALL (rv
= chmod (SCM_STRING_CHARS (object
), scm_to_int (mode
)));
258 return SCM_UNSPECIFIED
;
262 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
264 "If @var{mode} is omitted, returns a decimal number representing the current\n"
265 "file creation mask. Otherwise the file creation mask is set to\n"
266 "@var{mode} and the previous value is returned.\n\n"
267 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
268 #define FUNC_NAME s_scm_umask
271 if (SCM_UNBNDP (mode
))
278 mask
= umask (scm_to_uint (mode
));
280 return scm_from_uint (mask
);
286 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
287 (SCM path
, SCM flags
, SCM mode
),
288 "Similar to @code{open} but return a file descriptor instead of\n"
290 #define FUNC_NAME s_scm_open_fdes
296 SCM_VALIDATE_STRING (1, path
);
297 iflags
= SCM_NUM2INT (2, flags
);
298 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
299 SCM_SYSCALL (fd
= open (SCM_STRING_CHARS (path
), iflags
, imode
));
302 return scm_from_int (fd
);
306 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
307 (SCM path
, SCM flags
, SCM mode
),
308 "Open the file named by @var{path} for reading and/or writing.\n"
309 "@var{flags} is an integer specifying how the file should be opened.\n"
310 "@var{mode} is an integer specifying the permission bits of the file, if\n"
311 "it needs to be created, before the umask is applied. The default is 666\n"
312 "(Unix itself has no default).\n\n"
313 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
314 "Basic flags are:\n\n"
316 "Open the file read-only.\n"
319 "Open the file write-only.\n"
322 "Open the file read/write.\n"
325 "Append to the file instead of truncating.\n"
328 "Create the file if it does not already exist.\n"
330 "See the Unix documentation of the @code{open} system call\n"
331 "for additional flags.")
332 #define FUNC_NAME s_scm_open
339 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
340 iflags
= SCM_NUM2INT (2, flags
);
343 if (iflags
& O_APPEND
)
345 else if (iflags
& O_CREAT
)
351 if (iflags
& O_APPEND
)
353 else if (iflags
& O_WRONLY
)
358 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
363 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
365 "Similar to close-port (@pxref{Closing, close-port}),\n"
366 "but also works on file descriptors. A side\n"
367 "effect of closing a file descriptor is that any ports using that file\n"
368 "descriptor are moved to a different file descriptor and have\n"
369 "their revealed counts set to zero.")
370 #define FUNC_NAME s_scm_close
375 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
377 if (SCM_PORTP (fd_or_port
))
378 return scm_close_port (fd_or_port
);
379 fd
= scm_to_int (fd_or_port
);
380 scm_evict_ports (fd
); /* see scsh manual. */
381 SCM_SYSCALL (rv
= close (fd
));
382 /* following scsh, closing an already closed file descriptor is
384 if (rv
< 0 && errno
!= EBADF
)
386 return scm_from_bool (rv
>= 0);
390 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
392 "A simple wrapper for the @code{close} system call.\n"
393 "Close file descriptor @var{fd}, which must be an integer.\n"
394 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
395 "the file descriptor will be closed even if a port is using it.\n"
396 "The return value is unspecified.")
397 #define FUNC_NAME s_scm_close_fdes
402 c_fd
= scm_to_int (fd
);
403 SCM_SYSCALL (rv
= close (c_fd
));
406 return SCM_UNSPECIFIED
;
414 SCM_SYMBOL (scm_sym_regular
, "regular");
415 SCM_SYMBOL (scm_sym_directory
, "directory");
417 SCM_SYMBOL (scm_sym_symlink
, "symlink");
419 SCM_SYMBOL (scm_sym_block_special
, "block-special");
420 SCM_SYMBOL (scm_sym_char_special
, "char-special");
421 SCM_SYMBOL (scm_sym_fifo
, "fifo");
422 SCM_SYMBOL (scm_sym_sock
, "socket");
423 SCM_SYMBOL (scm_sym_unknown
, "unknown");
426 scm_stat2scm (struct stat
*stat_temp
)
428 SCM ans
= scm_c_make_vector (15, SCM_UNSPECIFIED
);
430 SCM_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
431 SCM_VECTOR_SET(ans
, 1, scm_from_ulong (stat_temp
->st_ino
));
432 SCM_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
433 SCM_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
434 SCM_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
435 SCM_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
436 #ifdef HAVE_STRUCT_STAT_ST_RDEV
437 SCM_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
439 SCM_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
441 SCM_VECTOR_SET(ans
, 7, scm_from_ulong (stat_temp
->st_size
));
442 SCM_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
443 SCM_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
444 SCM_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
445 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
446 SCM_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
448 SCM_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
450 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
451 SCM_VECTOR_SET(ans
, 12, scm_from_ulong (stat_temp
->st_blocks
));
453 SCM_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
456 int mode
= stat_temp
->st_mode
;
459 SCM_VECTOR_SET(ans
, 13, scm_sym_regular
);
460 else if (S_ISDIR (mode
))
461 SCM_VECTOR_SET(ans
, 13, scm_sym_directory
);
463 else if (S_ISLNK (mode
))
464 SCM_VECTOR_SET(ans
, 13, scm_sym_symlink
);
466 else if (S_ISBLK (mode
))
467 SCM_VECTOR_SET(ans
, 13, scm_sym_block_special
);
468 else if (S_ISCHR (mode
))
469 SCM_VECTOR_SET(ans
, 13, scm_sym_char_special
);
470 else if (S_ISFIFO (mode
))
471 SCM_VECTOR_SET(ans
, 13, scm_sym_fifo
);
473 else if (S_ISSOCK (mode
))
474 SCM_VECTOR_SET(ans
, 13, scm_sym_sock
);
477 SCM_VECTOR_SET(ans
, 13, scm_sym_unknown
);
479 SCM_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
481 /* the layout of the bits in ve[14] is intended to be portable.
482 If there are systems that don't follow the usual convention,
483 the following could be used:
486 if (S_ISUID & mode) tmp += 1;
488 if (S_IRGRP & mode) tmp += 1;
490 if (S_ISVTX & mode) tmp += 1;
492 if (S_IRUSR & mode) tmp += 1;
494 if (S_IWUSR & mode) tmp += 1;
496 if (S_IXUSR & mode) tmp += 1;
498 if (S_IWGRP & mode) tmp += 1;
500 if (S_IXGRP & mode) tmp += 1;
502 if (S_IROTH & mode) tmp += 1;
504 if (S_IWOTH & mode) tmp += 1;
506 if (S_IXOTH & mode) tmp += 1;
508 SCM_VECTOR_SET(ans, 14, scm_from_int (tmp));
518 * Try getting the appropiate stat buffer for a given file descriptor
519 * under Windows. It differentiates between file, pipe and socket
522 static int fstat_Win32 (int fdes
, struct stat
*buf
)
524 int error
, optlen
= sizeof (int);
526 memset (buf
, 0, sizeof (struct stat
));
528 /* Is this a socket ? */
529 if (getsockopt (fdes
, SOL_SOCKET
, SO_ERROR
, (void *) &error
, &optlen
) >= 0)
531 buf
->st_mode
= _S_IFSOCK
| _S_IREAD
| _S_IWRITE
| _S_IEXEC
;
533 buf
->st_atime
= buf
->st_ctime
= buf
->st_mtime
= time (NULL
);
536 /* Maybe a regular file or pipe ? */
537 return fstat (fdes
, buf
);
539 #endif /* __MINGW32__ */
541 SCM_DEFINE (scm_stat
, "stat", 1, 0, 0,
543 "Return an object containing various information about the file\n"
544 "determined by @var{obj}. @var{obj} can be a string containing\n"
545 "a file name or a port or integer file descriptor which is open\n"
546 "on a file (in which case @code{fstat} is used as the underlying\n"
549 "The object returned by @code{stat} can be passed as a single\n"
550 "parameter to the following procedures, all of which return\n"
555 "The device containing the file.\n"
557 "The file serial number, which distinguishes this file from all\n"
558 "other files on the same device.\n"
560 "The mode of the file. This includes file type information and\n"
561 "the file permission bits. See @code{stat:type} and\n"
562 "@code{stat:perms} below.\n"
564 "The number of hard links to the file.\n"
566 "The user ID of the file's owner.\n"
568 "The group ID of the file.\n"
570 "Device ID; this entry is defined only for character or block\n"
573 "The size of a regular file in bytes.\n"
575 "The last access time for the file.\n"
577 "The last modification time for the file.\n"
579 "The last modification time for the attributes of the file.\n"
580 "@item stat:blksize\n"
581 "The optimal block size for reading or writing the file, in\n"
583 "@item stat:blocks\n"
584 "The amount of disk space that the file occupies measured in\n"
585 "units of 512 byte blocks.\n"
588 "In addition, the following procedures return the information\n"
589 "from stat:mode in a more convenient form:\n"
593 "A symbol representing the type of file. Possible values are\n"
594 "regular, directory, symlink, block-special, char-special, fifo,\n"
595 "socket and unknown\n"
597 "An integer representing the access permission bits.\n"
599 #define FUNC_NAME s_scm_stat
603 struct stat stat_temp
;
605 if (scm_is_integer (object
))
608 SCM_SYSCALL (rv
= fstat_Win32 (scm_to_int (object
), &stat_temp
));
610 SCM_SYSCALL (rv
= fstat (scm_to_int (object
), &stat_temp
));
613 else if (SCM_STRINGP (object
))
616 char *p
, *file
= strdup (SCM_STRING_CHARS (object
));
617 p
= file
+ strlen (file
) - 1;
618 while (p
> file
&& (*p
== '/' || *p
== '\\'))
620 SCM_SYSCALL (rv
= stat (file
, &stat_temp
));
623 SCM_SYSCALL (rv
= stat (SCM_STRING_CHARS (object
), &stat_temp
));
628 object
= SCM_COERCE_OUTPORT (object
);
629 SCM_VALIDATE_OPFPORT (1, object
);
630 fdes
= SCM_FPORT_FDES (object
);
632 SCM_SYSCALL (rv
= fstat_Win32 (fdes
, &stat_temp
));
634 SCM_SYSCALL (rv
= fstat (fdes
, &stat_temp
));
642 SCM_SYSERROR_MSG ("~A: ~S",
643 scm_list_2 (scm_strerror (scm_from_int (en
)),
647 return scm_stat2scm (&stat_temp
);
652 /* {Modifying Directories}
656 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
657 (SCM oldpath
, SCM newpath
),
658 "Creates a new name @var{newpath} in the file system for the\n"
659 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
660 "link, the link may or may not be followed depending on the\n"
662 #define FUNC_NAME s_scm_link
666 SCM_VALIDATE_STRING (1, oldpath
);
667 SCM_VALIDATE_STRING (2, newpath
);
668 SCM_SYSCALL (val
= link (SCM_STRING_CHARS (oldpath
),
669 SCM_STRING_CHARS (newpath
)));
672 return SCM_UNSPECIFIED
;
675 #endif /* HAVE_LINK */
679 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
680 (SCM oldname
, SCM newname
),
681 "Renames the file specified by @var{oldname} to @var{newname}.\n"
682 "The return value is unspecified.")
683 #define FUNC_NAME s_scm_rename
686 SCM_VALIDATE_STRING (1, oldname
);
687 SCM_VALIDATE_STRING (2, newname
);
689 SCM_SYSCALL (rv
= rename (SCM_STRING_CHARS (oldname
), SCM_STRING_CHARS (newname
)));
691 SCM_SYSCALL (rv
= link (SCM_STRING_CHARS (oldname
), SCM_STRING_CHARS (newname
)));
694 SCM_SYSCALL (rv
= unlink (SCM_STRING_CHARS (oldname
)));;
696 /* unlink failed. remove new name */
697 SCM_SYSCALL (unlink (SCM_STRING_CHARS (newname
)));
702 return SCM_UNSPECIFIED
;
707 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
709 "Deletes (or \"unlinks\") the file specified by @var{path}.")
710 #define FUNC_NAME s_scm_delete_file
713 SCM_VALIDATE_STRING (1, str
);
714 SCM_SYSCALL (ans
= unlink (SCM_STRING_CHARS (str
)));
717 return SCM_UNSPECIFIED
;
722 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
723 (SCM path
, SCM mode
),
724 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
725 "then the permissions of the directory file are set using the current\n"
726 "umask. Otherwise they are set to the decimal value specified with\n"
727 "@var{mode}. The return value is unspecified.")
728 #define FUNC_NAME s_scm_mkdir
732 SCM_VALIDATE_STRING (1, path
);
733 if (SCM_UNBNDP (mode
))
737 SCM_SYSCALL (rv
= mkdir (SCM_STRING_CHARS (path
), 0777 ^ mask
));
741 SCM_SYSCALL (rv
= mkdir (SCM_STRING_CHARS (path
), scm_to_uint (mode
)));
745 return SCM_UNSPECIFIED
;
748 #endif /* HAVE_MKDIR */
751 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
753 "Remove the existing directory named by @var{path}. The directory must\n"
754 "be empty for this to succeed. The return value is unspecified.")
755 #define FUNC_NAME s_scm_rmdir
759 SCM_VALIDATE_STRING (1, path
);
760 SCM_SYSCALL (val
= rmdir (SCM_STRING_CHARS (path
)));
763 return SCM_UNSPECIFIED
;
770 /* {Examining Directories}
773 scm_t_bits scm_tc16_dir
;
776 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
778 "Return a boolean indicating whether @var{object} is a directory\n"
779 "stream as returned by @code{opendir}.")
780 #define FUNC_NAME s_scm_directory_stream_p
782 return scm_from_bool (SCM_DIRP (obj
));
787 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
789 "Open the directory specified by @var{path} and return a directory\n"
791 #define FUNC_NAME s_scm_opendir
794 SCM_VALIDATE_STRING (1, dirname
);
795 SCM_SYSCALL (ds
= opendir (SCM_STRING_CHARS (dirname
)));
798 SCM_RETURN_NEWSMOB (scm_tc16_dir
| SCM_DIR_FLAG_OPEN
, ds
);
803 /* FIXME: The glibc manual has a portability note that readdir_r may not
804 null-terminate its return string. The circumstances outlined for this
805 are not clear, nor is it clear what should be done about it. Lets worry
806 about this if/when someone can figure it out. */
808 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
810 "Return (as a string) the next directory entry from the directory stream\n"
811 "@var{stream}. If there is no remaining entry to be read then the\n"
812 "end of file object is returned.")
813 #define FUNC_NAME s_scm_readdir
815 struct dirent
*rdent
;
817 SCM_VALIDATE_DIR (1, port
);
818 if (!SCM_DIR_OPEN_P (port
))
819 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
824 /* On Solaris 2.7, struct dirent only contains "char d_name[1]" and one is
825 expected to provide a buffer of "sizeof(struct dirent) + NAME_MAX"
826 bytes. The glibc 2.3.2 manual notes this sort of thing too, and
827 advises "offsetof(struct dirent,d_name) + NAME_MAX + 1". Either should
828 suffice, we give both to be certain. */
831 char pad1
[sizeof(struct dirent
) + NAME_MAX
];
832 char pad2
[offsetof (struct dirent
, d_name
) + NAME_MAX
+ 1];
834 SCM_SYSCALL (readdir_r ((DIR *) SCM_CELL_WORD_1 (port
), &u
.ent
, &rdent
));
836 SCM_SYSCALL (rdent
= readdir ((DIR *) SCM_CELL_WORD_1 (port
)));
841 return (rdent
? scm_mem2string (rdent
->d_name
, NAMLEN (rdent
))
848 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
850 "Reset the directory port @var{stream} so that the next call to\n"
851 "@code{readdir} will return the first directory entry.")
852 #define FUNC_NAME s_scm_rewinddir
854 SCM_VALIDATE_DIR (1, port
);
855 if (!SCM_DIR_OPEN_P (port
))
856 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
858 rewinddir ((DIR *) SCM_CELL_WORD_1 (port
));
860 return SCM_UNSPECIFIED
;
865 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
867 "Close the directory stream @var{stream}.\n"
868 "The return value is unspecified.")
869 #define FUNC_NAME s_scm_closedir
871 SCM_VALIDATE_DIR (1, port
);
873 if (SCM_DIR_OPEN_P (port
))
877 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_CELL_WORD_1 (port
)));
881 SCM_SET_CELL_WORD_0 (port
, scm_tc16_dir
);
884 return SCM_UNSPECIFIED
;
890 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
892 scm_puts ("#<", port
);
893 if (!SCM_DIR_OPEN_P (exp
))
894 scm_puts ("closed: ", port
);
895 scm_puts ("directory stream ", port
);
896 scm_intprint (SCM_CELL_WORD_1 (exp
), 16, port
);
897 scm_putc ('>', port
);
905 if (SCM_DIR_OPEN_P (p
))
906 closedir ((DIR *) SCM_CELL_WORD_1 (p
));
911 /* {Navigating Directories}
915 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
917 "Change the current working directory to @var{path}.\n"
918 "The return value is unspecified.")
919 #define FUNC_NAME s_scm_chdir
923 SCM_VALIDATE_STRING (1, str
);
924 SCM_SYSCALL (ans
= chdir (SCM_STRING_CHARS (str
)));
927 return SCM_UNSPECIFIED
;
932 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
934 "Return the name of the current working directory.")
935 #define FUNC_NAME s_scm_getcwd
942 wd
= scm_malloc (size
);
943 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
947 wd
= scm_malloc (size
);
951 int save_errno
= errno
;
956 result
= scm_mem2string (wd
, strlen (wd
));
961 #endif /* HAVE_GETCWD */
967 /* check that element is a port or file descriptor. if it's a port
968 and its buffer is ready for use, add it to the ports_ready list.
969 otherwise add its file descriptor to *set. the type of list can be
970 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
971 SCM_ARG3 for excepts. */
973 set_element (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM element
, int pos
)
977 if (scm_is_integer (element
))
979 fd
= scm_to_int (element
);
985 element
= SCM_COERCE_OUTPORT (element
);
986 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
989 /* check whether port has buffered input. */
990 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
992 if (pt
->read_pos
< pt
->read_end
)
995 else if (pos
== SCM_ARG2
)
997 /* check whether port's output buffer has room. */
998 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1000 /* > 1 since writing the last byte in the buffer causes flush. */
1001 if (pt
->write_end
- pt
->write_pos
> 1)
1004 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
1007 *ports_ready
= scm_cons (element
, *ports_ready
);
1013 /* check list_or_vec, a list or vector of ports or file descriptors,
1014 adding each member to either the ports_ready list (if it's a port
1015 with a usable buffer) or to *set. the kind of list_or_vec can be
1016 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1017 SCM_ARG3 for excepts. */
1019 fill_select_type (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
1023 if (SCM_VECTORP (list_or_vec
))
1025 int i
= SCM_VECTOR_LENGTH (list_or_vec
);
1026 SCM
const *ve
= SCM_VELTS (list_or_vec
);
1030 int fd
= set_element (set
, ports_ready
, ve
[i
], pos
);
1038 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1040 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
1044 list_or_vec
= SCM_CDR (list_or_vec
);
1051 /* if element (a file descriptor or port) appears in *set, cons it to
1052 list. return list. */
1054 get_element (SELECT_TYPE
*set
, SCM element
, SCM list
)
1058 if (scm_is_integer (element
))
1060 fd
= scm_to_int (element
);
1064 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
1066 if (FD_ISSET (fd
, set
))
1067 list
= scm_cons (element
, list
);
1071 /* construct component of scm_select return value.
1072 set: pointer to set of file descriptors found by select to be ready
1073 ports_ready: ports ready due to buffering
1074 list_or_vec: original list/vector handed to scm_select.
1075 the return value is a list/vector of ready ports/file descriptors.
1076 works by finding the objects in list which correspond to members of
1077 *set and appending them to ports_ready. result is converted to a
1078 vector if list_or_vec is a vector. */
1080 retrieve_select_type (SELECT_TYPE
*set
, SCM ports_ready
, SCM list_or_vec
)
1082 SCM answer_list
= ports_ready
;
1084 if (SCM_VECTORP (list_or_vec
))
1086 int i
= SCM_VECTOR_LENGTH (list_or_vec
);
1087 SCM
const *ve
= SCM_VELTS (list_or_vec
);
1091 answer_list
= get_element (set
, ve
[i
], answer_list
);
1093 return scm_vector (answer_list
);
1097 /* list_or_vec must be a list. */
1098 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1100 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
1101 list_or_vec
= SCM_CDR (list_or_vec
);
1107 /* Static helper functions above refer to s_scm_select directly as s_select */
1108 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
1109 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
1110 "This procedure has a variety of uses: waiting for the ability\n"
1111 "to provide input, accept output, or the existence of\n"
1112 "exceptional conditions on a collection of ports or file\n"
1113 "descriptors, or waiting for a timeout to occur.\n"
1114 "It also returns if interrupted by a signal.\n\n"
1115 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
1116 "vectors, with each member a port or a file descriptor.\n"
1117 "The value returned is a list of three corresponding\n"
1118 "lists or vectors containing only the members which meet the\n"
1119 "specified requirement. The ability of port buffers to\n"
1120 "provide input or accept output is taken into account.\n"
1121 "Ordering of the input lists or vectors is not preserved.\n\n"
1122 "The optional arguments @var{secs} and @var{usecs} specify the\n"
1123 "timeout. Either @var{secs} can be specified alone, as\n"
1124 "either an integer or a real number, or both @var{secs} and\n"
1125 "@var{usecs} can be specified as integers, in which case\n"
1126 "@var{usecs} is an additional timeout expressed in\n"
1127 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
1128 "select will wait for as long as it takes for one of the other\n"
1129 "conditions to be satisfied.\n\n"
1130 "The scsh version of @code{select} differs as follows:\n"
1131 "Only vectors are accepted for the first three arguments.\n"
1132 "The @var{usecs} argument is not supported.\n"
1133 "Multiple values are returned instead of a list.\n"
1134 "Duplicates in the input vectors appear only once in output.\n"
1135 "An additional @code{select!} interface is provided.")
1136 #define FUNC_NAME s_scm_select
1138 struct timeval timeout
;
1139 struct timeval
* time_ptr
;
1140 SELECT_TYPE read_set
;
1141 SELECT_TYPE write_set
;
1142 SELECT_TYPE except_set
;
1146 /* these lists accumulate ports which are ready due to buffering.
1147 their file descriptors don't need to be added to the select sets. */
1148 SCM read_ports_ready
= SCM_EOL
;
1149 SCM write_ports_ready
= SCM_EOL
;
1152 if (SCM_VECTORP (reads
))
1154 read_count
= SCM_VECTOR_LENGTH (reads
);
1158 read_count
= scm_ilength (reads
);
1159 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
1161 if (SCM_VECTORP (writes
))
1163 write_count
= SCM_VECTOR_LENGTH (writes
);
1167 write_count
= scm_ilength (writes
);
1168 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
1170 if (SCM_VECTORP (excepts
))
1172 except_count
= SCM_VECTOR_LENGTH (excepts
);
1176 except_count
= scm_ilength (excepts
);
1177 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
1180 FD_ZERO (&read_set
);
1181 FD_ZERO (&write_set
);
1182 FD_ZERO (&except_set
);
1184 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
1187 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
1189 int except_max
= fill_select_type (&except_set
, NULL
,
1192 if (write_max
> max_fd
)
1194 if (except_max
> max_fd
)
1195 max_fd
= except_max
;
1198 /* if there's a port with a ready buffer, don't block, just
1199 check for ready file descriptors. */
1200 if (!SCM_NULLP (read_ports_ready
) || !SCM_NULLP (write_ports_ready
))
1203 timeout
.tv_usec
= 0;
1204 time_ptr
= &timeout
;
1206 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
1210 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
1212 timeout
.tv_sec
= scm_to_ulong (secs
);
1213 if (SCM_UNBNDP (usecs
))
1214 timeout
.tv_usec
= 0;
1216 timeout
.tv_usec
= scm_to_long (usecs
);
1220 double fl
= scm_to_double (secs
);
1222 if (!SCM_UNBNDP (usecs
))
1223 SCM_WRONG_TYPE_ARG (4, secs
);
1225 SCM_OUT_OF_RANGE (4, secs
);
1226 timeout
.tv_sec
= (long) fl
;
1227 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
1229 time_ptr
= &timeout
;
1233 int rv
= scm_internal_select (max_fd
+ 1,
1234 &read_set
, &write_set
, &except_set
,
1239 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
1240 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
1241 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
1244 #endif /* HAVE_SELECT */
1249 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
1250 (SCM object
, SCM cmd
, SCM value
),
1251 "Apply @var{command} to the specified file descriptor or the underlying\n"
1252 "file descriptor of the specified port. @var{value} is an optional\n"
1253 "integer argument.\n\n"
1254 "Values for @var{command} are:\n\n"
1257 "Duplicate a file descriptor\n"
1259 "Get flags associated with the file descriptor.\n"
1261 "Set flags associated with the file descriptor to @var{value}.\n"
1263 "Get flags associated with the open file.\n"
1265 "Set flags associated with the open file to @var{value}\n"
1267 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
1269 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
1270 "@item FD_CLOEXEC\n"
1271 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
1274 #define FUNC_NAME s_scm_fcntl
1280 object
= SCM_COERCE_OUTPORT (object
);
1282 if (SCM_OPFPORTP (object
))
1283 fdes
= SCM_FPORT_FDES (object
);
1285 fdes
= scm_to_int (object
);
1287 if (SCM_UNBNDP (value
))
1290 ivalue
= scm_to_int (value
);
1292 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
1295 return scm_from_int (rv
);
1298 #endif /* HAVE_FCNTL */
1300 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
1302 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1303 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1304 "file descriptor is fsync'd.\n"
1305 "The return value is unspecified.")
1306 #define FUNC_NAME s_scm_fsync
1310 object
= SCM_COERCE_OUTPORT (object
);
1312 if (SCM_OPFPORTP (object
))
1315 fdes
= SCM_FPORT_FDES (object
);
1318 fdes
= scm_to_int (object
);
1320 if (fsync (fdes
) == -1)
1322 return SCM_UNSPECIFIED
;
1327 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1328 (SCM oldpath
, SCM newpath
),
1329 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1330 "@var{path-from}. The return value is unspecified.")
1331 #define FUNC_NAME s_scm_symlink
1335 SCM_VALIDATE_STRING (1, oldpath
);
1336 SCM_VALIDATE_STRING (2, newpath
);
1337 SCM_SYSCALL (val
= symlink (SCM_STRING_CHARS (oldpath
), SCM_STRING_CHARS (newpath
)));
1340 return SCM_UNSPECIFIED
;
1343 #endif /* HAVE_SYMLINK */
1345 #ifdef HAVE_READLINK
1346 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1348 "Return the value of the symbolic link named by @var{path} (a\n"
1349 "string), i.e., the file that the link points to.")
1350 #define FUNC_NAME s_scm_readlink
1356 SCM_VALIDATE_STRING (1, path
);
1357 buf
= scm_malloc (size
);
1358 while ((rv
= readlink (SCM_STRING_CHARS (path
), buf
, size
)) == size
)
1362 buf
= scm_malloc (size
);
1366 int save_errno
= errno
;
1371 result
= scm_mem2string (buf
, rv
);
1376 #endif /* HAVE_READLINK */
1379 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
1381 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
1382 "it will return information about a symbolic link itself, not the\n"
1383 "file it points to. @var{path} must be a string.")
1384 #define FUNC_NAME s_scm_lstat
1387 struct stat stat_temp
;
1389 SCM_VALIDATE_STRING (1, str
);
1390 SCM_SYSCALL (rv
= lstat (SCM_STRING_CHARS (str
), &stat_temp
));
1395 SCM_SYSERROR_MSG ("~A: ~S",
1396 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
1399 return scm_stat2scm(&stat_temp
);
1402 #endif /* HAVE_LSTAT */
1404 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1405 (SCM oldfile
, SCM newfile
),
1406 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1407 "The return value is unspecified.")
1408 #define FUNC_NAME s_scm_copy_file
1413 struct stat oldstat
;
1415 SCM_VALIDATE_STRING (1, oldfile
);
1416 SCM_VALIDATE_STRING (2, newfile
);
1417 if (stat (SCM_STRING_CHARS (oldfile
), &oldstat
) == -1)
1419 oldfd
= open (SCM_STRING_CHARS (oldfile
), O_RDONLY
);
1423 /* use POSIX flags instead of 07777?. */
1424 newfd
= open (SCM_STRING_CHARS (newfile
), O_WRONLY
| O_CREAT
| O_TRUNC
,
1425 oldstat
.st_mode
& 07777);
1432 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1433 if (write (newfd
, buf
, n
) != n
)
1440 if (close (newfd
) == -1)
1442 return SCM_UNSPECIFIED
;
1447 /* Filename manipulation */
1451 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1453 "Return the directory name component of the file name\n"
1454 "@var{filename}. If @var{filename} does not contain a directory\n"
1455 "component, @code{.} is returned.")
1456 #define FUNC_NAME s_scm_dirname
1460 unsigned long int len
;
1462 SCM_VALIDATE_STRING (1, filename
);
1464 s
= SCM_STRING_CHARS (filename
);
1465 len
= SCM_STRING_LENGTH (filename
);
1469 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1470 while (i
>= 0 && (s
[i
] != '/' && s
[i
] != '\\')) --i
;
1471 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1473 while (i
>= 0 && s
[i
] == '/') --i
;
1474 while (i
>= 0 && s
[i
] != '/') --i
;
1475 while (i
>= 0 && s
[i
] == '/') --i
;
1476 #endif /* ndef __MINGW32__ */
1480 if (len
> 0 && (s
[0] == '/' || s
[0] == '\\'))
1482 if (len
> 0 && s
[0] == '/')
1483 #endif /* ndef __MINGW32__ */
1484 return scm_substring (filename
, SCM_INUM0
, scm_from_int (1));
1486 return scm_dot_string
;
1489 return scm_substring (filename
, SCM_INUM0
, scm_from_int (i
+ 1));
1493 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1494 (SCM filename
, SCM suffix
),
1495 "Return the base name of the file name @var{filename}. The\n"
1496 "base name is the file name without any directory components.\n"
1497 "If @var{suffix} is provided, and is equal to the end of\n"
1498 "@var{basename}, it is removed also.")
1499 #define FUNC_NAME s_scm_basename
1504 SCM_VALIDATE_STRING (1, filename
);
1505 f
= SCM_STRING_CHARS (filename
);
1506 len
= SCM_STRING_LENGTH (filename
);
1508 if (SCM_UNBNDP (suffix
))
1512 SCM_VALIDATE_STRING (2, suffix
);
1513 s
= SCM_STRING_CHARS (suffix
);
1514 j
= SCM_STRING_LENGTH (suffix
) - 1;
1518 while (i
>= 0 && (f
[i
] == '/' || f
[i
] == '\\')) --i
;
1520 while (i
>= 0 && f
[i
] == '/') --i
;
1521 #endif /* ndef __MINGW32__ */
1523 while (i
>= 0 && j
>= 0 && f
[i
] == s
[j
]) --i
, --j
;
1527 while (i
>= 0 && f
[i
] != '/' && f
[i
] != '\\') --i
;
1529 while (i
>= 0 && f
[i
] != '/') --i
;
1530 #endif /* ndef __MINGW32__ */
1534 if (len
> 0 && (f
[0] == '/' || f
[0] == '\\'))
1536 if (len
> 0 && f
[0] == '/')
1537 #endif /* ndef __MINGW32__ */
1538 return scm_substring (filename
, SCM_INUM0
, scm_from_int (1));
1540 return scm_dot_string
;
1543 return scm_substring (filename
, scm_from_int (i
+1), scm_from_int (end
+1));
1554 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1555 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1556 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1558 scm_dot_string
= scm_permanent_object (scm_makfrom0str ("."));
1561 scm_c_define ("O_RDONLY", scm_from_long (O_RDONLY
));
1564 scm_c_define ("O_WRONLY", scm_from_long (O_WRONLY
));
1567 scm_c_define ("O_RDWR", scm_from_long (O_RDWR
));
1570 scm_c_define ("O_CREAT", scm_from_long (O_CREAT
));
1573 scm_c_define ("O_EXCL", scm_from_long (O_EXCL
));
1576 scm_c_define ("O_NOCTTY", scm_from_long (O_NOCTTY
));
1579 scm_c_define ("O_TRUNC", scm_from_long (O_TRUNC
));
1582 scm_c_define ("O_APPEND", scm_from_long (O_APPEND
));
1585 scm_c_define ("O_NONBLOCK", scm_from_long (O_NONBLOCK
));
1588 scm_c_define ("O_NDELAY", scm_from_long (O_NDELAY
));
1591 scm_c_define ("O_SYNC", scm_from_long (O_SYNC
));
1595 scm_c_define ("F_DUPFD", scm_from_long (F_DUPFD
));
1598 scm_c_define ("F_GETFD", scm_from_long (F_GETFD
));
1601 scm_c_define ("F_SETFD", scm_from_long (F_SETFD
));
1604 scm_c_define ("F_GETFL", scm_from_long (F_GETFL
));
1607 scm_c_define ("F_SETFL", scm_from_long (F_SETFL
));
1610 scm_c_define ("F_GETOWN", scm_from_long (F_GETOWN
));
1613 scm_c_define ("F_SETOWN", scm_from_long (F_SETOWN
));
1616 scm_c_define ("FD_CLOEXEC", scm_from_long (FD_CLOEXEC
));
1619 #include "libguile/filesys.x"