-/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 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
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this software; see the file COPYING. If not, write to
- * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307 USA
- *
- * As a special exception, the Free Software Foundation gives permission
- * for additional uses of the text contained in its release of GUILE.
- *
- * The exception is that, if you link the GUILE library with other files
- * to produce an executable, this does not by itself cause the
- * resulting executable to be covered by the GNU General Public License.
- * Your use of that executable is in no way restricted on account of
- * linking the GUILE library code into it.
- *
- * This exception does not however invalidate any other reasons why
- * the executable file might be covered by the GNU General Public License.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
*
- * This exception applies only to the code released by the
- * Free Software Foundation under the name GUILE. If you copy
- * code from other Free Software Foundation releases into a copy of
- * GUILE, as the General Public License permits, the exception does
- * not apply to the code that you add in this way. To avoid misleading
- * anyone as to the status of such modified files, you must delete
- * this exception notice from them.
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * If you write modifications of your own for GUILE, it is your choice
- * whether to permit this exception to apply to your modifications.
- * If you do not wish that, delete this exception notice. */
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
-/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
- gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
\f
+#define _LARGEFILE64_SOURCE /* ask for stat64 etc */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
#include <stdio.h>
#include <fcntl.h>
#include "libguile/strings.h"
#include "libguile/validate.h"
#include "libguile/gc.h"
+#include "libguile/posix.h"
+#include "libguile/dynwind.h"
+#include "libguile/hashtab.h"
#include "libguile/fports.h"
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#else
-scm_sizet fwrite ();
#endif
-#ifdef HAVE_ST_BLKSIZE
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
#include <sys/stat.h>
#endif
#include <errno.h>
+#include <sys/types.h>
#include "libguile/iselect.h"
+/* Some defines for Windows (native port, not Cygwin). */
+#ifdef __MINGW32__
+# include <sys/stat.h>
+# include <winsock2.h>
+#endif /* __MINGW32__ */
+
+#include <full-write.h>
+
+/* Mingw (version 3.4.5, circa 2006) has ftruncate as an alias for chsize
+ already, but have this code here in case that wasn't so in past versions,
+ or perhaps to help other minimal DOS environments.
+
+ gnulib ftruncate.c has code using fcntl F_CHSIZE and F_FREESP, which
+ might be possibilities if we've got other systems without ftruncate. */
+
+#if HAVE_CHSIZE && ! HAVE_FTRUNCATE
+# define ftruncate(fd, size) chsize (fd, size)
+#undef HAVE_FTRUNCATE
+#define HAVE_FTRUNCATE 1
+#endif
+
+#if SIZEOF_OFF_T == SIZEOF_INT
+#define OFF_T_MAX INT_MAX
+#define OFF_T_MIN INT_MIN
+#elif SIZEOF_OFF_T == SIZEOF_LONG
+#define OFF_T_MAX LONG_MAX
+#define OFF_T_MIN LONG_MIN
+#elif SIZEOF_OFF_T == SIZEOF_LONG_LONG
+#define OFF_T_MAX LONG_LONG_MAX
+#define OFF_T_MIN LONG_LONG_MIN
+#else
+#error Oops, unknown OFF_T size
+#endif
-scm_bits_t scm_tc16_fport;
+scm_t_bits scm_tc16_fport;
/* default buffer size, used if the O/S won't supply a value. */
-static const int default_buffer_size = 1024;
+static const size_t default_buffer_size = 1024;
/* create FPORT buffer with specified sizes (or -1 to use default size or
0 for no buffer. */
static void
-scm_fport_buffer_add (SCM port, int read_size, int write_size)
+scm_fport_buffer_add (SCM port, long read_size, int write_size)
#define FUNC_NAME "scm_fport_buffer_add"
{
- struct scm_fport *fp = SCM_FSTREAM (port);
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (read_size == -1 || write_size == -1)
{
- int default_size;
-#ifdef HAVE_ST_BLKSIZE
+ size_t default_size;
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
struct stat st;
+ scm_t_fport *fp = SCM_FSTREAM (port);
default_size = (fstat (fp->fdes, &st) == -1) ? default_buffer_size
: st.st_blksize;
if (SCM_INPUT_PORT_P (port) && read_size > 0)
{
- pt->read_buf = scm_must_malloc (read_size, FUNC_NAME);
+ pt->read_buf = scm_gc_malloc_pointerless (read_size, "port buffer");
pt->read_pos = pt->read_end = pt->read_buf;
pt->read_buf_size = read_size;
}
if (SCM_OUTPUT_PORT_P (port) && write_size > 0)
{
- pt->write_buf = scm_must_malloc (write_size, FUNC_NAME);
+ pt->write_buf = scm_gc_malloc_pointerless (write_size, "port buffer");
pt->write_pos = pt->write_buf;
pt->write_buf_size = write_size;
}
"@end table")
#define FUNC_NAME s_scm_setvbuf
{
- int cmode, csize;
- scm_port *pt;
+ int cmode;
+ long csize;
+ scm_t_port *pt;
port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPFPORT (1,port);
- SCM_VALIDATE_INUM_COPY (2,mode,cmode);
+ cmode = scm_to_int (mode);
if (cmode != _IONBF && cmode != _IOFBF && cmode != _IOLBF)
scm_out_of_range (FUNC_NAME, mode);
}
else
{
- SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) ^ SCM_BUFLINE);
+ SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) & ~(scm_t_bits)SCM_BUFLINE);
}
if (SCM_UNBNDP (size))
}
else
{
- SCM_VALIDATE_INUM_COPY (3,size,csize);
+ csize = scm_to_int (size);
if (csize < 0 || (cmode == _IONBF && csize > 0))
scm_out_of_range (FUNC_NAME, size);
}
pt = SCM_PTAB_ENTRY (port);
- /* silently discards buffered chars. */
+ /* silently discards buffered and put-back chars. */
+ if (pt->read_buf == pt->putback_buf)
+ {
+ pt->read_buf = pt->saved_read_buf;
+ pt->read_pos = pt->saved_read_pos;
+ pt->read_end = pt->saved_read_end;
+ pt->read_buf_size = pt->saved_read_buf_size;
+ }
if (pt->read_buf != &pt->shortbuf)
- scm_must_free (pt->read_buf);
+ scm_gc_free (pt->read_buf, pt->read_buf_size, "port buffer");
if (pt->write_buf != &pt->shortbuf)
- scm_must_free (pt->write_buf);
+ scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer");
scm_fport_buffer_add (port, csize, csize);
return SCM_UNSPECIFIED;
#undef FUNC_NAME
/* Move ports with the specified file descriptor to new descriptors,
- * reseting the revealed count to 0.
+ * resetting the revealed count to 0.
*/
-
-void
-scm_evict_ports (int fd)
+static void
+scm_i_evict_port (void *closure, SCM port)
{
- int i;
+ int fd = * (int*) closure;
- for (i = 0; i < scm_port_table_size; i++)
+ if (SCM_FPORTP (port))
{
- SCM port = scm_port_table[i]->port;
+ scm_t_port *p;
+ scm_t_fport *fp;
- if (SCM_FPORTP (port))
- {
- struct scm_fport *fp = SCM_FSTREAM (port);
+ /* XXX: In some cases, we can encounter a port with no associated ptab
+ entry. */
+ p = SCM_PTAB_ENTRY (port);
+ fp = (p != NULL) ? (scm_t_fport *) p->stream : NULL;
- if (fp->fdes == fd)
- {
- fp->fdes = dup (fd);
- if (fp->fdes == -1)
- scm_syserror ("scm_evict_ports");
- scm_set_port_revealed_x (port, SCM_MAKINUM (0));
- }
+ if ((fp != NULL) && (fp->fdes == fd))
+ {
+ fp->fdes = dup (fd);
+ if (fp->fdes == -1)
+ scm_syserror ("scm_evict_ports");
+ scm_set_port_revealed_x (port, scm_from_int (0));
}
}
}
+void
+scm_evict_ports (int fd)
+{
+ scm_c_port_for_each (scm_i_evict_port, (void *) &fd);
+}
+
SCM_DEFINE (scm_file_port_p, "file-port?", 1, 0, 0,
(SCM obj),
"Determine whether @var{obj} is a port that is related to a file.")
#define FUNC_NAME s_scm_file_port_p
{
- return SCM_BOOL (SCM_FPORTP (obj));
+ return scm_from_bool (SCM_FPORTP (obj));
}
#undef FUNC_NAME
"@end table\n"
"The following additional characters can be appended:\n"
"@table @samp\n"
+ "@item b\n"
+ "Open the underlying file in binary mode, if supported by the operating system. "
"@item +\n"
"Open the port for both input and output. E.g., @code{r+}: open\n"
"an existing file for both input and output.\n"
char *md;
char *ptr;
- SCM_VALIDATE_STRING (1, filename);
- SCM_VALIDATE_STRING (2, mode);
- SCM_STRING_COERCE_0TERMINATION_X (filename);
- SCM_STRING_COERCE_0TERMINATION_X (mode);
+ scm_dynwind_begin (0);
- file = SCM_STRING_CHARS (filename);
- md = SCM_STRING_CHARS (mode);
+ file = scm_to_locale_string (filename);
+ scm_dynwind_free (file);
+
+ md = scm_to_locale_string (mode);
+ scm_dynwind_free (md);
switch (*md)
{
}
ptr++;
}
- SCM_SYSCALL (fdes = open (file, flags, 0666));
+ SCM_SYSCALL (fdes = open_or_open64 (file, flags, 0666));
if (fdes == -1)
{
int en = errno;
SCM_SYSERROR_MSG ("~A: ~S",
- scm_cons (scm_makfrom0str (strerror (en)),
+ scm_cons (scm_strerror (scm_from_int (en)),
scm_cons (filename, SCM_EOL)), en);
}
- port = scm_fdes_to_port (fdes, md, filename);
+ port = scm_i_fdes_to_port (fdes, scm_i_mode_bits (mode), filename);
+
+ scm_dynwind_end ();
+
return port;
}
#undef FUNC_NAME
\f
+#ifdef __MINGW32__
+/*
+ * Try getting the appropiate file flags for a given file descriptor
+ * under Windows. This incorporates some fancy operations because Windows
+ * differentiates between file, pipe and socket descriptors.
+ */
+#ifndef O_ACCMODE
+# define O_ACCMODE 0x0003
+#endif
+
+static int getflags (int fdes)
+{
+ int flags = 0;
+ struct stat buf;
+ int error, optlen = sizeof (int);
+
+ /* Is this a socket ? */
+ if (getsockopt (fdes, SOL_SOCKET, SO_ERROR, (void *) &error, &optlen) >= 0)
+ flags = O_RDWR;
+ /* Maybe a regular file ? */
+ else if (fstat (fdes, &buf) < 0)
+ flags = -1;
+ else
+ {
+ /* Or an anonymous pipe handle ? */
+ if (buf.st_mode & _S_IFIFO)
+ flags = PeekNamedPipe ((HANDLE) _get_osfhandle (fdes), NULL, 0,
+ NULL, NULL, NULL) ? O_RDONLY : O_WRONLY;
+ /* stdin ? */
+ else if (fdes == fileno (stdin) && isatty (fdes))
+ flags = O_RDONLY;
+ /* stdout / stderr ? */
+ else if ((fdes == fileno (stdout) || fdes == fileno (stderr)) &&
+ isatty (fdes))
+ flags = O_WRONLY;
+ else
+ flags = buf.st_mode;
+ }
+ return flags;
+}
+#endif /* __MINGW32__ */
+
/* Building Guile ports from a file descriptor. */
/* Build a Scheme port from an open file descriptor `fdes'.
NAME is a string to be used as the port's filename.
*/
SCM
-scm_fdes_to_port (int fdes, char *mode, SCM name)
+scm_i_fdes_to_port (int fdes, long mode_bits, SCM name)
#define FUNC_NAME "scm_fdes_to_port"
{
- long mode_bits = scm_mode_bits (mode);
SCM port;
- scm_port *pt;
+ scm_t_port *pt;
int flags;
/* test that fdes is valid. */
+#ifdef __MINGW32__
+ flags = getflags (fdes);
+#else
flags = fcntl (fdes, F_GETFL, 0);
+#endif
if (flags == -1)
SCM_SYSERROR;
flags &= O_ACCMODE;
SCM_MISC_ERROR ("requested file mode not available on fdes", SCM_EOL);
}
- SCM_NEWCELL (port);
- SCM_DEFER_INTS;
- pt = scm_add_to_port_table (port);
- SCM_SETPTAB_ENTRY (port, pt);
- SCM_SET_CELL_TYPE (port, (scm_tc16_fport | mode_bits));
+ scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex);
+ port = scm_new_port_table_entry (scm_tc16_fport);
+ SCM_SET_CELL_TYPE(port, scm_tc16_fport | mode_bits);
+ pt = SCM_PTAB_ENTRY(port);
{
- struct scm_fport *fp
- = (struct scm_fport *) scm_must_malloc (sizeof (struct scm_fport),
- FUNC_NAME);
+ scm_t_fport *fp
+ = (scm_t_fport *) scm_gc_malloc_pointerless (sizeof (scm_t_fport),
+ "file port");
fp->fdes = fdes;
pt->rw_random = SCM_FDES_RANDOM_P (fdes);
scm_fport_buffer_add (port, -1, -1);
}
SCM_SET_FILENAME (port, name);
- SCM_ALLOW_INTS;
+ scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex);
return port;
}
#undef FUNC_NAME
+SCM
+scm_fdes_to_port (int fdes, char *mode, SCM name)
+{
+ return scm_i_fdes_to_port (fdes, scm_mode_bits (mode), name);
+}
+
/* Return a lower bound on the number of bytes available for input. */
static int
fport_input_waiting (SCM port)
{
- int fdes = SCM_FSTREAM (port)->fdes;
-
#ifdef HAVE_SELECT
+ int fdes = SCM_FSTREAM (port)->fdes;
struct timeval timeout;
SELECT_TYPE read_set;
SELECT_TYPE write_set;
< 0)
scm_syserror ("fport_input_waiting");
return FD_ISSET (fdes, &read_set) ? 1 : 0;
-#elif defined (FIONREAD)
+
+#elif HAVE_IOCTL && defined (FIONREAD)
+ /* Note: cannot test just defined(FIONREAD) here, since mingw has FIONREAD
+ (for use with winsock ioctlsocket()) but not ioctl(). */
+ int fdes = SCM_FSTREAM (port)->fdes;
int remir;
ioctl(fdes, FIONREAD, &remir);
return remir;
+
#else
scm_misc_error ("fport_input_waiting",
"Not fully implemented on this platform",
\f
static int
-fport_print (SCM exp, SCM port, scm_print_state *pstate)
+fport_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)
{
scm_puts ("#<", port);
scm_print_port_mode (exp, port);
{
int fdes;
SCM name = SCM_FILENAME (exp);
- if (SCM_STRINGP (name) || SCM_SYMBOLP (name))
+ if (scm_is_string (name) || scm_is_symbol (name))
scm_display (name, port);
else
scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port);
scm_putc (' ', port);
fdes = (SCM_FSTREAM (exp))->fdes;
+#ifdef HAVE_TTYNAME
if (isatty (fdes))
- scm_puts (ttyname (fdes), port);
+ scm_display (scm_ttyname (exp), port);
else
+#endif /* HAVE_TTYNAME */
scm_intprint (fdes, 10, port);
}
else
{
scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port);
scm_putc (' ', port);
- scm_intprint (SCM_UNPACK (SCM_CDR (exp)), 16, port);
+ scm_uintprint ((scm_t_bits) SCM_PTAB_ENTRY (exp), 16, port);
}
scm_putc ('>', port);
return 1;
}
-#ifdef GUILE_ISELECT
+#ifndef __MINGW32__
/* thread-local block for input on fport's fdes. */
static void
fport_wait_for_input (SCM port)
{
FD_ZERO (&readfds);
FD_SET (fdes, &readfds);
- n = scm_internal_select (fdes + 1, &readfds, NULL, NULL, NULL);
+ n = scm_std_select (fdes + 1, &readfds, NULL, NULL, NULL);
}
while (n == -1 && errno == EINTR);
}
}
-#endif
+#endif /* !__MINGW32__ */
static void fport_flush (SCM port);
/* fill a port's read-buffer with a single read. returns the first
char or EOF if end of file. */
-static int
+static scm_t_wchar
fport_fill_input (SCM port)
{
- int count;
- scm_port *pt = SCM_PTAB_ENTRY (port);
- struct scm_fport *fp = SCM_FSTREAM (port);
+ long count;
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
-#ifdef GUILE_ISELECT
+#ifndef __MINGW32__
fport_wait_for_input (port);
-#endif
+#endif /* !__MINGW32__ */
SCM_SYSCALL (count = read (fp->fdes, pt->read_buf, pt->read_buf_size));
if (count == -1)
scm_syserror ("fport_fill_input");
if (count == 0)
- return EOF;
+ return (scm_t_wchar) EOF;
else
{
pt->read_pos = pt->read_buf;
}
}
-static off_t
-fport_seek (SCM port, off_t offset, int whence)
+static scm_t_off
+fport_seek (SCM port, scm_t_off offset, int whence)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
- struct scm_fport *fp = SCM_FSTREAM (port);
- off_t rv;
- off_t result;
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
+ off_t_or_off64_t rv;
+ off_t_or_off64_t result;
if (pt->rw_active == SCM_PORT_WRITE)
{
if (offset != 0 || whence != SEEK_CUR)
{
fport_flush (port);
- result = rv = lseek (fp->fdes, offset, whence);
+ result = rv = lseek_or_lseek64 (fp->fdes, offset, whence);
}
else
{
/* read current position without disturbing the buffer. */
- rv = lseek (fp->fdes, offset, whence);
+ rv = lseek_or_lseek64 (fp->fdes, offset, whence);
result = rv + (pt->write_pos - pt->write_buf);
}
}
{
/* could expand to avoid a second seek. */
scm_end_input (port);
- result = rv = lseek (fp->fdes, offset, whence);
+ result = rv = lseek_or_lseek64 (fp->fdes, offset, whence);
}
else
{
/* read current position without disturbing the buffer
(particularly the unread-char buffer). */
- rv = lseek (fp->fdes, offset, whence);
+ rv = lseek_or_lseek64 (fp->fdes, offset, whence);
result = rv - (pt->read_end - pt->read_pos);
if (pt->read_buf == pt->putback_buf)
}
else /* SCM_PORT_NEITHER */
{
- result = rv = lseek (fp->fdes, offset, whence);
+ result = rv = lseek_or_lseek64 (fp->fdes, offset, whence);
}
if (rv == -1)
}
static void
-fport_truncate (SCM port, off_t length)
+fport_truncate (SCM port, scm_t_off length)
{
- struct scm_fport *fp = SCM_FSTREAM (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
if (ftruncate (fp->fdes, length) == -1)
scm_syserror ("ftruncate");
while (remaining > 0)
{
- ssize_t done;
+ size_t done;
SCM_SYSCALL (done = write (fdes, data, remaining));
fport_write (SCM port, const void *data, size_t size)
{
/* this procedure tries to minimize the number of writes/flushes. */
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (pt->write_buf == &pt->shortbuf
|| (pt->write_pos == pt->write_buf && size >= pt->write_buf_size))
}
{
- off_t space = pt->write_end - pt->write_pos;
+ scm_t_off space = pt->write_end - pt->write_pos;
if (size <= space)
{
/* becomes 1 when process is exiting: normal exception handling won't
work by this time. */
-extern int terminating;
+extern int scm_i_terminating;
static void
fport_flush (SCM port)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
- struct scm_fport *fp = SCM_FSTREAM (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
unsigned char *ptr = pt->write_buf;
- int init_size = pt->write_pos - pt->write_buf;
- int remaining = init_size;
+ long init_size = pt->write_pos - pt->write_buf;
+ long remaining = init_size;
while (remaining > 0)
{
- int count;
+ long count;
SCM_SYSCALL (count = write (fp->fdes, ptr, remaining));
if (count < 0)
{
/* error. assume nothing was written this call, but
fix up the buffer for any previous successful writes. */
- int done = init_size - remaining;
+ long done = init_size - remaining;
if (done > 0)
{
}
pt->write_pos = pt->write_buf + remaining;
}
- if (terminating)
+ if (scm_i_terminating)
{
const char *msg = "Error: could not flush file-descriptor ";
char buf[11];
- write (2, msg, strlen (msg));
+ full_write (2, msg, strlen (msg));
sprintf (buf, "%d\n", fp->fdes);
- write (2, buf, strlen (buf));
+ full_write (2, buf, strlen (buf));
count = remaining;
}
static void
fport_end_input (SCM port, int offset)
{
- struct scm_fport *fp = SCM_FSTREAM (port);
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
offset += pt->read_end - pt->read_pos;
static int
fport_close (SCM port)
{
- struct scm_fport *fp = SCM_FSTREAM (port);
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
int rv;
fport_flush (port);
if (pt->read_buf == pt->putback_buf)
pt->read_buf = pt->saved_read_buf;
if (pt->read_buf != &pt->shortbuf)
- scm_must_free (pt->read_buf);
+ scm_gc_free (pt->read_buf, pt->read_buf_size, "port buffer");
if (pt->write_buf != &pt->shortbuf)
- scm_must_free (pt->write_buf);
- scm_must_free ((char *) fp);
+ scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer");
+ scm_gc_free (fp, sizeof (*fp), "file port");
return rv;
}
-static scm_sizet
+static size_t
fport_free (SCM port)
{
fport_close (port);
return 0;
}
-static scm_bits_t
+static scm_t_bits
scm_make_fptob ()
{
- scm_bits_t tc = scm_make_port_type ("file", fport_fill_input, fport_write);
+ scm_t_bits tc = scm_make_port_type ("file", fport_fill_input, fport_write);
scm_set_port_free (tc, fport_free);
scm_set_port_print (tc, fport_print);
{
scm_tc16_fport = scm_make_fptob ();
- scm_sysintern ("_IOFBF", SCM_MAKINUM (_IOFBF));
- scm_sysintern ("_IOLBF", SCM_MAKINUM (_IOLBF));
- scm_sysintern ("_IONBF", SCM_MAKINUM (_IONBF));
+ scm_c_define ("_IOFBF", scm_from_int (_IOFBF));
+ scm_c_define ("_IOLBF", scm_from_int (_IOLBF));
+ scm_c_define ("_IONBF", scm_from_int (_IONBF));
-#ifndef SCM_MAGIC_SNARFER
#include "libguile/fports.x"
-#endif
}
/*