*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
\f
+
+/* See stime.c for comments on why _POSIX_C_SOURCE is not always defined. */
#define _GNU_SOURCE /* ask glibc for everything */
-#define _POSIX_C_SOURCE 199506L /* for readdir_r elsewhere */
+#ifdef __hpux
+#define _POSIX_C_SOURCE 199506L /* for readdir_r */
+#endif
#if HAVE_CONFIG_H
# include <config.h>
#include "libguile/strings.h"
#include "libguile/vectors.h"
#include "libguile/lang.h"
+#include "libguile/dynwind.h"
#include "libguile/validate.h"
#include "libguile/filesys.h"
#endif /* __MINGW32__ */
\f
+/* Two helper macros for an often used pattern */
+
+#define STRING_SYSCALL(str,cstr,code) \
+ do { \
+ int eno; \
+ char *cstr = scm_to_locale_string (str); \
+ SCM_SYSCALL (code); \
+ eno = errno; free (cstr); errno = eno; \
+ } while (0)
+
+#define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
+ do { \
+ int eno; \
+ char *cstr1, *cstr2; \
+ scm_frame_begin (0); \
+ cstr1 = scm_to_locale_string (str1); \
+ scm_frame_free (cstr1); \
+ cstr2 = scm_to_locale_string (str2); \
+ scm_frame_free (cstr2); \
+ SCM_SYSCALL (code); \
+ eno = errno; scm_frame_end (); errno = eno; \
+ } while (0)
\f
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2, owner);
- SCM_VALIDATE_INUM (3, group);
#ifdef HAVE_FCHOWN
- if (SCM_INUMP (object) || (SCM_OPFPORTP (object)))
+ if (scm_is_integer (object) || (SCM_OPFPORTP (object)))
{
- int fdes = SCM_INUMP (object) ? SCM_INUM (object)
- : SCM_FPORT_FDES (object);
+ int fdes = (SCM_OPFPORTP (object)?
+ SCM_FPORT_FDES (object) : scm_to_int (object));
- SCM_SYSCALL (rv = fchown (fdes, SCM_INUM (owner), SCM_INUM (group)));
+ SCM_SYSCALL (rv = fchown (fdes, scm_to_int (owner), scm_to_int (group)));
}
else
#endif
{
- SCM_VALIDATE_STRING (1, object);
- SCM_SYSCALL (rv = chown (SCM_STRING_CHARS (object),
- SCM_INUM (owner), SCM_INUM (group)));
+ STRING_SYSCALL (object, c_object,
+ rv = chown (c_object,
+ scm_to_int (owner), scm_to_int (group)));
}
if (rv == -1)
SCM_SYSERROR;
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2, mode);
- if (SCM_INUMP (object) || SCM_OPFPORTP (object))
+ if (scm_is_integer (object) || SCM_OPFPORTP (object))
{
- if (SCM_INUMP (object))
- fdes = SCM_INUM (object);
+ if (scm_is_integer (object))
+ fdes = scm_to_int (object);
else
fdes = SCM_FPORT_FDES (object);
- SCM_SYSCALL (rv = fchmod (fdes, SCM_INUM (mode)));
+ SCM_SYSCALL (rv = fchmod (fdes, scm_to_int (mode)));
}
else
{
- SCM_VALIDATE_STRING (1, object);
- SCM_SYSCALL (rv = chmod (SCM_STRING_CHARS (object), SCM_INUM (mode)));
+ STRING_SYSCALL (object, c_object,
+ rv = chmod (c_object, scm_to_int (mode)));
}
if (rv == -1)
SCM_SYSERROR;
}
else
{
- SCM_VALIDATE_INUM (1, mode);
- mask = umask (SCM_INUM (mode));
+ mask = umask (scm_to_uint (mode));
}
- return SCM_I_MAKINUM (mask);
+ return scm_from_uint (mask);
}
#undef FUNC_NAME
int iflags;
int imode;
- SCM_VALIDATE_STRING (1, path);
iflags = SCM_NUM2INT (2, flags);
imode = SCM_NUM2INT_DEF (3, mode, 0666);
- SCM_SYSCALL (fd = open (SCM_STRING_CHARS (path), iflags, imode));
+ STRING_SYSCALL (path, c_path, fd = open (c_path, iflags, imode));
if (fd == -1)
SCM_SYSERROR;
- return SCM_I_MAKINUM (fd);
+ return scm_from_int (fd);
}
#undef FUNC_NAME
int fd;
int iflags;
- fd = SCM_INUM (scm_open_fdes (path, flags, mode));
+ fd = scm_to_int (scm_open_fdes (path, flags, mode));
iflags = SCM_NUM2INT (2, flags);
if (iflags & O_RDWR)
{
if (SCM_PORTP (fd_or_port))
return scm_close_port (fd_or_port);
- SCM_VALIDATE_INUM (1, fd_or_port);
- fd = SCM_INUM (fd_or_port);
+ fd = scm_to_int (fd_or_port);
scm_evict_ports (fd); /* see scsh manual. */
SCM_SYSCALL (rv = close (fd));
/* following scsh, closing an already closed file descriptor is
int c_fd;
int rv;
- SCM_VALIDATE_INUM_COPY (1, fd, c_fd);
+ c_fd = scm_to_int (fd);
SCM_SYSCALL (rv = close (c_fd));
if (rv < 0)
SCM_SYSERROR;
{
SCM ans = scm_c_make_vector (15, SCM_UNSPECIFIED);
- 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));
+ SCM_SIMPLE_VECTOR_SET(ans, 0, scm_from_ulong (stat_temp->st_dev));
+ SCM_SIMPLE_VECTOR_SET(ans, 1, scm_from_ulong (stat_temp->st_ino));
+ SCM_SIMPLE_VECTOR_SET(ans, 2, scm_from_ulong (stat_temp->st_mode));
+ SCM_SIMPLE_VECTOR_SET(ans, 3, scm_from_ulong (stat_temp->st_nlink));
+ SCM_SIMPLE_VECTOR_SET(ans, 4, scm_from_ulong (stat_temp->st_uid));
+ SCM_SIMPLE_VECTOR_SET(ans, 5, scm_from_ulong (stat_temp->st_gid));
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- SCM_VECTOR_SET(ans, 6, scm_ulong2num ((unsigned long) stat_temp->st_rdev));
+ SCM_SIMPLE_VECTOR_SET(ans, 6, scm_from_ulong (stat_temp->st_rdev));
#else
- SCM_VECTOR_SET(ans, 6, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET(ans, 6, SCM_BOOL_F);
#endif
- 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));
+ SCM_SIMPLE_VECTOR_SET(ans, 7, scm_from_ulong (stat_temp->st_size));
+ SCM_SIMPLE_VECTOR_SET(ans, 8, scm_from_ulong (stat_temp->st_atime));
+ SCM_SIMPLE_VECTOR_SET(ans, 9, scm_from_ulong (stat_temp->st_mtime));
+ SCM_SIMPLE_VECTOR_SET(ans, 10, scm_from_ulong (stat_temp->st_ctime));
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
- SCM_VECTOR_SET(ans, 11, scm_ulong2num ((unsigned long) stat_temp->st_blksize));
+ SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (stat_temp->st_blksize));
#else
- SCM_VECTOR_SET(ans, 11, scm_ulong2num (4096L));
+ SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (4096L));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
- SCM_VECTOR_SET(ans, 12, scm_ulong2num ((unsigned long) stat_temp->st_blocks));
+ SCM_SIMPLE_VECTOR_SET(ans, 12, scm_from_ulong (stat_temp->st_blocks));
#else
- SCM_VECTOR_SET(ans, 12, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET(ans, 12, SCM_BOOL_F);
#endif
{
int mode = stat_temp->st_mode;
if (S_ISREG (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_regular);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_regular);
else if (S_ISDIR (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_directory);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_directory);
#ifdef HAVE_S_ISLNK
else if (S_ISLNK (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_symlink);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_symlink);
#endif
else if (S_ISBLK (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_block_special);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_block_special);
else if (S_ISCHR (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_char_special);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_char_special);
else if (S_ISFIFO (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_fifo);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_fifo);
#ifdef S_ISSOCK
else if (S_ISSOCK (mode))
- SCM_VECTOR_SET(ans, 13, scm_sym_sock);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_sock);
#endif
else
- SCM_VECTOR_SET(ans, 13, scm_sym_unknown);
+ SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_unknown);
- SCM_VECTOR_SET(ans, 14, SCM_I_MAKINUM ((~S_IFMT) & mode));
+ SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int ((~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;
- SCM_VECTOR_SET(ans, 14, SCM_I_MAKINUM (tmp));
+ SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
*/
}
int fdes;
struct stat stat_temp;
- if (SCM_INUMP (object))
+ if (scm_is_integer (object))
{
#ifdef __MINGW32__
- SCM_SYSCALL (rv = fstat_Win32 (SCM_INUM (object), &stat_temp));
+ SCM_SYSCALL (rv = fstat_Win32 (scm_to_int (object), &stat_temp));
#else
- SCM_SYSCALL (rv = fstat (SCM_INUM (object), &stat_temp));
+ SCM_SYSCALL (rv = fstat (scm_to_int (object), &stat_temp));
#endif
}
- else if (SCM_STRINGP (object))
+ else if (scm_is_string (object))
{
+ char *file = scm_to_locale_string (object);
#ifdef __MINGW32__
- char *p, *file = strdup (SCM_STRING_CHARS (object));
+ char *p;
p = file + strlen (file) - 1;
while (p > file && (*p == '/' || *p == '\\'))
*p-- = '\0';
+#endif
SCM_SYSCALL (rv = stat (file, &stat_temp));
free (file);
-#else
- SCM_SYSCALL (rv = stat (SCM_STRING_CHARS (object), &stat_temp));
-#endif
}
else
{
int en = errno;
SCM_SYSERROR_MSG ("~A: ~S",
- scm_list_2 (scm_makfrom0str (strerror (errno)),
+ scm_list_2 (scm_strerror (scm_from_int (en)),
object),
en);
}
{
int val;
- SCM_VALIDATE_STRING (1, oldpath);
- SCM_VALIDATE_STRING (2, newpath);
- SCM_SYSCALL (val = link (SCM_STRING_CHARS (oldpath),
- SCM_STRING_CHARS (newpath)));
+ STRING2_SYSCALL (oldpath, c_oldpath,
+ newpath, c_newpath,
+ val = link (c_oldpath, c_newpath));
if (val != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
#undef FUNC_NAME
#endif /* HAVE_LINK */
+#ifdef HAVE_RENAME
+#define my_rename rename
+#else
+static int
+my_rename (const char *oldname, const char *newname)
+{
+ int rv;
+ SCM_SYSCALL (rv = link (oldname, newname));
+ if (rv == 0)
+ {
+ SCM_SYSCALL (rv = unlink (oldname));
+ if (rv != 0)
+ /* unlink failed. remove new name */
+ SCM_SYSCALL (unlink (newname));
+ }
+ return rv;
+}
+#endif
SCM_DEFINE (scm_rename, "rename-file", 2, 0, 0,
(SCM oldname, SCM newname),
#define FUNC_NAME s_scm_rename
{
int rv;
- SCM_VALIDATE_STRING (1, oldname);
- SCM_VALIDATE_STRING (2, newname);
-#ifdef HAVE_RENAME
- SCM_SYSCALL (rv = rename (SCM_STRING_CHARS (oldname), SCM_STRING_CHARS (newname)));
-#else
- SCM_SYSCALL (rv = link (SCM_STRING_CHARS (oldname), SCM_STRING_CHARS (newname)));
- if (rv == 0)
- {
- SCM_SYSCALL (rv = unlink (SCM_STRING_CHARS (oldname)));;
- if (rv != 0)
- /* unlink failed. remove new name */
- SCM_SYSCALL (unlink (SCM_STRING_CHARS (newname)));
- }
-#endif
+
+ STRING2_SYSCALL (oldname, c_oldname,
+ newname, c_newname,
+ rv = my_rename (c_oldname, c_newname));
if (rv != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
#define FUNC_NAME s_scm_delete_file
{
int ans;
- SCM_VALIDATE_STRING (1, str);
- SCM_SYSCALL (ans = unlink (SCM_STRING_CHARS (str)));
+ STRING_SYSCALL (str, c_str, ans = unlink (c_str));
if (ans != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
{
int rv;
mode_t mask;
- SCM_VALIDATE_STRING (1, path);
+
if (SCM_UNBNDP (mode))
{
mask = umask (0);
umask (mask);
- SCM_SYSCALL (rv = mkdir (SCM_STRING_CHARS (path), 0777 ^ mask));
+ STRING_SYSCALL (path, c_path, rv = mkdir (c_path, 0777 ^ mask));
}
else
{
- SCM_VALIDATE_INUM (2, mode);
- SCM_SYSCALL (rv = mkdir (SCM_STRING_CHARS (path), SCM_INUM (mode)));
+ STRING_SYSCALL (path, c_path, rv = mkdir (c_path, scm_to_uint (mode)));
}
if (rv != 0)
SCM_SYSERROR;
{
int val;
- SCM_VALIDATE_STRING (1, path);
- SCM_SYSCALL (val = rmdir (SCM_STRING_CHARS (path)));
+ STRING_SYSCALL (path, c_path, val = rmdir (c_path));
if (val != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
#define FUNC_NAME s_scm_opendir
{
DIR *ds;
- SCM_VALIDATE_STRING (1, dirname);
- SCM_SYSCALL (ds = opendir (SCM_STRING_CHARS (dirname)));
+ STRING_SYSCALL (dirname, c_dirname, ds = opendir (c_dirname));
if (ds == NULL)
SCM_SYSERROR;
SCM_RETURN_NEWSMOB (scm_tc16_dir | SCM_DIR_FLAG_OPEN, ds);
if (errno != 0)
SCM_SYSERROR;
- return (rdent ? scm_mem2string (rdent->d_name, NAMLEN (rdent))
+ return (rdent ? scm_from_locale_stringn (rdent->d_name, NAMLEN (rdent))
: SCM_EOF_VAL);
}
}
if (!SCM_DIR_OPEN_P (exp))
scm_puts ("closed: ", port);
scm_puts ("directory stream ", port);
- scm_intprint (SCM_CELL_WORD_1 (exp), 16, port);
+ scm_uintprint (SCM_CELL_WORD_1 (exp), 16, port);
scm_putc ('>', port);
return 1;
}
{
int ans;
- SCM_VALIDATE_STRING (1, str);
- SCM_SYSCALL (ans = chdir (SCM_STRING_CHARS (str)));
+ STRING_SYSCALL (str, c_str, ans = chdir (c_str));
if (ans != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
errno = save_errno;
SCM_SYSERROR;
}
- result = scm_mem2string (wd, strlen (wd));
+ result = scm_from_locale_stringn (wd, strlen (wd));
free (wd);
return result;
}
{
int fd;
- if (SCM_INUMP (element))
+ if (scm_is_integer (element))
{
- fd = SCM_INUM (element);
+ fd = scm_to_int (element);
}
else
{
{
int max_fd = 0;
- if (SCM_VECTORP (list_or_vec))
+ if (scm_is_simple_vector (list_or_vec))
{
- int i = SCM_VECTOR_LENGTH (list_or_vec);
- SCM const *ve = SCM_VELTS (list_or_vec);
+ int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
while (--i >= 0)
{
- int fd = set_element (set, ports_ready, ve[i], pos);
+ int fd = set_element (set, ports_ready,
+ SCM_SIMPLE_VECTOR_REF (list_or_vec, i), pos);
if (fd > max_fd)
max_fd = fd;
{
int fd;
- if (SCM_INUMP (element))
+ if (scm_is_integer (element))
{
- fd = SCM_INUM (element);
+ fd = scm_to_int (element);
}
else
{
{
SCM answer_list = ports_ready;
- if (SCM_VECTORP (list_or_vec))
+ if (scm_is_simple_vector (list_or_vec))
{
- int i = SCM_VECTOR_LENGTH (list_or_vec);
- SCM const *ve = SCM_VELTS (list_or_vec);
+ int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
while (--i >= 0)
{
- answer_list = get_element (set, ve[i], answer_list);
+ answer_list = get_element (set,
+ SCM_SIMPLE_VECTOR_REF (list_or_vec, i),
+ answer_list);
}
return scm_vector (answer_list);
}
SCM write_ports_ready = SCM_EOL;
int max_fd;
- if (SCM_VECTORP (reads))
+ if (scm_is_simple_vector (reads))
{
- read_count = SCM_VECTOR_LENGTH (reads);
+ read_count = SCM_SIMPLE_VECTOR_LENGTH (reads);
}
else
{
read_count = scm_ilength (reads);
SCM_ASSERT (read_count >= 0, reads, SCM_ARG1, FUNC_NAME);
}
- if (SCM_VECTORP (writes))
+ if (scm_is_simple_vector (writes))
{
- write_count = SCM_VECTOR_LENGTH (writes);
+ write_count = SCM_SIMPLE_VECTOR_LENGTH (writes);
}
else
{
write_count = scm_ilength (writes);
SCM_ASSERT (write_count >= 0, writes, SCM_ARG2, FUNC_NAME);
}
- if (SCM_VECTORP (excepts))
+ if (scm_is_simple_vector (excepts))
{
- except_count = SCM_VECTOR_LENGTH (excepts);
+ except_count = SCM_SIMPLE_VECTOR_LENGTH (excepts);
}
else
{
/* if there's a port with a ready buffer, don't block, just
check for ready file descriptors. */
- if (!SCM_NULLP (read_ports_ready) || !SCM_NULLP (write_ports_ready))
+ if (!scm_is_null (read_ports_ready) || !scm_is_null (write_ports_ready))
{
timeout.tv_sec = 0;
timeout.tv_usec = 0;
time_ptr = 0;
else
{
- if (SCM_INUMP (secs))
+ if (scm_is_unsigned_integer (secs, 0, ULONG_MAX))
{
- timeout.tv_sec = SCM_INUM (secs);
+ timeout.tv_sec = scm_to_ulong (secs);
if (SCM_UNBNDP (usecs))
timeout.tv_usec = 0;
else
- {
- SCM_VALIDATE_INUM (5, usecs);
- timeout.tv_usec = SCM_INUM (usecs);
- }
+ timeout.tv_usec = scm_to_long (usecs);
}
else
{
- double fl = scm_num2dbl (secs, FUNC_NAME);
+ double fl = scm_to_double (secs);
if (!SCM_UNBNDP (usecs))
SCM_WRONG_TYPE_ARG (4, secs);
}
{
- int rv = scm_internal_select (max_fd + 1,
- &read_set, &write_set, &except_set,
- time_ptr);
+ int rv = scm_std_select (max_fd + 1,
+ &read_set, &write_set, &except_set,
+ time_ptr);
if (rv < 0)
SCM_SYSERROR;
}
object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_INUM (2, cmd);
if (SCM_OPFPORTP (object))
fdes = SCM_FPORT_FDES (object);
else
- {
- SCM_VALIDATE_INUM (1, object);
- fdes = SCM_INUM (object);
- }
+ fdes = scm_to_int (object);
- if (SCM_UNBNDP (value)) {
+ if (SCM_UNBNDP (value))
ivalue = 0;
- } else {
- SCM_VALIDATE_INUM_COPY (SCM_ARG3, value, ivalue);
- }
+ else
+ ivalue = scm_to_int (value);
- SCM_SYSCALL (rv = fcntl (fdes, SCM_INUM (cmd), ivalue));
+ SCM_SYSCALL (rv = fcntl (fdes, scm_to_int (cmd), ivalue));
if (rv == -1)
SCM_SYSERROR;
- return SCM_I_MAKINUM (rv);
+ return scm_from_int (rv);
}
#undef FUNC_NAME
#endif /* HAVE_FCNTL */
fdes = SCM_FPORT_FDES (object);
}
else
- {
- SCM_VALIDATE_INUM (1, object);
- fdes = SCM_INUM (object);
- }
+ fdes = scm_to_int (object);
+
if (fsync (fdes) == -1)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
{
int val;
- SCM_VALIDATE_STRING (1, oldpath);
- SCM_VALIDATE_STRING (2, newpath);
- SCM_SYSCALL (val = symlink (SCM_STRING_CHARS (oldpath), SCM_STRING_CHARS (newpath)));
+ STRING2_SYSCALL (oldpath, c_oldpath,
+ newpath, c_newpath,
+ val = symlink (c_oldpath, c_newpath));
if (val != 0)
SCM_SYSERROR;
return SCM_UNSPECIFIED;
int size = 100;
char *buf;
SCM result;
- SCM_VALIDATE_STRING (1, path);
+ char *c_path;
+
+ scm_frame_begin (0);
+
+ c_path = scm_to_locale_string (path);
+ scm_frame_free (c_path);
+
buf = scm_malloc (size);
- while ((rv = readlink (SCM_STRING_CHARS (path), buf, size)) == size)
+
+ while ((rv = readlink (c_path, buf, size)) == size)
{
free (buf);
size *= 2;
errno = save_errno;
SCM_SYSERROR;
}
- result = scm_mem2string (buf, rv);
- free (buf);
+ result = scm_take_locale_stringn (buf, rv);
+
+ scm_frame_end ();
return result;
}
#undef FUNC_NAME
int rv;
struct stat stat_temp;
- SCM_VALIDATE_STRING (1, str);
- SCM_SYSCALL (rv = lstat (SCM_STRING_CHARS (str), &stat_temp));
+ STRING_SYSCALL (str, c_str, rv = lstat (c_str, &stat_temp));
if (rv != 0)
{
int en = errno;
SCM_SYSERROR_MSG ("~A: ~S",
- scm_list_2 (scm_makfrom0str (strerror (errno)), str),
+ scm_list_2 (scm_strerror (scm_from_int (en)), str),
en);
}
- return scm_stat2scm(&stat_temp);
+ return scm_stat2scm (&stat_temp);
}
#undef FUNC_NAME
#endif /* HAVE_LSTAT */
"The return value is unspecified.")
#define FUNC_NAME s_scm_copy_file
{
+ char *c_oldfile, *c_newfile;
int oldfd, newfd;
- int n;
+ int n, rv;
char buf[BUFSIZ];
struct stat oldstat;
- SCM_VALIDATE_STRING (1, oldfile);
- SCM_VALIDATE_STRING (2, newfile);
- if (stat (SCM_STRING_CHARS (oldfile), &oldstat) == -1)
- SCM_SYSERROR;
- oldfd = open (SCM_STRING_CHARS (oldfile), O_RDONLY);
+ scm_frame_begin (0);
+
+ c_oldfile = scm_to_locale_string (oldfile);
+ scm_frame_free (c_oldfile);
+ c_newfile = scm_to_locale_string (newfile);
+ scm_frame_free (c_newfile);
+
+ oldfd = open (c_oldfile, O_RDONLY);
if (oldfd == -1)
SCM_SYSERROR;
+#ifdef __MINGW32__
+ SCM_SYSCALL (rv = fstat_Win32 (oldfd, &oldstat));
+#else
+ SCM_SYSCALL (rv = fstat (oldfd, &oldstat));
+#endif
+ if (rv == -1)
+ goto err_close_oldfd;
+
/* use POSIX flags instead of 07777?. */
- newfd = open (SCM_STRING_CHARS (newfile), O_WRONLY | O_CREAT | O_TRUNC,
+ newfd = open (c_newfile, O_WRONLY | O_CREAT | O_TRUNC,
oldstat.st_mode & 07777);
if (newfd == -1)
- SCM_SYSERROR;
+ {
+ err_close_oldfd:
+ close (oldfd);
+ SCM_SYSERROR;
+ }
while ((n = read (oldfd, buf, sizeof buf)) > 0)
if (write (newfd, buf, n) != n)
close (oldfd);
if (close (newfd) == -1)
SCM_SYSERROR;
+
+ scm_frame_end ();
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
"component, @code{.} is returned.")
#define FUNC_NAME s_scm_dirname
{
- char *s;
+ const char *s;
long int i;
unsigned long int len;
SCM_VALIDATE_STRING (1, filename);
- s = SCM_STRING_CHARS (filename);
- len = SCM_STRING_LENGTH (filename);
+ s = scm_i_string_chars (filename);
+ len = scm_i_string_length (filename);
i = len - 1;
#ifdef __MINGW32__
#else
if (len > 0 && s[0] == '/')
#endif /* ndef __MINGW32__ */
- return scm_substring (filename, SCM_INUM0, SCM_I_MAKINUM (1));
+ return scm_c_substring (filename, 0, 1);
else
return scm_dot_string;
}
else
- return scm_substring (filename, SCM_INUM0, SCM_I_MAKINUM (i + 1));
+ return scm_c_substring (filename, 0, i + 1);
}
#undef FUNC_NAME
"@var{basename}, it is removed also.")
#define FUNC_NAME s_scm_basename
{
- char *f, *s = 0;
+ const char *f, *s = 0;
int i, j, len, end;
SCM_VALIDATE_STRING (1, filename);
- f = SCM_STRING_CHARS (filename);
- len = SCM_STRING_LENGTH (filename);
+ f = scm_i_string_chars (filename);
+ len = scm_i_string_length (filename);
if (SCM_UNBNDP (suffix))
j = -1;
else
{
SCM_VALIDATE_STRING (2, suffix);
- s = SCM_STRING_CHARS (suffix);
- j = SCM_STRING_LENGTH (suffix) - 1;
+ s = scm_i_string_chars (suffix);
+ j = scm_i_string_length (suffix) - 1;
}
i = len - 1;
#ifdef __MINGW32__
#else
if (len > 0 && f[0] == '/')
#endif /* ndef __MINGW32__ */
- return scm_substring (filename, SCM_INUM0, SCM_I_MAKINUM (1));
+ return scm_c_substring (filename, 0, 1);
else
return scm_dot_string;
}
else
- return scm_substring (filename, SCM_I_MAKINUM (i + 1), SCM_I_MAKINUM (end + 1));
+ return scm_c_substring (filename, i+1, end+1);
}
#undef FUNC_NAME
scm_set_smob_free (scm_tc16_dir, scm_dir_free);
scm_set_smob_print (scm_tc16_dir, scm_dir_print);
- scm_dot_string = scm_permanent_object (scm_makfrom0str ("."));
+ scm_dot_string = scm_permanent_object (scm_from_locale_string ("."));
#ifdef O_RDONLY
- scm_c_define ("O_RDONLY", scm_long2num (O_RDONLY));
+ scm_c_define ("O_RDONLY", scm_from_long (O_RDONLY));
#endif
#ifdef O_WRONLY
- scm_c_define ("O_WRONLY", scm_long2num (O_WRONLY));
+ scm_c_define ("O_WRONLY", scm_from_long (O_WRONLY));
#endif
#ifdef O_RDWR
- scm_c_define ("O_RDWR", scm_long2num (O_RDWR));
+ scm_c_define ("O_RDWR", scm_from_long (O_RDWR));
#endif
#ifdef O_CREAT
- scm_c_define ("O_CREAT", scm_long2num (O_CREAT));
+ scm_c_define ("O_CREAT", scm_from_long (O_CREAT));
#endif
#ifdef O_EXCL
- scm_c_define ("O_EXCL", scm_long2num (O_EXCL));
+ scm_c_define ("O_EXCL", scm_from_long (O_EXCL));
#endif
#ifdef O_NOCTTY
- scm_c_define ("O_NOCTTY", scm_long2num (O_NOCTTY));
+ scm_c_define ("O_NOCTTY", scm_from_long (O_NOCTTY));
#endif
#ifdef O_TRUNC
- scm_c_define ("O_TRUNC", scm_long2num (O_TRUNC));
+ scm_c_define ("O_TRUNC", scm_from_long (O_TRUNC));
#endif
#ifdef O_APPEND
- scm_c_define ("O_APPEND", scm_long2num (O_APPEND));
+ scm_c_define ("O_APPEND", scm_from_long (O_APPEND));
#endif
#ifdef O_NONBLOCK
- scm_c_define ("O_NONBLOCK", scm_long2num (O_NONBLOCK));
+ scm_c_define ("O_NONBLOCK", scm_from_long (O_NONBLOCK));
#endif
#ifdef O_NDELAY
- scm_c_define ("O_NDELAY", scm_long2num (O_NDELAY));
+ scm_c_define ("O_NDELAY", scm_from_long (O_NDELAY));
#endif
#ifdef O_SYNC
- scm_c_define ("O_SYNC", scm_long2num (O_SYNC));
+ scm_c_define ("O_SYNC", scm_from_long (O_SYNC));
#endif
#ifdef F_DUPFD
- scm_c_define ("F_DUPFD", scm_long2num (F_DUPFD));
+ scm_c_define ("F_DUPFD", scm_from_long (F_DUPFD));
#endif
#ifdef F_GETFD
- scm_c_define ("F_GETFD", scm_long2num (F_GETFD));
+ scm_c_define ("F_GETFD", scm_from_long (F_GETFD));
#endif
#ifdef F_SETFD
- scm_c_define ("F_SETFD", scm_long2num (F_SETFD));
+ scm_c_define ("F_SETFD", scm_from_long (F_SETFD));
#endif
#ifdef F_GETFL
- scm_c_define ("F_GETFL", scm_long2num (F_GETFL));
+ scm_c_define ("F_GETFL", scm_from_long (F_GETFL));
#endif
#ifdef F_SETFL
- scm_c_define ("F_SETFL", scm_long2num (F_SETFL));
+ scm_c_define ("F_SETFL", scm_from_long (F_SETFL));
#endif
#ifdef F_GETOWN
- scm_c_define ("F_GETOWN", scm_long2num (F_GETOWN));
+ scm_c_define ("F_GETOWN", scm_from_long (F_GETOWN));
#endif
#ifdef F_SETOWN
- scm_c_define ("F_SETOWN", scm_long2num (F_SETOWN));
+ scm_c_define ("F_SETOWN", scm_from_long (F_SETOWN));
#endif
#ifdef FD_CLOEXEC
- scm_c_define ("FD_CLOEXEC", scm_long2num (FD_CLOEXEC));
+ scm_c_define ("FD_CLOEXEC", scm_from_long (FD_CLOEXEC));
#endif
#include "libguile/filesys.x"