-/* Copyright (C) 1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
+/* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice. */
-/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
- gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
\f
#include <stdio.h>
#include "libguile/iselect.h"
#include "libguile/strings.h"
#include "libguile/vectors.h"
+#include "libguile/lang.h"
#include "libguile/validate.h"
#include "libguile/filesys.h"
#include <io.h>
#endif
+#ifdef HAVE_DIRECT_H
+#include <direct.h>
+#endif
+
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
+#ifdef HAVE_PWD_H
#include <pwd.h>
+#endif
-#if HAVE_DIRENT_H
+#if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
+# include "win32-dirent.h"
+# define NAMLEN(dirent) strlen((dirent)->d_name)
+#elif HAVE_DIRENT_H
# include <dirent.h>
# define NAMLEN(dirent) strlen((dirent)->d_name)
#else
#if defined (S_IFSOCK) && ! defined (S_ISSOCK)
#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
#endif
+
+/* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
+ compiler like BorlandC or MSVC has none of these macros defined. */
+#ifdef __MINGW32__
+
+# ifdef _S_IFIFO
+# undef _S_IFIFO
+# endif
+# ifdef _S_IFCHR
+# undef _S_IFCHR
+# endif
+# ifdef _S_IFBLK
+# undef _S_IFBLK
+# endif
+# ifdef _S_IFDIR
+# undef _S_IFDIR
+# endif
+# ifdef _S_IFREG
+# undef _S_IFREG
+# endif
+# ifdef _S_IFSOCK
+# undef _S_IFSOCK
+# endif
+
+# define _S_IFIFO 0x1000 /* FIFO */
+# define _S_IFCHR 0x2000 /* Character */
+# define _S_IFBLK 0x3000 /* Block */
+# define _S_IFDIR 0x4000 /* Directory */
+# define _S_IFREG 0x8000 /* Regular */
+# define _S_IFSOCK 0xC000 /* Socket */
+
+# ifdef S_ISBLK
+# undef S_ISBLK
+# endif
+# ifdef S_ISFIFO
+# undef S_ISFIFO
+# endif
+# ifdef S_ISCHR
+# undef S_ISCHR
+# endif
+# ifdef S_ISDIR
+# undef S_ISDIR
+# endif
+# ifdef S_ISREG
+# undef S_ISREG
+# endif
+# ifdef S_ISSOCK
+# undef S_ISSOCK
+# endif
+
+# define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
+# define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
+# define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
+# define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
+# define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
+# define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
+
+#endif /* __MINGW32__ */
+
+/* Some more definitions for the native Windows port. */
+#ifdef __MINGW32__
+# define mkdir(path, mode) mkdir (path)
+# define fsync(fd) _commit (fd)
+# define fchmod(fd, mode) (-1)
+#endif /* __MINGW32__ */
\f
/* {Permissions}
*/
+#ifdef HAVE_CHOWN
SCM_DEFINE (scm_chown, "chown", 3, 0, 0,
(SCM object, SCM owner, SCM group),
"Change the ownership and group of the file referred to by @var{object} to\n"
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2,owner);
- SCM_VALIDATE_INUM (3,group);
+ SCM_VALIDATE_INUM (2, owner);
+ SCM_VALIDATE_INUM (3, group);
#ifdef HAVE_FCHOWN
if (SCM_INUMP (object) || (SCM_OPFPORTP (object)))
{
#endif
{
SCM_VALIDATE_STRING (1, object);
- SCM_STRING_COERCE_0TERMINATION_X (object);
SCM_SYSCALL (rv = chown (SCM_STRING_CHARS (object),
SCM_INUM (owner), SCM_INUM (group)));
}
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
+#endif /* HAVE_CHOWN */
SCM_DEFINE (scm_chmod, "chmod", 2, 0, 0,
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2,mode);
+ SCM_VALIDATE_INUM (2, mode);
if (SCM_INUMP (object) || SCM_OPFPORTP (object))
{
if (SCM_INUMP (object))
else
{
SCM_VALIDATE_STRING (1, object);
- SCM_STRING_COERCE_0TERMINATION_X (object);
SCM_SYSCALL (rv = chmod (SCM_STRING_CHARS (object), SCM_INUM (mode)));
}
if (rv == -1)
SCM_DEFINE (scm_umask, "umask", 0, 1, 0,
(SCM mode),
- "If @var{mode} is omitted, retuns a decimal number representing the current\n"
+ "If @var{mode} is omitted, returns a decimal number representing the current\n"
"file creation mask. Otherwise the file creation mask is set to\n"
"@var{mode} and the previous value is returned.\n\n"
"E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
}
else
{
- SCM_VALIDATE_INUM (1,mode);
+ SCM_VALIDATE_INUM (1, mode);
mask = umask (SCM_INUM (mode));
}
return SCM_MAKINUM (mask);
int imode;
SCM_VALIDATE_STRING (1, path);
- SCM_STRING_COERCE_0TERMINATION_X (path);
iflags = SCM_NUM2INT (2, flags);
imode = SCM_NUM2INT_DEF (3, mode, 0666);
SCM_SYSCALL (fd = open (SCM_STRING_CHARS (path), iflags, imode));
"Open the file read-only.\n"
"@end defvar\n"
"@defvar O_WRONLY\n"
- "Open the file write-only. \n"
+ "Open the file write-only.\n"
"@end defvar\n"
"@defvar O_RDWR\n"
"Open the file read/write.\n"
SCM_DEFINE (scm_close, "close", 1, 0, 0,
(SCM fd_or_port),
- "Similar to close-port (@pxref{Generic Port Operations, close-port}),\n"
+ "Similar to close-port (@pxref{Closing, close-port}),\n"
"but also works on file descriptors. A side\n"
"effect of closing a file descriptor is that any ports using that file\n"
"descriptor are moved to a different file descriptor and have\n"
if (SCM_PORTP (fd_or_port))
return scm_close_port (fd_or_port);
- SCM_VALIDATE_INUM (1,fd_or_port);
+ SCM_VALIDATE_INUM (1, fd_or_port);
fd = SCM_INUM (fd_or_port);
scm_evict_ports (fd); /* see scsh manual. */
SCM_SYSCALL (rv = close (fd));
scm_stat2scm (struct stat *stat_temp)
{
SCM ans = scm_c_make_vector (15, SCM_UNSPECIFIED);
- SCM *ve = SCM_VELTS (ans);
- ve[0] = scm_ulong2num ((unsigned long) stat_temp->st_dev);
- ve[1] = scm_ulong2num ((unsigned long) stat_temp->st_ino);
- ve[2] = scm_ulong2num ((unsigned long) stat_temp->st_mode);
- ve[3] = scm_ulong2num ((unsigned long) stat_temp->st_nlink);
- ve[4] = scm_ulong2num ((unsigned long) stat_temp->st_uid);
- ve[5] = scm_ulong2num ((unsigned long) stat_temp->st_gid);
+ SCM_VECTOR_SET(ans, 0, scm_ulong2num ((unsigned long) stat_temp->st_dev));
+ SCM_VECTOR_SET(ans, 1, scm_ulong2num ((unsigned long) stat_temp->st_ino));
+ SCM_VECTOR_SET(ans, 2, scm_ulong2num ((unsigned long) stat_temp->st_mode));
+ SCM_VECTOR_SET(ans, 3, scm_ulong2num ((unsigned long) stat_temp->st_nlink));
+ SCM_VECTOR_SET(ans, 4, scm_ulong2num ((unsigned long) stat_temp->st_uid));
+ SCM_VECTOR_SET(ans, 5, scm_ulong2num ((unsigned long) stat_temp->st_gid));
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- ve[6] = scm_ulong2num ((unsigned long) stat_temp->st_rdev);
+ SCM_VECTOR_SET(ans, 6, scm_ulong2num ((unsigned long) stat_temp->st_rdev));
#else
- ve[6] = SCM_BOOL_F;
+ SCM_VECTOR_SET(ans, 6, SCM_BOOL_F);
#endif
- ve[7] = scm_ulong2num ((unsigned long) stat_temp->st_size);
- ve[8] = scm_ulong2num ((unsigned long) stat_temp->st_atime);
- ve[9] = scm_ulong2num ((unsigned long) stat_temp->st_mtime);
- ve[10] = scm_ulong2num ((unsigned long) stat_temp->st_ctime);
+ SCM_VECTOR_SET(ans, 7, scm_ulong2num ((unsigned long) stat_temp->st_size));
+ SCM_VECTOR_SET(ans, 8, scm_ulong2num ((unsigned long) stat_temp->st_atime));
+ SCM_VECTOR_SET(ans, 9, scm_ulong2num ((unsigned long) stat_temp->st_mtime));
+ SCM_VECTOR_SET(ans, 10, scm_ulong2num ((unsigned long) stat_temp->st_ctime));
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
- ve[11] = scm_ulong2num ((unsigned long) stat_temp->st_blksize);
+ SCM_VECTOR_SET(ans, 11, scm_ulong2num ((unsigned long) stat_temp->st_blksize));
#else
- ve[11] = scm_ulong2num (4096L);
+ SCM_VECTOR_SET(ans, 11, scm_ulong2num (4096L));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
- ve[12] = scm_ulong2num ((unsigned long) stat_temp->st_blocks);
+ SCM_VECTOR_SET(ans, 12, scm_ulong2num ((unsigned long) stat_temp->st_blocks));
#else
- ve[12] = SCM_BOOL_F;
+ SCM_VECTOR_SET(ans, 12, SCM_BOOL_F);
#endif
{
int mode = stat_temp->st_mode;
if (S_ISREG (mode))
- ve[13] = scm_sym_regular;
+ SCM_VECTOR_SET(ans, 13, scm_sym_regular);
else if (S_ISDIR (mode))
- ve[13] = scm_sym_directory;
+ SCM_VECTOR_SET(ans, 13, scm_sym_directory);
#ifdef HAVE_S_ISLNK
else if (S_ISLNK (mode))
- ve[13] = scm_sym_symlink;
+ SCM_VECTOR_SET(ans, 13, scm_sym_symlink);
#endif
else if (S_ISBLK (mode))
- ve[13] = scm_sym_block_special;
+ SCM_VECTOR_SET(ans, 13, scm_sym_block_special);
else if (S_ISCHR (mode))
- ve[13] = scm_sym_char_special;
+ SCM_VECTOR_SET(ans, 13, scm_sym_char_special);
else if (S_ISFIFO (mode))
- ve[13] = scm_sym_fifo;
+ SCM_VECTOR_SET(ans, 13, scm_sym_fifo);
#ifdef S_ISSOCK
else if (S_ISSOCK (mode))
- ve[13] = scm_sym_sock;
+ SCM_VECTOR_SET(ans, 13, scm_sym_sock);
#endif
else
- ve[13] = scm_sym_unknown;
+ SCM_VECTOR_SET(ans, 13, scm_sym_unknown);
- ve[14] = SCM_MAKINUM ((~S_IFMT) & mode);
+ SCM_VECTOR_SET(ans, 14, SCM_MAKINUM ((~S_IFMT) & mode));
/* the layout of the bits in ve[14] is intended to be portable.
If there are systems that don't follow the usual convention,
tmp <<= 1;
if (S_IXOTH & mode) tmp += 1;
- ve[14] = SCM_MAKINUM (tmp);
+ SCM_VECTOR_SET(ans, 14, SCM_MAKINUM (tmp));
*/
}
return ans;
}
+#ifdef __MINGW32__
+/*
+ * Try getting the appropiate stat buffer for a given file descriptor
+ * under Windows. It differentiates between file, pipe and socket
+ * descriptors.
+ */
+static int fstat_Win32 (int fdes, struct stat *buf)
+{
+ int error, optlen = sizeof (int);
+
+ memset (buf, 0, sizeof (struct stat));
+
+ /* Is this a socket ? */
+ if (getsockopt (fdes, SOL_SOCKET, SO_ERROR, (void *) &error, &optlen) >= 0)
+ {
+ buf->st_mode = _S_IFSOCK | _S_IREAD | _S_IWRITE | _S_IEXEC;
+ buf->st_nlink = 1;
+ buf->st_atime = buf->st_ctime = buf->st_mtime = time (NULL);
+ return 0;
+ }
+ /* Maybe a regular file or pipe ? */
+ return fstat (fdes, buf);
+}
+#endif /* __MINGW32__ */
+
SCM_DEFINE (scm_stat, "stat", 1, 0, 0,
(SCM object),
"Return an object containing various information about the file\n"
if (SCM_INUMP (object))
{
+#ifdef __MINGW32__
+ SCM_SYSCALL (rv = fstat_Win32 (SCM_INUM (object), &stat_temp));
+#else
SCM_SYSCALL (rv = fstat (SCM_INUM (object), &stat_temp));
+#endif
}
else if (SCM_STRINGP (object))
{
- SCM_STRING_COERCE_0TERMINATION_X (object);
+#ifdef __MINGW32__
+ char *p, *file = strdup (SCM_STRING_CHARS (object));
+ p = file + strlen (file) - 1;
+ while (p > file && (*p == '/' || *p == '\\'))
+ *p-- = '\0';
+ SCM_SYSCALL (rv = stat (file, &stat_temp));
+ free (file);
+#else
SCM_SYSCALL (rv = stat (SCM_STRING_CHARS (object), &stat_temp));
+#endif
}
else
{
object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_OPFPORT (1, object);
fdes = SCM_FPORT_FDES (object);
+#ifdef __MINGW32__
+ SCM_SYSCALL (rv = fstat_Win32 (fdes, &stat_temp));
+#else
SCM_SYSCALL (rv = fstat (fdes, &stat_temp));
+#endif
}
if (rv == -1)
int en = errno;
SCM_SYSERROR_MSG ("~A: ~S",
- SCM_LIST2 (scm_makfrom0str (strerror (errno)), object),
+ scm_list_2 (scm_makfrom0str (strerror (errno)),
+ object),
en);
}
return scm_stat2scm (&stat_temp);
/* {Modifying Directories}
*/
+#ifdef HAVE_LINK
SCM_DEFINE (scm_link, "link", 2, 0, 0,
(SCM oldpath, SCM newpath),
"Creates a new name @var{newpath} in the file system for the\n"
int val;
SCM_VALIDATE_STRING (1, oldpath);
- SCM_STRING_COERCE_0TERMINATION_X (oldpath);
SCM_VALIDATE_STRING (2, newpath);
- SCM_STRING_COERCE_0TERMINATION_X (newpath);
SCM_SYSCALL (val = link (SCM_STRING_CHARS (oldpath),
SCM_STRING_CHARS (newpath)));
if (val != 0)
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
+#endif /* HAVE_LINK */
int rv;
SCM_VALIDATE_STRING (1, oldname);
SCM_VALIDATE_STRING (2, newname);
- SCM_STRING_COERCE_0TERMINATION_X (oldname);
- SCM_STRING_COERCE_0TERMINATION_X (newname);
#ifdef HAVE_RENAME
SCM_SYSCALL (rv = rename (SCM_STRING_CHARS (oldname), SCM_STRING_CHARS (newname)));
#else
{
int ans;
SCM_VALIDATE_STRING (1, str);
- SCM_STRING_COERCE_0TERMINATION_X (str);
SCM_SYSCALL (ans = unlink (SCM_STRING_CHARS (str)));
if (ans != 0)
SCM_SYSERROR;
int rv;
mode_t mask;
SCM_VALIDATE_STRING (1, path);
- SCM_STRING_COERCE_0TERMINATION_X (path);
if (SCM_UNBNDP (mode))
{
mask = umask (0);
}
else
{
- SCM_VALIDATE_INUM (2,mode);
+ SCM_VALIDATE_INUM (2, mode);
SCM_SYSCALL (rv = mkdir (SCM_STRING_CHARS (path), SCM_INUM (mode)));
}
if (rv != 0)
int val;
SCM_VALIDATE_STRING (1, path);
- SCM_STRING_COERCE_0TERMINATION_X (path);
SCM_SYSCALL (val = rmdir (SCM_STRING_CHARS (path)));
if (val != 0)
SCM_SYSERROR;
{
DIR *ds;
SCM_VALIDATE_STRING (1, dirname);
- SCM_STRING_COERCE_0TERMINATION_X (dirname);
SCM_SYSCALL (ds = opendir (SCM_STRING_CHARS (dirname)));
if (ds == NULL)
SCM_SYSERROR;
SCM_VALIDATE_DIR (1, port);
if (!SCM_DIR_OPEN_P (port))
- SCM_MISC_ERROR ("Directory ~S is not open.", SCM_LIST1 (port));
+ SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port));
errno = 0;
SCM_SYSCALL (rdent = readdir ((DIR *) SCM_CELL_WORD_1 (port)));
{
SCM_VALIDATE_DIR (1, port);
if (!SCM_DIR_OPEN_P (port))
- SCM_MISC_ERROR ("Directory ~S is not open.", SCM_LIST1 (port));
+ SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port));
rewinddir ((DIR *) SCM_CELL_WORD_1 (port));
int ans;
SCM_VALIDATE_STRING (1, str);
- SCM_STRING_COERCE_0TERMINATION_X (str);
SCM_SYSCALL (ans = chdir (SCM_STRING_CHARS (str)));
if (ans != 0)
SCM_SYSERROR;
char *wd;
SCM result;
- wd = scm_must_malloc (size, FUNC_NAME);
+ wd = scm_malloc (size);
while ((rv = getcwd (wd, size)) == 0 && errno == ERANGE)
{
- scm_must_free (wd);
+ free (wd);
size *= 2;
- wd = scm_must_malloc (size, FUNC_NAME);
+ wd = scm_malloc (size);
}
if (rv == 0)
SCM_SYSERROR;
result = scm_mem2string (wd, strlen (wd));
- scm_must_free (wd);
+ free (wd);
return result;
}
#undef FUNC_NAME
if (SCM_VECTORP (list_or_vec))
{
int i = SCM_VECTOR_LENGTH (list_or_vec);
- SCM *ve = SCM_VELTS (list_or_vec);
+ SCM const *ve = SCM_VELTS (list_or_vec);
while (--i >= 0)
{
}
else
{
- while (!SCM_NULLP (list_or_vec))
+ while (!SCM_NULL_OR_NIL_P (list_or_vec))
{
int fd = set_element (set, ports_ready, SCM_CAR (list_or_vec), pos);
if (SCM_VECTORP (list_or_vec))
{
int i = SCM_VECTOR_LENGTH (list_or_vec);
- SCM *ve = SCM_VELTS (list_or_vec);
+ SCM const *ve = SCM_VELTS (list_or_vec);
while (--i >= 0)
{
else
{
/* list_or_vec must be a list. */
- while (!SCM_NULLP (list_or_vec))
+ while (!SCM_NULL_OR_NIL_P (list_or_vec))
{
answer_list = get_element (set, SCM_CAR (list_or_vec), answer_list);
list_or_vec = SCM_CDR (list_or_vec);
SCM_DEFINE (scm_select, "select", 3, 2, 0,
(SCM reads, SCM writes, SCM excepts, SCM secs, SCM usecs),
"This procedure has a variety of uses: waiting for the ability\n"
- "to provide input, accept output, or the existance of\n"
+ "to provide input, accept output, or the existence of\n"
"exceptional conditions on a collection of ports or file\n"
"descriptors, or waiting for a timeout to occur.\n"
"It also returns if interrupted by a signal.\n\n"
"The @var{usecs} argument is not supported.\n"
"Multiple values are returned instead of a list.\n"
"Duplicates in the input vectors appear only once in output.\n"
- "An additional @code{select!} interface is provided.\n"
- )
+ "An additional @code{select!} interface is provided.")
#define FUNC_NAME s_scm_select
{
struct timeval timeout;
timeout.tv_usec = 0;
else
{
- SCM_VALIDATE_INUM (5,usecs);
+ SCM_VALIDATE_INUM (5, usecs);
timeout.tv_usec = SCM_INUM (usecs);
}
}
}
{
-#ifdef GUILE_ISELECT
int rv = scm_internal_select (max_fd + 1,
&read_set, &write_set, &except_set,
time_ptr);
-#else
- int rv = select (max_fd + 1,
- &read_set, &write_set, &except_set, time_ptr);
-#endif
if (rv < 0)
SCM_SYSERROR;
}
- return SCM_LIST3 (retrieve_select_type (&read_set, read_ports_ready, reads),
- retrieve_select_type (&write_set, write_ports_ready, writes),
- retrieve_select_type (&except_set, SCM_EOL, excepts));
+ return scm_list_3 (retrieve_select_type (&read_set, read_ports_ready, reads),
+ retrieve_select_type (&write_set, write_ports_ready, writes),
+ retrieve_select_type (&except_set, SCM_EOL, excepts));
}
#undef FUNC_NAME
#endif /* HAVE_SELECT */
\f
+#ifdef HAVE_FCNTL
SCM_DEFINE (scm_fcntl, "fcntl", 2, 1, 0,
(SCM object, SCM cmd, SCM value),
"Apply @var{command} to the specified file descriptor or the underlying\n"
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2,cmd);
+ SCM_VALIDATE_INUM (2, cmd);
if (SCM_OPFPORTP (object))
fdes = SCM_FPORT_FDES (object);
else
{
- SCM_VALIDATE_INUM (1,object);
+ SCM_VALIDATE_INUM (1, object);
fdes = SCM_INUM (object);
}
return SCM_MAKINUM (rv);
}
#undef FUNC_NAME
+#endif /* HAVE_FCNTL */
SCM_DEFINE (scm_fsync, "fsync", 1, 0, 0,
(SCM object),
}
else
{
- SCM_VALIDATE_INUM (1,object);
+ SCM_VALIDATE_INUM (1, object);
fdes = SCM_INUM (object);
}
if (fsync (fdes) == -1)
SCM_VALIDATE_STRING (1, oldpath);
SCM_VALIDATE_STRING (2, newpath);
- SCM_STRING_COERCE_0TERMINATION_X (oldpath);
- SCM_STRING_COERCE_0TERMINATION_X (newpath);
SCM_SYSCALL (val = symlink (SCM_STRING_CHARS (oldpath), SCM_STRING_CHARS (newpath)));
if (val != 0)
SCM_SYSERROR;
char *buf;
SCM result;
SCM_VALIDATE_STRING (1, path);
- SCM_STRING_COERCE_0TERMINATION_X (path);
- buf = scm_must_malloc (size, FUNC_NAME);
+ buf = scm_malloc (size);
while ((rv = readlink (SCM_STRING_CHARS (path), buf, size)) == size)
{
- scm_must_free (buf);
+ free (buf);
size *= 2;
- buf = scm_must_malloc (size, FUNC_NAME);
+ buf = scm_malloc (size);
}
if (rv == -1)
SCM_SYSERROR;
result = scm_mem2string (buf, rv);
- scm_must_free (buf);
+ free (buf);
return result;
}
#undef FUNC_NAME
SCM_DEFINE (scm_lstat, "lstat", 1, 0, 0,
(SCM str),
"Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
- "it will return information about a symbolic link itself, not the \n"
+ "it will return information about a symbolic link itself, not the\n"
"file it points to. @var{path} must be a string.")
#define FUNC_NAME s_scm_lstat
{
struct stat stat_temp;
SCM_VALIDATE_STRING (1, str);
- SCM_STRING_COERCE_0TERMINATION_X (str);
SCM_SYSCALL (rv = lstat (SCM_STRING_CHARS (str), &stat_temp));
if (rv != 0)
{
int en = errno;
SCM_SYSERROR_MSG ("~A: ~S",
- SCM_LIST2 (scm_makfrom0str (strerror (errno)), str),
+ scm_list_2 (scm_makfrom0str (strerror (errno)), str),
en);
}
return scm_stat2scm(&stat_temp);
struct stat oldstat;
SCM_VALIDATE_STRING (1, oldfile);
- SCM_STRING_COERCE_0TERMINATION_X (oldfile);
SCM_VALIDATE_STRING (2, newfile);
- SCM_STRING_COERCE_0TERMINATION_X (newfile);
if (stat (SCM_STRING_CHARS (oldfile), &oldstat) == -1)
SCM_SYSERROR;
oldfd = open (SCM_STRING_CHARS (oldfile), O_RDONLY);
long int i;
unsigned long int len;
- SCM_VALIDATE_STRING (1,filename);
+ SCM_VALIDATE_STRING (1, filename);
s = SCM_STRING_CHARS (filename);
len = SCM_STRING_LENGTH (filename);
i = len - 1;
+#ifdef __MINGW32__
+ while (i >= 0 && (s[i] == '/' || s[i] == '\\')) --i;
+ while (i >= 0 && (s[i] != '/' && s[i] != '\\')) --i;
+ while (i >= 0 && (s[i] == '/' || s[i] == '\\')) --i;
+#else
while (i >= 0 && s[i] == '/') --i;
while (i >= 0 && s[i] != '/') --i;
while (i >= 0 && s[i] == '/') --i;
+#endif /* ndef __MINGW32__ */
if (i < 0)
{
+#ifdef __MINGW32__
+ if (len > 0 && (s[0] == '/' || s[0] == '\\'))
+#else
if (len > 0 && s[0] == '/')
+#endif /* ndef __MINGW32__ */
return scm_substring (filename, SCM_INUM0, SCM_MAKINUM (1));
else
return scm_dot_string;
(SCM filename, SCM suffix),
"Return the base name of the file name @var{filename}. The\n"
"base name is the file name without any directory components.\n"
- "If @var{suffix} is privided, and is equal to the end of\n"
+ "If @var{suffix} is provided, and is equal to the end of\n"
"@var{basename}, it is removed also.")
#define FUNC_NAME s_scm_basename
{
char *f, *s = 0;
int i, j, len, end;
- SCM_VALIDATE_STRING (1,filename);
+ SCM_VALIDATE_STRING (1, filename);
f = SCM_STRING_CHARS (filename);
len = SCM_STRING_LENGTH (filename);
j = SCM_STRING_LENGTH (suffix) - 1;
}
i = len - 1;
+#ifdef __MINGW32__
+ while (i >= 0 && (f[i] == '/' || f[i] == '\\')) --i;
+#else
while (i >= 0 && f[i] == '/') --i;
+#endif /* ndef __MINGW32__ */
end = i;
while (i >= 0 && j >= 0 && f[i] == s[j]) --i, --j;
if (j == -1)
end = i;
+#ifdef __MINGW32__
+ while (i >= 0 && (f[i] != '/' || f[i] != '\\')) --i;
+#else
while (i >= 0 && f[i] != '/') --i;
+#endif /* ndef __MINGW32__ */
if (i == end)
{
+#ifdef __MINGW32__
+ if (len > 0 && (f[0] == '/' || f[i] == '\\'))
+#else
if (len > 0 && f[0] == '/')
+#endif /* ndef __MINGW32__ */
return scm_substring (filename, SCM_INUM0, SCM_MAKINUM (1));
else
return scm_dot_string;
scm_c_define ("FD_CLOEXEC", scm_long2num (FD_CLOEXEC));
#endif
-#ifndef SCM_MAGIC_SNARFER
#include "libguile/filesys.x"
-#endif
}
/*
HCoop / bpt / guile.git / blobdiff