1 /* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002 Free Software Foundation, Inc.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2, or (at your option)
8 * This program 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
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this software; see the file COPYING. If not, write to
15 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
16 * Boston, MA 02111-1307 USA
18 * As a special exception, the Free Software Foundation gives permission
19 * for additional uses of the text contained in its release of GUILE.
21 * The exception is that, if you link the GUILE library with other files
22 * to produce an executable, this does not by itself cause the
23 * resulting executable to be covered by the GNU General Public License.
24 * Your use of that executable is in no way restricted on account of
25 * linking the GUILE library code into it.
27 * This exception does not however invalidate any other reasons why
28 * the executable file might be covered by the GNU General Public License.
30 * This exception applies only to the code released by the
31 * Free Software Foundation under the name GUILE. If you copy
32 * code from other Free Software Foundation releases into a copy of
33 * GUILE, as the General Public License permits, the exception does
34 * not apply to the code that you add in this way. To avoid misleading
35 * anyone as to the status of such modified files, you must delete
36 * this exception notice from them.
38 * If you write modifications of your own for GUILE, it is your choice
39 * whether to permit this exception to apply to your modifications.
40 * If you do not wish that, delete this exception notice. */
51 #include "libguile/_scm.h"
52 #include "libguile/smob.h"
53 #include "libguile/feature.h"
54 #include "libguile/fports.h"
55 #include "libguile/iselect.h"
56 #include "libguile/strings.h"
57 #include "libguile/vectors.h"
58 #include "libguile/lang.h"
60 #include "libguile/validate.h"
61 #include "libguile/filesys.h"
72 #ifdef TIME_WITH_SYS_TIME
73 # include <sys/time.h>
77 # include <sys/time.h>
87 #ifdef LIBC_H_WITH_UNISTD_H
91 #ifdef HAVE_SYS_SELECT_H
92 #include <sys/select.h>
99 #include <sys/types.h>
100 #include <sys/stat.h>
108 #if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
109 # include "win32-dirent.h"
110 # define NAMLEN(dirent) strlen((dirent)->d_name)
113 # define NAMLEN(dirent) strlen((dirent)->d_name)
115 # define dirent direct
116 # define NAMLEN(dirent) (dirent)->d_namlen
118 # include <sys/ndir.h>
121 # include <sys/dir.h>
128 /* Ultrix has S_IFSOCK, but no S_ISSOCK. Ipe! */
129 #if defined (S_IFSOCK) && ! defined (S_ISSOCK)
130 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
133 /* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
134 compiler like BorlandC or MSVC has none of these macros defined. */
156 # define _S_IFIFO 0x1000 /* FIFO */
157 # define _S_IFCHR 0x2000 /* Character */
158 # define _S_IFBLK 0x3000 /* Block */
159 # define _S_IFDIR 0x4000 /* Directory */
160 # define _S_IFREG 0x8000 /* Regular */
161 # define _S_IFSOCK 0xC000 /* Socket */
182 # define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
183 # define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
184 # define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
185 # define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
186 # define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
187 # define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
189 #endif /* __MINGW32__ */
191 /* Some more definitions for the native Windows port. */
193 # define mkdir(path, mode) mkdir (path)
194 # define fsync(fd) _commit (fd)
195 # define fchmod(fd, mode) (-1)
196 #endif /* __MINGW32__ */
206 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
207 (SCM object
, SCM owner
, SCM group
),
208 "Change the ownership and group of the file referred to by @var{object} to\n"
209 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
210 "a string containing a file name or, if the platform\n"
211 "supports fchown, a port or integer file descriptor\n"
212 "which is open on the file. The return value\n"
213 "is unspecified.\n\n"
214 "If @var{object} is a symbolic link, either the\n"
215 "ownership of the link or the ownership of the referenced file will be\n"
216 "changed depending on the operating system (lchown is\n"
217 "unsupported at present). If @var{owner} or @var{group} is specified\n"
218 "as @code{-1}, then that ID is not changed.")
219 #define FUNC_NAME s_scm_chown
223 object
= SCM_COERCE_OUTPORT (object
);
225 SCM_VALIDATE_INUM (2, owner
);
226 SCM_VALIDATE_INUM (3, group
);
228 if (SCM_INUMP (object
) || (SCM_OPFPORTP (object
)))
230 int fdes
= SCM_INUMP (object
) ? SCM_INUM (object
)
231 : SCM_FPORT_FDES (object
);
233 SCM_SYSCALL (rv
= fchown (fdes
, SCM_INUM (owner
), SCM_INUM (group
)));
238 SCM_VALIDATE_STRING (1, object
);
239 SCM_SYSCALL (rv
= chown (SCM_STRING_CHARS (object
),
240 SCM_INUM (owner
), SCM_INUM (group
)));
244 return SCM_UNSPECIFIED
;
247 #endif /* HAVE_CHOWN */
250 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
251 (SCM object
, SCM mode
),
252 "Changes the permissions of the file referred to by @var{obj}.\n"
253 "@var{obj} can be a string containing a file name or a port or integer file\n"
254 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
255 "as the underlying system call).\n"
256 "@var{mode} specifies\n"
257 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
258 "The return value is unspecified.")
259 #define FUNC_NAME s_scm_chmod
264 object
= SCM_COERCE_OUTPORT (object
);
266 SCM_VALIDATE_INUM (2, mode
);
267 if (SCM_INUMP (object
) || SCM_OPFPORTP (object
))
269 if (SCM_INUMP (object
))
270 fdes
= SCM_INUM (object
);
272 fdes
= SCM_FPORT_FDES (object
);
273 SCM_SYSCALL (rv
= fchmod (fdes
, SCM_INUM (mode
)));
277 SCM_VALIDATE_STRING (1, object
);
278 SCM_SYSCALL (rv
= chmod (SCM_STRING_CHARS (object
), SCM_INUM (mode
)));
282 return SCM_UNSPECIFIED
;
286 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
288 "If @var{mode} is omitted, returns a decimal number representing the current\n"
289 "file creation mask. Otherwise the file creation mask is set to\n"
290 "@var{mode} and the previous value is returned.\n\n"
291 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
292 #define FUNC_NAME s_scm_umask
295 if (SCM_UNBNDP (mode
))
302 SCM_VALIDATE_INUM (1, mode
);
303 mask
= umask (SCM_INUM (mode
));
305 return SCM_MAKINUM (mask
);
311 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
312 (SCM path
, SCM flags
, SCM mode
),
313 "Similar to @code{open} but return a file descriptor instead of\n"
315 #define FUNC_NAME s_scm_open_fdes
321 SCM_VALIDATE_STRING (1, path
);
322 iflags
= SCM_NUM2INT (2, flags
);
323 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
324 SCM_SYSCALL (fd
= open (SCM_STRING_CHARS (path
), iflags
, imode
));
327 return SCM_MAKINUM (fd
);
331 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
332 (SCM path
, SCM flags
, SCM mode
),
333 "Open the file named by @var{path} for reading and/or writing.\n"
334 "@var{flags} is an integer specifying how the file should be opened.\n"
335 "@var{mode} is an integer specifying the permission bits of the file, if\n"
336 "it needs to be created, before the umask is applied. The default is 666\n"
337 "(Unix itself has no default).\n\n"
338 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
339 "Basic flags are:\n\n"
341 "Open the file read-only.\n"
344 "Open the file write-only.\n"
347 "Open the file read/write.\n"
350 "Append to the file instead of truncating.\n"
353 "Create the file if it does not already exist.\n"
355 "See the Unix documentation of the @code{open} system call\n"
356 "for additional flags.")
357 #define FUNC_NAME s_scm_open
364 fd
= SCM_INUM (scm_open_fdes (path
, flags
, mode
));
365 iflags
= SCM_NUM2INT (2, flags
);
368 if (iflags
& O_APPEND
)
370 else if (iflags
& O_CREAT
)
376 if (iflags
& O_APPEND
)
378 else if (iflags
& O_WRONLY
)
383 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
388 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
390 "Similar to close-port (@pxref{Closing, close-port}),\n"
391 "but also works on file descriptors. A side\n"
392 "effect of closing a file descriptor is that any ports using that file\n"
393 "descriptor are moved to a different file descriptor and have\n"
394 "their revealed counts set to zero.")
395 #define FUNC_NAME s_scm_close
400 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
402 if (SCM_PORTP (fd_or_port
))
403 return scm_close_port (fd_or_port
);
404 SCM_VALIDATE_INUM (1, fd_or_port
);
405 fd
= SCM_INUM (fd_or_port
);
406 scm_evict_ports (fd
); /* see scsh manual. */
407 SCM_SYSCALL (rv
= close (fd
));
408 /* following scsh, closing an already closed file descriptor is
410 if (rv
< 0 && errno
!= EBADF
)
412 return SCM_BOOL (rv
>= 0);
416 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
418 "A simple wrapper for the @code{close} system call.\n"
419 "Close file descriptor @var{fd}, which must be an integer.\n"
420 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
421 "the file descriptor will be closed even if a port is using it.\n"
422 "The return value is unspecified.")
423 #define FUNC_NAME s_scm_close_fdes
428 SCM_VALIDATE_INUM_COPY (1, fd
, c_fd
);
429 SCM_SYSCALL (rv
= close (c_fd
));
432 return SCM_UNSPECIFIED
;
440 SCM_SYMBOL (scm_sym_regular
, "regular");
441 SCM_SYMBOL (scm_sym_directory
, "directory");
443 SCM_SYMBOL (scm_sym_symlink
, "symlink");
445 SCM_SYMBOL (scm_sym_block_special
, "block-special");
446 SCM_SYMBOL (scm_sym_char_special
, "char-special");
447 SCM_SYMBOL (scm_sym_fifo
, "fifo");
448 SCM_SYMBOL (scm_sym_sock
, "socket");
449 SCM_SYMBOL (scm_sym_unknown
, "unknown");
452 scm_stat2scm (struct stat
*stat_temp
)
454 SCM ans
= scm_c_make_vector (15, SCM_UNSPECIFIED
);
456 SCM_VECTOR_SET(ans
, 0, scm_ulong2num ((unsigned long) stat_temp
->st_dev
));
457 SCM_VECTOR_SET(ans
, 1, scm_ulong2num ((unsigned long) stat_temp
->st_ino
));
458 SCM_VECTOR_SET(ans
, 2, scm_ulong2num ((unsigned long) stat_temp
->st_mode
));
459 SCM_VECTOR_SET(ans
, 3, scm_ulong2num ((unsigned long) stat_temp
->st_nlink
));
460 SCM_VECTOR_SET(ans
, 4, scm_ulong2num ((unsigned long) stat_temp
->st_uid
));
461 SCM_VECTOR_SET(ans
, 5, scm_ulong2num ((unsigned long) stat_temp
->st_gid
));
462 #ifdef HAVE_STRUCT_STAT_ST_RDEV
463 SCM_VECTOR_SET(ans
, 6, scm_ulong2num ((unsigned long) stat_temp
->st_rdev
));
465 SCM_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
467 SCM_VECTOR_SET(ans
, 7, scm_ulong2num ((unsigned long) stat_temp
->st_size
));
468 SCM_VECTOR_SET(ans
, 8, scm_ulong2num ((unsigned long) stat_temp
->st_atime
));
469 SCM_VECTOR_SET(ans
, 9, scm_ulong2num ((unsigned long) stat_temp
->st_mtime
));
470 SCM_VECTOR_SET(ans
, 10, scm_ulong2num ((unsigned long) stat_temp
->st_ctime
));
471 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
472 SCM_VECTOR_SET(ans
, 11, scm_ulong2num ((unsigned long) stat_temp
->st_blksize
));
474 SCM_VECTOR_SET(ans
, 11, scm_ulong2num (4096L));
476 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
477 SCM_VECTOR_SET(ans
, 12, scm_ulong2num ((unsigned long) stat_temp
->st_blocks
));
479 SCM_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
482 int mode
= stat_temp
->st_mode
;
485 SCM_VECTOR_SET(ans
, 13, scm_sym_regular
);
486 else if (S_ISDIR (mode
))
487 SCM_VECTOR_SET(ans
, 13, scm_sym_directory
);
489 else if (S_ISLNK (mode
))
490 SCM_VECTOR_SET(ans
, 13, scm_sym_symlink
);
492 else if (S_ISBLK (mode
))
493 SCM_VECTOR_SET(ans
, 13, scm_sym_block_special
);
494 else if (S_ISCHR (mode
))
495 SCM_VECTOR_SET(ans
, 13, scm_sym_char_special
);
496 else if (S_ISFIFO (mode
))
497 SCM_VECTOR_SET(ans
, 13, scm_sym_fifo
);
499 else if (S_ISSOCK (mode
))
500 SCM_VECTOR_SET(ans
, 13, scm_sym_sock
);
503 SCM_VECTOR_SET(ans
, 13, scm_sym_unknown
);
505 SCM_VECTOR_SET(ans
, 14, SCM_MAKINUM ((~S_IFMT
) & mode
));
507 /* the layout of the bits in ve[14] is intended to be portable.
508 If there are systems that don't follow the usual convention,
509 the following could be used:
512 if (S_ISUID & mode) tmp += 1;
514 if (S_IRGRP & mode) tmp += 1;
516 if (S_ISVTX & mode) tmp += 1;
518 if (S_IRUSR & mode) tmp += 1;
520 if (S_IWUSR & mode) tmp += 1;
522 if (S_IXUSR & mode) tmp += 1;
524 if (S_IWGRP & mode) tmp += 1;
526 if (S_IXGRP & mode) tmp += 1;
528 if (S_IROTH & mode) tmp += 1;
530 if (S_IWOTH & mode) tmp += 1;
532 if (S_IXOTH & mode) tmp += 1;
534 SCM_VECTOR_SET(ans, 14, SCM_MAKINUM (tmp));
544 * Try getting the appropiate stat buffer for a given file descriptor
545 * under Windows. It differentiates between file, pipe and socket
548 static int fstat_Win32 (int fdes
, struct stat
*buf
)
550 int error
, optlen
= sizeof (int);
552 memset (buf
, 0, sizeof (struct stat
));
554 /* Is this a socket ? */
555 if (getsockopt (fdes
, SOL_SOCKET
, SO_ERROR
, (void *) &error
, &optlen
) >= 0)
557 buf
->st_mode
= _S_IFSOCK
| _S_IREAD
| _S_IWRITE
| _S_IEXEC
;
559 buf
->st_atime
= buf
->st_ctime
= buf
->st_mtime
= time (NULL
);
562 /* Maybe a regular file or pipe ? */
563 return fstat (fdes
, buf
);
565 #endif /* __MINGW32__ */
567 SCM_DEFINE (scm_stat
, "stat", 1, 0, 0,
569 "Return an object containing various information about the file\n"
570 "determined by @var{obj}. @var{obj} can be a string containing\n"
571 "a file name or a port or integer file descriptor which is open\n"
572 "on a file (in which case @code{fstat} is used as the underlying\n"
575 "The object returned by @code{stat} can be passed as a single\n"
576 "parameter to the following procedures, all of which return\n"
581 "The device containing the file.\n"
583 "The file serial number, which distinguishes this file from all\n"
584 "other files on the same device.\n"
586 "The mode of the file. This includes file type information and\n"
587 "the file permission bits. See @code{stat:type} and\n"
588 "@code{stat:perms} below.\n"
590 "The number of hard links to the file.\n"
592 "The user ID of the file's owner.\n"
594 "The group ID of the file.\n"
596 "Device ID; this entry is defined only for character or block\n"
599 "The size of a regular file in bytes.\n"
601 "The last access time for the file.\n"
603 "The last modification time for the file.\n"
605 "The last modification time for the attributes of the file.\n"
606 "@item stat:blksize\n"
607 "The optimal block size for reading or writing the file, in\n"
609 "@item stat:blocks\n"
610 "The amount of disk space that the file occupies measured in\n"
611 "units of 512 byte blocks.\n"
614 "In addition, the following procedures return the information\n"
615 "from stat:mode in a more convenient form:\n"
619 "A symbol representing the type of file. Possible values are\n"
620 "regular, directory, symlink, block-special, char-special, fifo,\n"
621 "socket and unknown\n"
623 "An integer representing the access permission bits.\n"
625 #define FUNC_NAME s_scm_stat
629 struct stat stat_temp
;
631 if (SCM_INUMP (object
))
634 SCM_SYSCALL (rv
= fstat_Win32 (SCM_INUM (object
), &stat_temp
));
636 SCM_SYSCALL (rv
= fstat (SCM_INUM (object
), &stat_temp
));
639 else if (SCM_STRINGP (object
))
642 char *p
, *file
= strdup (SCM_STRING_CHARS (object
));
643 p
= file
+ strlen (file
) - 1;
644 while (p
> file
&& (*p
== '/' || *p
== '\\'))
646 SCM_SYSCALL (rv
= stat (file
, &stat_temp
));
649 SCM_SYSCALL (rv
= stat (SCM_STRING_CHARS (object
), &stat_temp
));
654 object
= SCM_COERCE_OUTPORT (object
);
655 SCM_VALIDATE_OPFPORT (1, object
);
656 fdes
= SCM_FPORT_FDES (object
);
658 SCM_SYSCALL (rv
= fstat_Win32 (fdes
, &stat_temp
));
660 SCM_SYSCALL (rv
= fstat (fdes
, &stat_temp
));
668 SCM_SYSERROR_MSG ("~A: ~S",
669 scm_list_2 (scm_makfrom0str (strerror (errno
)),
673 return scm_stat2scm (&stat_temp
);
678 /* {Modifying Directories}
682 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
683 (SCM oldpath
, SCM newpath
),
684 "Creates a new name @var{newpath} in the file system for the\n"
685 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
686 "link, the link may or may not be followed depending on the\n"
688 #define FUNC_NAME s_scm_link
692 SCM_VALIDATE_STRING (1, oldpath
);
693 SCM_VALIDATE_STRING (2, newpath
);
694 SCM_SYSCALL (val
= link (SCM_STRING_CHARS (oldpath
),
695 SCM_STRING_CHARS (newpath
)));
698 return SCM_UNSPECIFIED
;
701 #endif /* HAVE_LINK */
705 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
706 (SCM oldname
, SCM newname
),
707 "Renames the file specified by @var{oldname} to @var{newname}.\n"
708 "The return value is unspecified.")
709 #define FUNC_NAME s_scm_rename
712 SCM_VALIDATE_STRING (1, oldname
);
713 SCM_VALIDATE_STRING (2, newname
);
715 SCM_SYSCALL (rv
= rename (SCM_STRING_CHARS (oldname
), SCM_STRING_CHARS (newname
)));
717 SCM_SYSCALL (rv
= link (SCM_STRING_CHARS (oldname
), SCM_STRING_CHARS (newname
)));
720 SCM_SYSCALL (rv
= unlink (SCM_STRING_CHARS (oldname
)));;
722 /* unlink failed. remove new name */
723 SCM_SYSCALL (unlink (SCM_STRING_CHARS (newname
)));
728 return SCM_UNSPECIFIED
;
733 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
735 "Deletes (or \"unlinks\") the file specified by @var{path}.")
736 #define FUNC_NAME s_scm_delete_file
739 SCM_VALIDATE_STRING (1, str
);
740 SCM_SYSCALL (ans
= unlink (SCM_STRING_CHARS (str
)));
743 return SCM_UNSPECIFIED
;
748 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
749 (SCM path
, SCM mode
),
750 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
751 "then the permissions of the directory file are set using the current\n"
752 "umask. Otherwise they are set to the decimal value specified with\n"
753 "@var{mode}. The return value is unspecified.")
754 #define FUNC_NAME s_scm_mkdir
758 SCM_VALIDATE_STRING (1, path
);
759 if (SCM_UNBNDP (mode
))
763 SCM_SYSCALL (rv
= mkdir (SCM_STRING_CHARS (path
), 0777 ^ mask
));
767 SCM_VALIDATE_INUM (2, mode
);
768 SCM_SYSCALL (rv
= mkdir (SCM_STRING_CHARS (path
), SCM_INUM (mode
)));
772 return SCM_UNSPECIFIED
;
775 #endif /* HAVE_MKDIR */
778 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
780 "Remove the existing directory named by @var{path}. The directory must\n"
781 "be empty for this to succeed. The return value is unspecified.")
782 #define FUNC_NAME s_scm_rmdir
786 SCM_VALIDATE_STRING (1, path
);
787 SCM_SYSCALL (val
= rmdir (SCM_STRING_CHARS (path
)));
790 return SCM_UNSPECIFIED
;
797 /* {Examining Directories}
800 scm_t_bits scm_tc16_dir
;
803 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
805 "Return a boolean indicating whether @var{object} is a directory\n"
806 "stream as returned by @code{opendir}.")
807 #define FUNC_NAME s_scm_directory_stream_p
809 return SCM_BOOL (SCM_DIRP (obj
));
814 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
816 "Open the directory specified by @var{path} and return a directory\n"
818 #define FUNC_NAME s_scm_opendir
821 SCM_VALIDATE_STRING (1, dirname
);
822 SCM_SYSCALL (ds
= opendir (SCM_STRING_CHARS (dirname
)));
825 SCM_RETURN_NEWSMOB (scm_tc16_dir
| SCM_DIR_FLAG_OPEN
, ds
);
830 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
832 "Return (as a string) the next directory entry from the directory stream\n"
833 "@var{stream}. If there is no remaining entry to be read then the\n"
834 "end of file object is returned.")
835 #define FUNC_NAME s_scm_readdir
837 struct dirent
*rdent
;
839 SCM_VALIDATE_DIR (1, port
);
840 if (!SCM_DIR_OPEN_P (port
))
841 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
844 SCM_SYSCALL (rdent
= readdir ((DIR *) SCM_CELL_WORD_1 (port
)));
848 return (rdent
? scm_mem2string (rdent
->d_name
, NAMLEN (rdent
))
854 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
856 "Reset the directory port @var{stream} so that the next call to\n"
857 "@code{readdir} will return the first directory entry.")
858 #define FUNC_NAME s_scm_rewinddir
860 SCM_VALIDATE_DIR (1, port
);
861 if (!SCM_DIR_OPEN_P (port
))
862 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
864 rewinddir ((DIR *) SCM_CELL_WORD_1 (port
));
866 return SCM_UNSPECIFIED
;
871 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
873 "Close the directory stream @var{stream}.\n"
874 "The return value is unspecified.")
875 #define FUNC_NAME s_scm_closedir
877 SCM_VALIDATE_DIR (1, port
);
879 if (SCM_DIR_OPEN_P (port
))
883 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_CELL_WORD_1 (port
)));
887 SCM_SET_CELL_WORD_0 (port
, scm_tc16_dir
);
890 return SCM_UNSPECIFIED
;
896 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
898 scm_puts ("#<", port
);
899 if (!SCM_DIR_OPEN_P (exp
))
900 scm_puts ("closed: ", port
);
901 scm_puts ("directory stream ", port
);
902 scm_intprint (SCM_CELL_WORD_1 (exp
), 16, port
);
903 scm_putc ('>', port
);
911 if (SCM_DIR_OPEN_P (p
))
912 closedir ((DIR *) SCM_CELL_WORD_1 (p
));
917 /* {Navigating Directories}
921 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
923 "Change the current working directory to @var{path}.\n"
924 "The return value is unspecified.")
925 #define FUNC_NAME s_scm_chdir
929 SCM_VALIDATE_STRING (1, str
);
930 SCM_SYSCALL (ans
= chdir (SCM_STRING_CHARS (str
)));
933 return SCM_UNSPECIFIED
;
938 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
940 "Return the name of the current working directory.")
941 #define FUNC_NAME s_scm_getcwd
948 wd
= scm_malloc (size
);
949 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
953 wd
= scm_malloc (size
);
957 result
= scm_mem2string (wd
, strlen (wd
));
962 #endif /* HAVE_GETCWD */
968 /* check that element is a port or file descriptor. if it's a port
969 and its buffer is ready for use, add it to the ports_ready list.
970 otherwise add its file descriptor to *set. the type of list can be
971 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
972 SCM_ARG3 for excepts. */
974 set_element (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM element
, int pos
)
978 if (SCM_INUMP (element
))
980 fd
= SCM_INUM (element
);
986 element
= SCM_COERCE_OUTPORT (element
);
987 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
990 /* check whether port has buffered input. */
991 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
993 if (pt
->read_pos
< pt
->read_end
)
996 else if (pos
== SCM_ARG2
)
998 /* check whether port's output buffer has room. */
999 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
1001 /* > 1 since writing the last byte in the buffer causes flush. */
1002 if (pt
->write_end
- pt
->write_pos
> 1)
1005 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
1008 *ports_ready
= scm_cons (element
, *ports_ready
);
1014 /* check list_or_vec, a list or vector of ports or file descriptors,
1015 adding each member to either the ports_ready list (if it's a port
1016 with a usable buffer) or to *set. the kind of list_or_vec can be
1017 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1018 SCM_ARG3 for excepts. */
1020 fill_select_type (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
1024 if (SCM_VECTORP (list_or_vec
))
1026 int i
= SCM_VECTOR_LENGTH (list_or_vec
);
1027 SCM
const *ve
= SCM_VELTS (list_or_vec
);
1031 int fd
= set_element (set
, ports_ready
, ve
[i
], pos
);
1039 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1041 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
1045 list_or_vec
= SCM_CDR (list_or_vec
);
1052 /* if element (a file descriptor or port) appears in *set, cons it to
1053 list. return list. */
1055 get_element (SELECT_TYPE
*set
, SCM element
, SCM list
)
1059 if (SCM_INUMP (element
))
1061 fd
= SCM_INUM (element
);
1065 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
1067 if (FD_ISSET (fd
, set
))
1068 list
= scm_cons (element
, list
);
1072 /* construct component of scm_select return value.
1073 set: pointer to set of file descriptors found by select to be ready
1074 ports_ready: ports ready due to buffering
1075 list_or_vec: original list/vector handed to scm_select.
1076 the return value is a list/vector of ready ports/file descriptors.
1077 works by finding the objects in list which correspond to members of
1078 *set and appending them to ports_ready. result is converted to a
1079 vector if list_or_vec is a vector. */
1081 retrieve_select_type (SELECT_TYPE
*set
, SCM ports_ready
, SCM list_or_vec
)
1083 SCM answer_list
= ports_ready
;
1085 if (SCM_VECTORP (list_or_vec
))
1087 int i
= SCM_VECTOR_LENGTH (list_or_vec
);
1088 SCM
const *ve
= SCM_VELTS (list_or_vec
);
1092 answer_list
= get_element (set
, ve
[i
], answer_list
);
1094 return scm_vector (answer_list
);
1098 /* list_or_vec must be a list. */
1099 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
1101 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
1102 list_or_vec
= SCM_CDR (list_or_vec
);
1108 /* Static helper functions above refer to s_scm_select directly as s_select */
1109 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
1110 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
1111 "This procedure has a variety of uses: waiting for the ability\n"
1112 "to provide input, accept output, or the existence of\n"
1113 "exceptional conditions on a collection of ports or file\n"
1114 "descriptors, or waiting for a timeout to occur.\n"
1115 "It also returns if interrupted by a signal.\n\n"
1116 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
1117 "vectors, with each member a port or a file descriptor.\n"
1118 "The value returned is a list of three corresponding\n"
1119 "lists or vectors containing only the members which meet the\n"
1120 "specified requirement. The ability of port buffers to\n"
1121 "provide input or accept output is taken into account.\n"
1122 "Ordering of the input lists or vectors is not preserved.\n\n"
1123 "The optional arguments @var{secs} and @var{usecs} specify the\n"
1124 "timeout. Either @var{secs} can be specified alone, as\n"
1125 "either an integer or a real number, or both @var{secs} and\n"
1126 "@var{usecs} can be specified as integers, in which case\n"
1127 "@var{usecs} is an additional timeout expressed in\n"
1128 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
1129 "select will wait for as long as it takes for one of the other\n"
1130 "conditions to be satisfied.\n\n"
1131 "The scsh version of @code{select} differs as follows:\n"
1132 "Only vectors are accepted for the first three arguments.\n"
1133 "The @var{usecs} argument is not supported.\n"
1134 "Multiple values are returned instead of a list.\n"
1135 "Duplicates in the input vectors appear only once in output.\n"
1136 "An additional @code{select!} interface is provided.")
1137 #define FUNC_NAME s_scm_select
1139 struct timeval timeout
;
1140 struct timeval
* time_ptr
;
1141 SELECT_TYPE read_set
;
1142 SELECT_TYPE write_set
;
1143 SELECT_TYPE except_set
;
1147 /* these lists accumulate ports which are ready due to buffering.
1148 their file descriptors don't need to be added to the select sets. */
1149 SCM read_ports_ready
= SCM_EOL
;
1150 SCM write_ports_ready
= SCM_EOL
;
1153 if (SCM_VECTORP (reads
))
1155 read_count
= SCM_VECTOR_LENGTH (reads
);
1159 read_count
= scm_ilength (reads
);
1160 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
1162 if (SCM_VECTORP (writes
))
1164 write_count
= SCM_VECTOR_LENGTH (writes
);
1168 write_count
= scm_ilength (writes
);
1169 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
1171 if (SCM_VECTORP (excepts
))
1173 except_count
= SCM_VECTOR_LENGTH (excepts
);
1177 except_count
= scm_ilength (excepts
);
1178 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
1181 FD_ZERO (&read_set
);
1182 FD_ZERO (&write_set
);
1183 FD_ZERO (&except_set
);
1185 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
1188 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
1190 int except_max
= fill_select_type (&except_set
, NULL
,
1193 if (write_max
> max_fd
)
1195 if (except_max
> max_fd
)
1196 max_fd
= except_max
;
1199 /* if there's a port with a ready buffer, don't block, just
1200 check for ready file descriptors. */
1201 if (!SCM_NULLP (read_ports_ready
) || !SCM_NULLP (write_ports_ready
))
1204 timeout
.tv_usec
= 0;
1205 time_ptr
= &timeout
;
1207 else if (SCM_UNBNDP (secs
) || SCM_FALSEP (secs
))
1211 if (SCM_INUMP (secs
))
1213 timeout
.tv_sec
= SCM_INUM (secs
);
1214 if (SCM_UNBNDP (usecs
))
1215 timeout
.tv_usec
= 0;
1218 SCM_VALIDATE_INUM (5, usecs
);
1219 timeout
.tv_usec
= SCM_INUM (usecs
);
1224 double fl
= scm_num2dbl (secs
, FUNC_NAME
);
1226 if (!SCM_UNBNDP (usecs
))
1227 SCM_WRONG_TYPE_ARG (4, secs
);
1229 SCM_OUT_OF_RANGE (4, secs
);
1230 timeout
.tv_sec
= (long) fl
;
1231 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
1233 time_ptr
= &timeout
;
1237 int rv
= scm_internal_select (max_fd
+ 1,
1238 &read_set
, &write_set
, &except_set
,
1243 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
1244 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
1245 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
1248 #endif /* HAVE_SELECT */
1253 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
1254 (SCM object
, SCM cmd
, SCM value
),
1255 "Apply @var{command} to the specified file descriptor or the underlying\n"
1256 "file descriptor of the specified port. @var{value} is an optional\n"
1257 "integer argument.\n\n"
1258 "Values for @var{command} are:\n\n"
1261 "Duplicate a file descriptor\n"
1263 "Get flags associated with the file descriptor.\n"
1265 "Set flags associated with the file descriptor to @var{value}.\n"
1267 "Get flags associated with the open file.\n"
1269 "Set flags associated with the open file to @var{value}\n"
1271 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
1273 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
1274 "@item FD_CLOEXEC\n"
1275 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
1278 #define FUNC_NAME s_scm_fcntl
1284 object
= SCM_COERCE_OUTPORT (object
);
1286 SCM_VALIDATE_INUM (2, cmd
);
1287 if (SCM_OPFPORTP (object
))
1288 fdes
= SCM_FPORT_FDES (object
);
1291 SCM_VALIDATE_INUM (1, object
);
1292 fdes
= SCM_INUM (object
);
1295 if (SCM_UNBNDP (value
)) {
1298 SCM_VALIDATE_INUM_COPY (SCM_ARG3
, value
, ivalue
);
1301 SCM_SYSCALL (rv
= fcntl (fdes
, SCM_INUM (cmd
), ivalue
));
1304 return SCM_MAKINUM (rv
);
1307 #endif /* HAVE_FCNTL */
1309 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
1311 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1312 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1313 "file descriptor is fsync'd.\n"
1314 "The return value is unspecified.")
1315 #define FUNC_NAME s_scm_fsync
1319 object
= SCM_COERCE_OUTPORT (object
);
1321 if (SCM_OPFPORTP (object
))
1324 fdes
= SCM_FPORT_FDES (object
);
1328 SCM_VALIDATE_INUM (1, object
);
1329 fdes
= SCM_INUM (object
);
1331 if (fsync (fdes
) == -1)
1333 return SCM_UNSPECIFIED
;
1338 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1339 (SCM oldpath
, SCM newpath
),
1340 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1341 "@var{path-from}. The return value is unspecified.")
1342 #define FUNC_NAME s_scm_symlink
1346 SCM_VALIDATE_STRING (1, oldpath
);
1347 SCM_VALIDATE_STRING (2, newpath
);
1348 SCM_SYSCALL (val
= symlink (SCM_STRING_CHARS (oldpath
), SCM_STRING_CHARS (newpath
)));
1351 return SCM_UNSPECIFIED
;
1354 #endif /* HAVE_SYMLINK */
1356 #ifdef HAVE_READLINK
1357 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1359 "Return the value of the symbolic link named by @var{path} (a\n"
1360 "string), i.e., the file that the link points to.")
1361 #define FUNC_NAME s_scm_readlink
1367 SCM_VALIDATE_STRING (1, path
);
1368 buf
= scm_malloc (size
);
1369 while ((rv
= readlink (SCM_STRING_CHARS (path
), buf
, size
)) == size
)
1373 buf
= scm_malloc (size
);
1377 result
= scm_mem2string (buf
, rv
);
1382 #endif /* HAVE_READLINK */
1385 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
1387 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
1388 "it will return information about a symbolic link itself, not the\n"
1389 "file it points to. @var{path} must be a string.")
1390 #define FUNC_NAME s_scm_lstat
1393 struct stat stat_temp
;
1395 SCM_VALIDATE_STRING (1, str
);
1396 SCM_SYSCALL (rv
= lstat (SCM_STRING_CHARS (str
), &stat_temp
));
1401 SCM_SYSERROR_MSG ("~A: ~S",
1402 scm_list_2 (scm_makfrom0str (strerror (errno
)), str
),
1405 return scm_stat2scm(&stat_temp
);
1408 #endif /* HAVE_LSTAT */
1410 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1411 (SCM oldfile
, SCM newfile
),
1412 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1413 "The return value is unspecified.")
1414 #define FUNC_NAME s_scm_copy_file
1419 struct stat oldstat
;
1421 SCM_VALIDATE_STRING (1, oldfile
);
1422 SCM_VALIDATE_STRING (2, newfile
);
1423 if (stat (SCM_STRING_CHARS (oldfile
), &oldstat
) == -1)
1425 oldfd
= open (SCM_STRING_CHARS (oldfile
), O_RDONLY
);
1429 /* use POSIX flags instead of 07777?. */
1430 newfd
= open (SCM_STRING_CHARS (newfile
), O_WRONLY
| O_CREAT
| O_TRUNC
,
1431 oldstat
.st_mode
& 07777);
1435 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1436 if (write (newfd
, buf
, n
) != n
)
1443 if (close (newfd
) == -1)
1445 return SCM_UNSPECIFIED
;
1450 /* Filename manipulation */
1454 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1456 "Return the directory name component of the file name\n"
1457 "@var{filename}. If @var{filename} does not contain a directory\n"
1458 "component, @code{.} is returned.")
1459 #define FUNC_NAME s_scm_dirname
1463 unsigned long int len
;
1465 SCM_VALIDATE_STRING (1, filename
);
1467 s
= SCM_STRING_CHARS (filename
);
1468 len
= SCM_STRING_LENGTH (filename
);
1472 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1473 while (i
>= 0 && (s
[i
] != '/' && s
[i
] != '\\')) --i
;
1474 while (i
>= 0 && (s
[i
] == '/' || s
[i
] == '\\')) --i
;
1476 while (i
>= 0 && s
[i
] == '/') --i
;
1477 while (i
>= 0 && s
[i
] != '/') --i
;
1478 while (i
>= 0 && s
[i
] == '/') --i
;
1479 #endif /* ndef __MINGW32__ */
1483 if (len
> 0 && (s
[0] == '/' || s
[0] == '\\'))
1485 if (len
> 0 && s
[0] == '/')
1486 #endif /* ndef __MINGW32__ */
1487 return scm_substring (filename
, SCM_INUM0
, SCM_MAKINUM (1));
1489 return scm_dot_string
;
1492 return scm_substring (filename
, SCM_INUM0
, SCM_MAKINUM (i
+ 1));
1496 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1497 (SCM filename
, SCM suffix
),
1498 "Return the base name of the file name @var{filename}. The\n"
1499 "base name is the file name without any directory components.\n"
1500 "If @var{suffix} is provided, and is equal to the end of\n"
1501 "@var{basename}, it is removed also.")
1502 #define FUNC_NAME s_scm_basename
1507 SCM_VALIDATE_STRING (1, filename
);
1508 f
= SCM_STRING_CHARS (filename
);
1509 len
= SCM_STRING_LENGTH (filename
);
1511 if (SCM_UNBNDP (suffix
))
1515 SCM_VALIDATE_STRING (2, suffix
);
1516 s
= SCM_STRING_CHARS (suffix
);
1517 j
= SCM_STRING_LENGTH (suffix
) - 1;
1521 while (i
>= 0 && (f
[i
] == '/' || f
[i
] == '\\')) --i
;
1523 while (i
>= 0 && f
[i
] == '/') --i
;
1524 #endif /* ndef __MINGW32__ */
1526 while (i
>= 0 && j
>= 0 && f
[i
] == s
[j
]) --i
, --j
;
1530 while (i
>= 0 && (f
[i
] != '/' || f
[i
] != '\\')) --i
;
1532 while (i
>= 0 && f
[i
] != '/') --i
;
1533 #endif /* ndef __MINGW32__ */
1537 if (len
> 0 && (f
[0] == '/' || f
[i
] == '\\'))
1539 if (len
> 0 && f
[0] == '/')
1540 #endif /* ndef __MINGW32__ */
1541 return scm_substring (filename
, SCM_INUM0
, SCM_MAKINUM (1));
1543 return scm_dot_string
;
1546 return scm_substring (filename
, SCM_MAKINUM (i
+ 1), SCM_MAKINUM (end
+ 1));
1557 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1558 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1559 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1561 scm_dot_string
= scm_permanent_object (scm_makfrom0str ("."));
1564 scm_c_define ("O_RDONLY", scm_long2num (O_RDONLY
));
1567 scm_c_define ("O_WRONLY", scm_long2num (O_WRONLY
));
1570 scm_c_define ("O_RDWR", scm_long2num (O_RDWR
));
1573 scm_c_define ("O_CREAT", scm_long2num (O_CREAT
));
1576 scm_c_define ("O_EXCL", scm_long2num (O_EXCL
));
1579 scm_c_define ("O_NOCTTY", scm_long2num (O_NOCTTY
));
1582 scm_c_define ("O_TRUNC", scm_long2num (O_TRUNC
));
1585 scm_c_define ("O_APPEND", scm_long2num (O_APPEND
));
1588 scm_c_define ("O_NONBLOCK", scm_long2num (O_NONBLOCK
));
1591 scm_c_define ("O_NDELAY", scm_long2num (O_NDELAY
));
1594 scm_c_define ("O_SYNC", scm_long2num (O_SYNC
));
1598 scm_c_define ("F_DUPFD", scm_long2num (F_DUPFD
));
1601 scm_c_define ("F_GETFD", scm_long2num (F_GETFD
));
1604 scm_c_define ("F_SETFD", scm_long2num (F_SETFD
));
1607 scm_c_define ("F_GETFL", scm_long2num (F_GETFL
));
1610 scm_c_define ("F_SETFL", scm_long2num (F_SETFL
));
1613 scm_c_define ("F_GETOWN", scm_long2num (F_GETOWN
));
1616 scm_c_define ("F_SETOWN", scm_long2num (F_SETOWN
));
1619 scm_c_define ("FD_CLOEXEC", scm_long2num (FD_CLOEXEC
));
1622 #include "libguile/filesys.x"