-/* Copyright (C) 1995,1996,1997,1998,1999 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001 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 <fcntl.h>
-#include "_scm.h"
+#include "libguile/_scm.h"
+#include "libguile/strings.h"
+#include "libguile/validate.h"
+#include "libguile/gc.h"
-#include "scm_validate.h"
-#include "fports.h"
+#include "libguile/fports.h"
#ifdef HAVE_STRING_H
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#else
-scm_sizet fwrite ();
+size_t 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 "iselect.h"
+#include "libguile/iselect.h"
+/* Some defines for Windows. */
+#ifdef __MINGW32__
+# include <sys/stat.h>
+# include <winsock2.h>
+# define ftruncate(fd, size) chsize (fd, size)
+#endif /* __MINGW32__ */
+
+
+scm_t_bits scm_tc16_fport;
+
+
+/* default buffer size, used if the O/S won't supply a value. */
+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);
- char *s_scm_fport_buffer_add = "scm_fport_buffer_add";
+ 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);
- if (fstat (fp->fdes, &st) == -1)
- scm_syserror (s_scm_fport_buffer_add);
- default_size = st.st_blksize;
+ default_size = (fstat (fp->fdes, &st) == -1) ? default_buffer_size
+ : st.st_blksize;
#else
- default_size = 1024;
+ default_size = default_buffer_size;
#endif
if (read_size == -1)
read_size = default_size;
write_size = default_size;
}
- if (SCM_INPORTP (port) && read_size > 0)
+ if (SCM_INPUT_PORT_P (port) && read_size > 0)
{
- pt->read_buf = malloc (read_size);
- if (pt->read_buf == NULL)
- scm_memory_error (s_scm_fport_buffer_add);
+ pt->read_buf = scm_must_malloc (read_size, FUNC_NAME);
pt->read_pos = pt->read_end = pt->read_buf;
pt->read_buf_size = read_size;
}
pt->read_buf_size = 1;
}
- if (SCM_OUTPORTP (port) && write_size > 0)
+ if (SCM_OUTPUT_PORT_P (port) && write_size > 0)
{
- pt->write_buf = malloc (write_size);
- if (pt->write_buf == NULL)
- scm_memory_error (s_scm_fport_buffer_add);
+ pt->write_buf = scm_must_malloc (write_size, FUNC_NAME);
pt->write_pos = pt->write_buf;
pt->write_buf_size = write_size;
}
pt->write_end = pt->write_buf + pt->write_buf_size;
if (read_size > 0 || write_size > 0)
- SCM_SETCAR (port, SCM_CAR (port) & ~SCM_BUF0);
+ SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) & ~SCM_BUF0);
else
- SCM_SETCAR (port, (SCM_CAR (port) | SCM_BUF0));
+ SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) | SCM_BUF0);
}
+#undef FUNC_NAME
-GUILE_PROC (scm_setvbuf, "setvbuf", 2, 1, 0,
+SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0,
(SCM port, SCM mode, SCM size),
-"")
+ "Set the buffering mode for @var{port}. @var{mode} can be:\n"
+ "@table @code\n"
+ "@item _IONBF\n"
+ "non-buffered\n"
+ "@item _IOLBF\n"
+ "line buffered\n"
+ "@item _IOFBF\n"
+ "block buffered, using a newly allocated buffer of @var{size} bytes.\n"
+ "If @var{size} is omitted, a default size will be used.\n"
+ "@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_INT_COPY(2,mode,cmode);
+ SCM_VALIDATE_OPFPORT (1,port);
+ SCM_VALIDATE_INUM_COPY (2,mode,cmode);
if (cmode != _IONBF && cmode != _IOFBF && cmode != _IOLBF)
scm_out_of_range (FUNC_NAME, mode);
if (cmode == _IOLBF)
{
- SCM_SETCAR (port, SCM_CAR (port) | SCM_BUFLINE);
+ SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) | SCM_BUFLINE);
cmode = _IOFBF;
}
else
{
- SCM_SETCAR (port, SCM_CAR (port) ^ SCM_BUFLINE);
+ SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) ^ SCM_BUFLINE);
}
if (SCM_UNBNDP (size))
}
else
{
- SCM_VALIDATE_INT_COPY(3,size,csize);
+ SCM_VALIDATE_INUM_COPY (3,size,csize);
if (csize < 0 || (cmode == _IONBF && csize > 0))
scm_out_of_range (FUNC_NAME, size);
}
*/
void
-scm_evict_ports (fd)
- int fd;
+scm_evict_ports (int fd)
{
- int i;
+ long i;
for (i = 0; i < scm_port_table_size; i++)
{
if (SCM_FPORTP (port))
{
- struct scm_fport *fp = SCM_FSTREAM (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
if (fp->fdes == 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));
+}
+#undef FUNC_NAME
+
+
/* scm_open_file
* Return a new port open on a given file.
*
*
* Return the new port.
*/
-GUILE_PROC(scm_open_file, "open-file", 2, 0, 0,
- (SCM filename, SCM modes),
-"")
+SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0,
+ (SCM filename, SCM mode),
+ "Open the file whose name is @var{filename}, and return a port\n"
+ "representing that file. The attributes of the port are\n"
+ "determined by the @var{mode} string. The way in which this is\n"
+ "interpreted is similar to C stdio. The first character must be\n"
+ "one of the following:\n"
+ "@table @samp\n"
+ "@item r\n"
+ "Open an existing file for input.\n"
+ "@item w\n"
+ "Open a file for output, creating it if it doesn't already exist\n"
+ "or removing its contents if it does.\n"
+ "@item a\n"
+ "Open a file for output, creating it if it doesn't already\n"
+ "exist. All writes to the port will go to the end of the file.\n"
+ "The \"append mode\" can be turned off while the port is in use\n"
+ "@pxref{Ports and File Descriptors, fcntl}\n"
+ "@end table\n"
+ "The following additional characters can be appended:\n"
+ "@table @samp\n"
+ "@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"
+ "@item 0\n"
+ "Create an \"unbuffered\" port. In this case input and output\n"
+ "operations are passed directly to the underlying port\n"
+ "implementation without additional buffering. This is likely to\n"
+ "slow down I/O operations. The buffering mode can be changed\n"
+ "while a port is in use @pxref{Ports and File Descriptors,\n"
+ "setvbuf}\n"
+ "@item l\n"
+ "Add line-buffering to the port. The port output buffer will be\n"
+ "automatically flushed whenever a newline character is written.\n"
+ "@end table\n"
+ "In theory we could create read/write ports which were buffered\n"
+ "in one direction only. However this isn't included in the\n"
+ "current interfaces. If a file cannot be opened with the access\n"
+ "requested, @code{open-file} throws an exception.")
#define FUNC_NAME s_scm_open_file
{
SCM port;
int fdes;
int flags = 0;
char *file;
- char *mode;
+ char *md;
char *ptr;
- SCM_VALIDATE_ROSTRING(1,filename);
- SCM_VALIDATE_ROSTRING(2,modes);
- if (SCM_SUBSTRP (filename))
- filename = scm_makfromstr (SCM_ROCHARS (filename), SCM_ROLENGTH (filename), 0);
- if (SCM_SUBSTRP (modes))
- modes = scm_makfromstr (SCM_ROCHARS (modes), SCM_ROLENGTH (modes), 0);
+ SCM_VALIDATE_STRING (1, filename);
+ SCM_VALIDATE_STRING (2, mode);
- file = SCM_ROCHARS (filename);
- mode = SCM_ROCHARS (modes);
+ file = SCM_STRING_CHARS (filename);
+ md = SCM_STRING_CHARS (mode);
- switch (*mode)
+ switch (*md)
{
case 'r':
flags |= O_RDONLY;
flags |= O_WRONLY | O_CREAT | O_APPEND;
break;
default:
- scm_out_of_range (FUNC_NAME, modes);
+ scm_out_of_range (FUNC_NAME, mode);
}
- ptr = mode + 1;
+ ptr = md + 1;
while (*ptr != '\0')
{
switch (*ptr)
case '+':
flags = (flags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
break;
+ case 'b':
+#if defined (O_BINARY)
+ flags |= O_BINARY;
+#endif
+ break;
case '0': /* unbuffered: handled later. */
- case 'b': /* 'binary' mode: ignored. */
case 'l': /* line buffered: handled during output. */
break;
default:
- scm_out_of_range (FUNC_NAME, modes);
+ scm_out_of_range (FUNC_NAME, mode);
}
ptr++;
}
{
int en = errno;
- scm_syserror_msg (FUNC_NAME, "%s: %S",
+ SCM_SYSERROR_MSG ("~A: ~S",
scm_cons (scm_makfrom0str (strerror (en)),
- scm_cons (filename, SCM_EOL)),
- en);
+ scm_cons (filename, SCM_EOL)), en);
}
- port = scm_fdes_to_port (fdes, mode, filename);
+ port = scm_fdes_to_port (fdes, md, filename);
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'.
MODE indicates whether FILE is open for reading or writing; it uses
the same notation as open-file's second argument.
- Use NAME as the port's filename. */
-
+ NAME is a string to be used as the port's filename.
+*/
SCM
scm_fdes_to_port (int fdes, char *mode, 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;
+ if (flags != O_RDWR
+ && ((flags != O_WRONLY && (mode_bits & SCM_WRTNG))
+ || (flags != O_RDONLY && (mode_bits & SCM_RDNG))))
+ {
+ 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_SETCAR (port, (scm_tc16_fport | mode_bits));
+ SCM_SET_CELL_TYPE (port, (scm_tc16_fport | mode_bits));
{
- struct scm_fport *fp
- = (struct scm_fport *) malloc (sizeof (struct scm_fport));
- if (fp == NULL)
- scm_memory_error ("scm_fdes_to_port");
+ scm_t_fport *fp
+ = (scm_t_fport *) scm_must_malloc (sizeof (scm_t_fport),
+ FUNC_NAME);
+
fp->fdes = fdes;
pt->rw_random = SCM_FDES_RANDOM_P (fdes);
SCM_SETSTREAM (port, fp);
else
scm_fport_buffer_add (port, -1, -1);
}
- SCM_PTAB_ENTRY (port)->file_name = name;
+ SCM_SET_FILENAME (port, name);
SCM_ALLOW_INTS;
return port;
}
-
+#undef FUNC_NAME
/* Return a lower bound on the number of bytes available for input. */
static int
\f
static int
-prinfport (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);
if (SCM_OPFPORTP (exp))
{
int fdes;
- SCM name = SCM_PTAB_ENTRY (exp)->file_name;
- scm_puts (SCM_NIMP (name) && SCM_ROSTRINGP (name)
- ? SCM_ROCHARS (name)
- : SCM_PTOBNAME (SCM_PTOBNUM (exp)),
- port);
+ SCM name = SCM_FILENAME (exp);
+ if (SCM_STRINGP (name) || SCM_SYMBOLP (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);
else
+#endif /* HAVE_TTYNAME */
scm_intprint (fdes, 10, port);
}
else
{
scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port);
scm_putc (' ', port);
- scm_intprint (SCM_CDR (exp), 16, port);
+ scm_intprint ((scm_t_bits) SCM_PTAB_ENTRY (exp), 16, port);
}
scm_putc ('>', port);
return 1;
static void fport_flush (SCM port);
-/* fill a port's read-buffer with a single read.
- returns the first char and moves the read_pos pointer past it.
- or returns EOF if end of file. */
+/* fill a port's read-buffer with a single read. returns the first
+ char or EOF if end of file. */
static int
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
fport_wait_for_input (port);
static off_t
fport_seek (SCM port, off_t offset, int whence)
{
- 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);
off_t rv;
off_t result;
static void
fport_truncate (SCM port, off_t length)
{
- struct scm_fport *fp = SCM_FSTREAM (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
if (ftruncate (fp->fdes, length) == -1)
scm_syserror ("ftruncate");
}
-static void
-fport_write (SCM port, void *data, size_t size)
+/* helper for fport_write: try to write data, using multiple system
+ calls if required. */
+#define FUNC_NAME "write_all"
+static void write_all (SCM port, const void *data, size_t remaining)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ int fdes = SCM_FSTREAM (port)->fdes;
- if (pt->write_buf == &pt->shortbuf)
+ while (remaining > 0)
{
- /* "unbuffered" port. */
- int fdes = SCM_FSTREAM (port)->fdes;
+ size_t done;
+
+ SCM_SYSCALL (done = write (fdes, data, remaining));
- if (write (fdes, data, size) == -1)
- scm_syserror ("fport_write");
+ if (done == -1)
+ SCM_SYSERROR;
+ remaining -= done;
+ data = ((const char *) data) + done;
}
- else
+}
+#undef FUNC_NAME
+
+static void
+fport_write (SCM port, const void *data, size_t size)
+{
+ /* this procedure tries to minimize the number of writes/flushes. */
+ 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))
{
- const char *input = (char *) data;
- size_t remaining = size;
+ /* "unbuffered" port, or
+ port with empty buffer and data won't fit in buffer. */
+ write_all (port, data, size);
+ return;
+ }
- while (remaining > 0)
- {
- int space = pt->write_end - pt->write_pos;
- int write_len = (remaining > space) ? space : remaining;
-
- memcpy (pt->write_pos, input, write_len);
- pt->write_pos += write_len;
- remaining -= write_len;
- input += write_len;
- if (write_len == space)
+ {
+ off_t space = pt->write_end - pt->write_pos;
+
+ if (size <= space)
+ {
+ /* data fits in buffer. */
+ memcpy (pt->write_pos, data, size);
+ pt->write_pos += size;
+ if (pt->write_pos == pt->write_end)
+ {
fport_flush (port);
+ /* we can skip the line-buffering check if nothing's buffered. */
+ return;
+ }
+ }
+ else
+ {
+ memcpy (pt->write_pos, data, space);
+ pt->write_pos = pt->write_end;
+ fport_flush (port);
+ {
+ const void *ptr = ((const char *) data) + space;
+ size_t remaining = size - space;
+
+ if (size >= pt->write_buf_size)
+ {
+ write_all (port, ptr, remaining);
+ return;
+ }
+ else
+ {
+ memcpy (pt->write_pos, ptr, remaining);
+ pt->write_pos += remaining;
+ }
}
+ }
- /* handle line buffering. */
- if ((SCM_CAR (port) & SCM_BUFLINE) && memchr (data, '\n', size))
- fport_flush (port);
- }
+ /* handle line buffering. */
+ if ((SCM_CELL_WORD_0 (port) & SCM_BUFLINE) && memchr (data, '\n', size))
+ fport_flush (port);
+ }
}
/* becomes 1 when process is exiting: normal exception handling won't
static void
fport_flush (SCM port)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
- struct scm_fport *fp = SCM_FSTREAM (port);
- char *ptr = pt->write_buf;
- int init_size = pt->write_pos - pt->write_buf;
- int remaining = init_size;
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_fport *fp = SCM_FSTREAM (port);
+ unsigned char *ptr = pt->write_buf;
+ 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)
- scm_syserror ("fport_flush");
- else
+ if (terminating)
{
const char *msg = "Error: could not flush file-descriptor ";
char buf[11];
count = remaining;
}
+ else if (scm_gc_running_p)
+ {
+ /* silently ignore the error. scm_error would abort if we
+ called it now. */
+ count = remaining;
+ }
+ else
+ scm_syserror ("fport_flush");
}
ptr += count;
remaining -= count;
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);
SCM_SYSCALL (rv = close (fp->fdes));
if (rv == -1 && errno != EBADF)
- scm_syserror ("fport_close");
+ {
+ if (scm_gc_running_p)
+ /* silently ignore the error. scm_error would abort if we
+ called it now. */
+ ;
+ else
+ scm_syserror ("fport_close");
+ }
if (pt->read_buf == pt->putback_buf)
pt->read_buf = pt->saved_read_buf;
if (pt->read_buf != &pt->shortbuf)
- free (pt->read_buf);
+ scm_must_free (pt->read_buf);
if (pt->write_buf != &pt->shortbuf)
- free (pt->write_buf);
- free ((char *) fp);
+ scm_must_free (pt->write_buf);
+ scm_must_free ((char *) fp);
return rv;
}
-static scm_sizet
+static size_t
fport_free (SCM port)
{
fport_close (port);
return 0;
}
-void scm_make_fptob (void); /* Called from ports.c */
-
-void
+static scm_t_bits
scm_make_fptob ()
{
- long 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, prinfport);
+ scm_set_port_print (tc, fport_print);
scm_set_port_flush (tc, fport_flush);
scm_set_port_end_input (tc, fport_end_input);
scm_set_port_close (tc, fport_close);
scm_set_port_seek (tc, fport_seek);
scm_set_port_truncate (tc, fport_truncate);
scm_set_port_input_waiting (tc, fport_input_waiting);
+
+ return tc;
}
void
scm_init_fports ()
{
-#include "fports.x"
- scm_sysintern ("_IOFBF", SCM_MAKINUM (_IOFBF));
- scm_sysintern ("_IOLBF", SCM_MAKINUM (_IOLBF));
- scm_sysintern ("_IONBF", SCM_MAKINUM (_IONBF));
+ scm_tc16_fport = scm_make_fptob ();
+
+ scm_c_define ("_IOFBF", SCM_MAKINUM (_IOFBF));
+ scm_c_define ("_IOLBF", SCM_MAKINUM (_IOLBF));
+ scm_c_define ("_IONBF", SCM_MAKINUM (_IONBF));
+
+#ifndef SCM_MAGIC_SNARFER
+#include "libguile/fports.x"
+#endif
}
+
+/*
+ Local Variables:
+ c-file-style: "gnu"
+ End:
+*/
HCoop / bpt / guile.git / blobdiff