-/* Copyright (C) 1995,1996,1997,1998,1999, 2000 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2003 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 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 2.1 of the License, or (at your option) any later version.
*
- * This exception does not however invalidate any other reasons why
- * the executable file might be covered by the GNU General Public License.
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
-/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
- gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
\f
/* Headers. */
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
#include <stdio.h>
+#include <errno.h>
+
#include "libguile/_scm.h"
+#include "libguile/eval.h"
#include "libguile/objects.h"
#include "libguile/smob.h"
#include "libguile/chars.h"
#include <malloc.h>
#endif
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <sys/ioctl.h>
#endif
+#ifdef __MINGW32__
+#include <fcntl.h>
+#define ftruncate(fd, size) chsize (fd, size)
+#endif
+
\f
/* The port kind table --- a dynamically resized array of port types. */
* Indexes into this table are used when generating type
* tags for smobjects (if you know a tag you can get an index and conversely).
*/
-scm_ptob_descriptor *scm_ptobs;
-int scm_numptob;
+scm_t_ptob_descriptor *scm_ptobs;
+long scm_numptob;
/* GC marker for a port with stream of SCM type. */
SCM
*/
static void
-flush_port_default (SCM port)
+flush_port_default (SCM port SCM_UNUSED)
{
}
static void
-end_input_default (SCM port, int offset)
+end_input_default (SCM port SCM_UNUSED, int offset SCM_UNUSED)
{
}
-long
+static size_t
+scm_port_free0 (SCM port)
+{
+ return 0;
+}
+
+scm_t_bits
scm_make_port_type (char *name,
int (*fill_input) (SCM port),
void (*write) (SCM port, const void *data, size_t size))
SCM_DEFER_INTS;
SCM_SYSCALL (tmp = (char *) realloc ((char *) scm_ptobs,
(1 + scm_numptob)
- * sizeof (scm_ptob_descriptor)));
+ * sizeof (scm_t_ptob_descriptor)));
if (tmp)
{
- scm_ptobs = (scm_ptob_descriptor *) tmp;
+ scm_ptobs = (scm_t_ptob_descriptor *) tmp;
scm_ptobs[scm_numptob].name = name;
scm_ptobs[scm_numptob].mark = 0;
- scm_ptobs[scm_numptob].free = scm_free0;
+ scm_ptobs[scm_numptob].free = scm_port_free0;
scm_ptobs[scm_numptob].print = scm_port_print;
scm_ptobs[scm_numptob].equalp = 0;
scm_ptobs[scm_numptob].close = 0;
}
void
-scm_set_port_free (long tc, scm_sizet (*free) (SCM))
+scm_set_port_free (long tc, size_t (*free) (SCM))
{
scm_ptobs[SCM_TC2PTOBNUM (tc)].free = free;
}
\f
SCM_DEFINE (scm_char_ready_p, "char-ready?", 0, 1, 0,
- (SCM port),
- "Returns @code{#t} if a character is ready on input @var{port} and\n"
- "returns @code{#f} otherwise. If @code{char-ready?} returns @code{#t}\n"
- "then the next @code{read-char} operation on @var{port} is\n"
- "guaranteed not to hang. If @var{port} is a file port at end of\n"
- "file then @code{char-ready?} returns @code{#t}.\n"
- "@footnote{@code{char-ready?} exists to make it possible for a\n"
- "program to accept characters from interactive ports without getting\n"
- "stuck waiting for input. Any input editors associated with such ports\n"
- "must make sure that characters whose existence has been asserted by\n"
- "@code{char-ready?} cannot be rubbed out. If @code{char-ready?} were to\n"
- "return @code{#f} at end of file, a port at end of file would be\n"
- "indistinguishable from an interactive port that has no ready\n"
- "characters.}")
+ (SCM port),
+ "Return @code{#t} if a character is ready on input @var{port}\n"
+ "and return @code{#f} otherwise. If @code{char-ready?} returns\n"
+ "@code{#t} then the next @code{read-char} operation on\n"
+ "@var{port} is guaranteed not to hang. If @var{port} is a file\n"
+ "port at end of file then @code{char-ready?} returns @code{#t}.\n"
+ "@footnote{@code{char-ready?} exists to make it possible for a\n"
+ "program to accept characters from interactive ports without\n"
+ "getting stuck waiting for input. Any input editors associated\n"
+ "with such ports must make sure that characters whose existence\n"
+ "has been asserted by @code{char-ready?} cannot be rubbed out.\n"
+ "If @code{char-ready?} were to return @code{#f} at end of file,\n"
+ "a port at end of file would be indistinguishable from an\n"
+ "interactive port that has no ready characters.}")
#define FUNC_NAME s_scm_char_ready_p
{
- scm_port *pt;
+ scm_t_port *pt;
if (SCM_UNBNDP (port))
port = scm_cur_inp;
else
- SCM_VALIDATE_OPINPORT (1,port);
+ SCM_VALIDATE_OPINPORT (1, port);
pt = SCM_PTAB_ENTRY (port);
return SCM_BOOL_T;
else
{
- scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
+ scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
if (ptob->input_waiting)
return SCM_BOOL(ptob->input_waiting (port));
}
#undef FUNC_NAME
+/* move up to read_len chars from port's putback and/or read buffers
+ into memory starting at dest. returns the number of chars moved. */
+size_t scm_take_from_input_buffers (SCM port, char *dest, size_t read_len)
+{
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ size_t chars_read = 0;
+ size_t from_buf = min (pt->read_end - pt->read_pos, read_len);
+
+ if (from_buf > 0)
+ {
+ memcpy (dest, pt->read_pos, from_buf);
+ pt->read_pos += from_buf;
+ chars_read += from_buf;
+ read_len -= from_buf;
+ dest += from_buf;
+ }
+
+ /* if putback was active, try the real input buffer too. */
+ if (pt->read_buf == pt->putback_buf)
+ {
+ from_buf = min (pt->saved_read_end - pt->saved_read_pos, read_len);
+ if (from_buf > 0)
+ {
+ memcpy (dest, pt->saved_read_pos, from_buf);
+ pt->saved_read_pos += from_buf;
+ chars_read += from_buf;
+ }
+ }
+ return chars_read;
+}
+
/* Clear a port's read buffers, returning the contents. */
SCM_DEFINE (scm_drain_input, "drain-input", 1, 0, 0,
(SCM port),
- "Drains @var{PORT}'s read buffers (including any pushed-back characters)\n"
- "and returns the contents as a single string.")
+ "This procedure clears a port's input buffers, similar\n"
+ "to the way that force-output clears the output buffer. The\n"
+ "contents of the buffers are returned as a single string, e.g.,\n"
+ "\n"
+ "@lisp\n"
+ "(define p (open-input-file ...))\n"
+ "(drain-input p) => empty string, nothing buffered yet.\n"
+ "(unread-char (read-char p) p)\n"
+ "(drain-input p) => initial chars from p, up to the buffer size.\n"
+ "@end lisp\n\n"
+ "Draining the buffers may be useful for cleanly finishing\n"
+ "buffered I/O so that the file descriptor can be used directly\n"
+ "for further input.")
#define FUNC_NAME s_scm_drain_input
{
SCM result;
- scm_port *pt = SCM_PTAB_ENTRY (port);
- int count;
- char *dst;
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ long count;
- SCM_VALIDATE_OPINPORT (1,port);
+ SCM_VALIDATE_OPINPORT (1, port);
count = pt->read_end - pt->read_pos;
if (pt->read_buf == pt->putback_buf)
count += pt->saved_read_end - pt->saved_read_pos;
- result = scm_makstr (count, 0);
- dst = SCM_CHARS (result);
-
- while (pt->read_pos < pt->read_end)
- *dst++ = *(pt->read_pos++);
-
- if (pt->read_buf == pt->putback_buf)
- {
- while (pt->saved_read_pos < pt->saved_read_end)
- *dst++ = *(pt->saved_read_pos++);
- }
+ result = scm_allocate_string (count);
+ scm_take_from_input_buffers (port, SCM_STRING_CHARS (result), count);
return result;
}
/* Standard ports --- current input, output, error, and more(!). */
SCM_DEFINE (scm_current_input_port, "current-input-port", 0, 0, 0,
- (),
- "Returns the current input port. This is the default port used by many\n"
- "input procedures. Initially, @code{current-input-port} returns the\n"
- "value of @code{???}.")
+ (),
+ "Return the current input port. This is the default port used\n"
+ "by many input procedures. Initially, @code{current-input-port}\n"
+ "returns the @dfn{standard input} in Unix and C terminology.")
#define FUNC_NAME s_scm_current_input_port
{
return scm_cur_inp;
#undef FUNC_NAME
SCM_DEFINE (scm_current_output_port, "current-output-port", 0, 0, 0,
- (),
- "Returns the current output port. This is the default port used by many\n"
- "output procedures. Initially, @code{current-output-port} returns the\n"
- "value of @code{???}.")
+ (),
+ "Return the current output port. This is the default port used\n"
+ "by many output procedures. Initially,\n"
+ "@code{current-output-port} returns the @dfn{standard output} in\n"
+ "Unix and C terminology.")
#define FUNC_NAME s_scm_current_output_port
{
return scm_cur_outp;
#undef FUNC_NAME
SCM_DEFINE (scm_current_load_port, "current-load-port", 0, 0, 0,
- (),
+ (),
"Return the current-load-port.\n"
- "The load port is used internally by `primitive-load'.")
+ "The load port is used internally by @code{primitive-load}.")
#define FUNC_NAME s_scm_current_load_port
{
return scm_cur_loadp;
SCM_DEFINE (scm_set_current_input_port, "set-current-input-port", 1, 0, 0,
(SCM port),
- "@deffnx primitive set-current-output-port port\n"
- "@deffnx primitive set-current-error-port port\n"
+ "@deffnx {Scheme Procedure} set-current-output-port port\n"
+ "@deffnx {Scheme Procedure} set-current-error-port port\n"
"Change the ports returned by @code{current-input-port},\n"
"@code{current-output-port} and @code{current-error-port}, respectively,\n"
"so that they use the supplied @var{port} for input or output.")
#define FUNC_NAME s_scm_set_current_input_port
{
SCM oinp = scm_cur_inp;
- SCM_VALIDATE_OPINPORT (1,port);
+ SCM_VALIDATE_OPINPORT (1, port);
scm_cur_inp = port;
return oinp;
}
SCM_DEFINE (scm_set_current_output_port, "set-current-output-port", 1, 0, 0,
- (SCM port),
- "Set the current default output port to PORT.")
+ (SCM port),
+ "Set the current default output port to @var{port}.")
#define FUNC_NAME s_scm_set_current_output_port
{
SCM ooutp = scm_cur_outp;
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPOUTPORT (1,port);
+ SCM_VALIDATE_OPOUTPORT (1, port);
scm_cur_outp = port;
return ooutp;
}
SCM_DEFINE (scm_set_current_error_port, "set-current-error-port", 1, 0, 0,
- (SCM port),
- "Set the current default error port to PORT.")
+ (SCM port),
+ "Set the current default error port to @var{port}.")
#define FUNC_NAME s_scm_set_current_error_port
{
SCM oerrp = scm_cur_errp;
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPOUTPORT (1,port);
+ SCM_VALIDATE_OPOUTPORT (1, port);
scm_cur_errp = port;
return oerrp;
}
\f
/* The port table --- an array of pointers to ports. */
-scm_port **scm_port_table;
+scm_t_port **scm_i_port_table;
-int scm_port_table_size = 0; /* Number of ports in scm_port_table. */
-int scm_port_table_room = 20; /* Size of the array. */
+long scm_i_port_table_size = 0; /* Number of ports in scm_i_port_table. */
+long scm_i_port_table_room = 20; /* Size of the array. */
-/* Add a port to the table. */
+SCM_GLOBAL_MUTEX (scm_i_port_table_mutex);
-scm_port *
-scm_add_to_port_table (SCM port)
-{
- scm_port *entry;
+/* This function is not and should not be thread safe. */
- if (scm_port_table_size == scm_port_table_room)
+SCM
+scm_new_port_table_entry (scm_t_bits tag)
+#define FUNC_NAME "scm_new_port_table_entry"
+{
+ /*
+ We initialize the cell to empty, this is in case scm_gc_calloc
+ triggers GC ; we don't want the GC to scan a half-finished Z.
+ */
+
+ SCM z = scm_cons (SCM_EOL, SCM_EOL);
+ scm_t_port *entry = (scm_t_port *) scm_gc_calloc (sizeof (scm_t_port), "port");
+ if (scm_i_port_table_size == scm_i_port_table_room)
{
- void *newt = realloc ((char *) scm_port_table,
- (scm_sizet) (sizeof (scm_port *)
- * scm_port_table_room * 2));
- if (newt == NULL)
- scm_memory_error ("scm_add_to_port_table");
- scm_port_table = (scm_port **) newt;
- scm_port_table_room *= 2;
+ /* initial malloc is in gc.c. this doesn't use scm_gc_malloc etc.,
+ since it can never be freed during gc. */
+ void *newt = scm_realloc ((char *) scm_i_port_table,
+ (size_t) (sizeof (scm_t_port *)
+ * scm_i_port_table_room * 2));
+ scm_i_port_table = (scm_t_port **) newt;
+ scm_i_port_table_room *= 2;
}
- entry = (scm_port *) malloc (sizeof (scm_port));
- if (entry == NULL)
- scm_memory_error ("scm_add_to_port_table");
-
- entry->port = port;
- entry->entry = scm_port_table_size;
- entry->revealed = 0;
- entry->stream = 0;
+
+ entry->entry = scm_i_port_table_size;
+
entry->file_name = SCM_BOOL_F;
- entry->line_number = 0;
- entry->column_number = 0;
- entry->putback_buf = 0;
- entry->putback_buf_size = 0;
entry->rw_active = SCM_PORT_NEITHER;
- entry->rw_random = 0;
- scm_port_table[scm_port_table_size] = entry;
- scm_port_table_size++;
+ scm_i_port_table[scm_i_port_table_size] = entry;
+ scm_i_port_table_size++;
- return entry;
+ entry->port = z;
+ SCM_SET_CELL_TYPE(z, tag);
+ SCM_SETPTAB_ENTRY(z, entry);
+
+ return z;
}
+#undef FUNC_NAME
+
+#if SCM_ENABLE_DEPRECATED==1
+SCM_API scm_t_port *
+scm_add_to_port_table (SCM port)
+{
+ SCM z = scm_new_port_table_entry (scm_tc7_port);
+ scm_t_port * pt = SCM_PTAB_ENTRY(z);
+
+ pt->port = port;
+ SCM_SETCAR(z, SCM_EOL);
+ SCM_SETCDR(z, SCM_EOL);
+ SCM_SETPTAB_ENTRY (port, pt);
+ return pt;
+}
+#endif
+
/* Remove a port from the table and destroy it. */
+/* This function is not and should not be thread safe. */
+
void
scm_remove_from_port_table (SCM port)
+#define FUNC_NAME "scm_remove_from_port_table"
{
- scm_port *p = SCM_PTAB_ENTRY (port);
- int i = p->entry;
+ scm_t_port *p = SCM_PTAB_ENTRY (port);
+ long i = p->entry;
- if (i >= scm_port_table_size)
- scm_wta (port, "Port not in table", "scm_remove_from_port_table");
+ if (i >= scm_i_port_table_size)
+ SCM_MISC_ERROR ("Port not in table: ~S", scm_list_1 (port));
if (p->putback_buf)
- free (p->putback_buf);
- free (p);
+ scm_gc_free (p->putback_buf, p->putback_buf_size, "putback buffer");
+ scm_gc_free (p, sizeof (scm_t_port), "port");
/* Since we have just freed slot i we can shrink the table by moving
the last entry to that slot... */
- if (i < scm_port_table_size - 1)
+ if (i < scm_i_port_table_size - 1)
{
- scm_port_table[i] = scm_port_table[scm_port_table_size - 1];
- scm_port_table[i]->entry = i;
+ scm_i_port_table[i] = scm_i_port_table[scm_i_port_table_size - 1];
+ scm_i_port_table[i]->entry = i;
}
SCM_SETPTAB_ENTRY (port, 0);
- scm_port_table_size--;
+ scm_i_port_table_size--;
}
+#undef FUNC_NAME
+
#ifdef GUILE_DEBUG
/* Functions for debugging. */
SCM_DEFINE (scm_pt_size, "pt-size", 0, 0, 0,
(),
- "Returns the number of ports in the port table.\n"
- "`pt-size' is only included in GUILE_DEBUG builds.")
+ "Return the number of ports in the port table. @code{pt-size}\n"
+ "is only included in @code{--enable-guile-debug} builds.")
#define FUNC_NAME s_scm_pt_size
{
- return SCM_MAKINUM (scm_port_table_size);
+ return SCM_MAKINUM (scm_i_port_table_size);
}
#undef FUNC_NAME
SCM_DEFINE (scm_pt_member, "pt-member", 1, 0, 0,
(SCM index),
- "Returns the port at INDEX in the port table.\n"
- "`pt-member' is only included in GUILE_DEBUG builds.")
+ "Return the port at @var{index} in the port table.\n"
+ "@code{pt-member} is only included in\n"
+ "@code{--enable-guile-debug} builds.")
#define FUNC_NAME s_scm_pt_member
{
- int i;
- SCM_VALIDATE_INUM_COPY (1,index,i);
- if (i < 0 || i >= scm_port_table_size)
+ long i;
+ SCM_VALIDATE_INUM_COPY (1, index, i);
+ if (i < 0 || i >= scm_i_port_table_size)
return SCM_BOOL_F;
else
- return scm_port_table[i]->port;
+ return scm_i_port_table[i]->port;
}
#undef FUNC_NAME
#endif
void
-scm_port_non_buffer (scm_port *pt)
+scm_port_non_buffer (scm_t_port *pt)
{
pt->read_pos = pt->read_buf = pt->read_end = &pt->shortbuf;
pt->write_buf = pt->write_pos = &pt->shortbuf;
SCM_DEFINE (scm_port_revealed, "port-revealed", 1, 0, 0,
(SCM port),
- "Returns the revealed count for @var{port}.")
+ "Return the revealed count for @var{port}.")
#define FUNC_NAME s_scm_port_revealed
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_PORT (1,port);
+ SCM_VALIDATE_OPENPORT (1, port);
return SCM_MAKINUM (scm_revealed_count (port));
}
#undef FUNC_NAME
#define FUNC_NAME s_scm_set_port_revealed_x
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_PORT (1,port);
- SCM_VALIDATE_INUM (2,rcount);
+ SCM_VALIDATE_OPENPORT (1, port);
+ SCM_VALIDATE_INUM (2, rcount);
SCM_REVEALED (port) = SCM_INUM (rcount);
return SCM_UNSPECIFIED;
}
SCM_DEFINE (scm_port_mode, "port-mode", 1, 0, 0,
(SCM port),
- "Returns the port modes associated with the open port @var{port}. These\n"
- "will not necessarily be identical to the modes used when the port was\n"
- "opened, since modes such as \"append\" which are used only during\n"
- "port creation are not retained.")
+ "Return the port modes associated with the open port @var{port}.\n"
+ "These will not necessarily be identical to the modes used when\n"
+ "the port was opened, since modes such as \"append\" which are\n"
+ "used only during port creation are not retained.")
#define FUNC_NAME s_scm_port_mode
{
- char modes[3];
+ char modes[4];
modes[0] = '\0';
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPPORT (1,port);
+ SCM_VALIDATE_OPPORT (1, port);
if (SCM_CELL_WORD_0 (port) & SCM_RDNG) {
if (SCM_CELL_WORD_0 (port) & SCM_WRTNG)
strcpy (modes, "r+");
strcpy (modes, "w");
if (SCM_CELL_WORD_0 (port) & SCM_BUF0)
strcat (modes, "0");
- return scm_makfromstr (modes, strlen (modes), 0);
+ return scm_mem2string (modes, strlen (modes));
}
#undef FUNC_NAME
*/
SCM_DEFINE (scm_close_port, "close-port", 1, 0, 0,
(SCM port),
- "Close the specified port object. Returns @code{#t} if it successfully\n"
- "closes a port or @code{#f} if it was already\n"
- "closed. An exception may be raised if an error occurs, for example\n"
- "when flushing buffered output.\n"
- "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
- "which can close file descriptors.")
+ "Close the specified port object. Return @code{#t} if it\n"
+ "successfully closes a port or @code{#f} if it was already\n"
+ "closed. An exception may be raised if an error occurs, for\n"
+ "example when flushing buffered output. See also @ref{Ports and\n"
+ "File Descriptors, close}, for a procedure which can close file\n"
+ "descriptors.")
#define FUNC_NAME s_scm_close_port
{
- scm_sizet i;
+ size_t i;
int rv;
port = SCM_COERCE_OUTPORT (port);
rv = (scm_ptobs[i].close) (port);
else
rv = 0;
+ scm_mutex_lock (&scm_i_port_table_mutex);
scm_remove_from_port_table (port);
- SCM_SETAND_CAR (port, ~SCM_OPN);
- return SCM_NEGATE_BOOL (rv < 0);
+ scm_mutex_unlock (&scm_i_port_table_mutex);
+ SCM_CLR_PORT_OPEN_FLAG (port);
+ return SCM_BOOL (rv >= 0);
}
#undef FUNC_NAME
}
#undef FUNC_NAME
-SCM_DEFINE (scm_close_all_ports_except, "close-all-ports-except", 0, 0, 1,
- (SCM ports),
- "Close all open file ports used by the interpreter\n"
- "except for those supplied as arguments. This procedure\n"
- "is intended to be used before an exec call to close file descriptors\n"
- "which are not needed in the new process.")
-#define FUNC_NAME s_scm_close_all_ports_except
-{
- int i = 0;
- SCM_VALIDATE_REST_ARGUMENT (ports);
- while (i < scm_port_table_size)
+SCM_DEFINE (scm_port_for_each, "port-for-each", 1, 0, 0,
+ (SCM proc),
+ "Apply @var{proc} to each port in the Guile port table\n"
+ "in turn. The return value is unspecified. More specifically,\n"
+ "@var{proc} is applied exactly once to every port that exists\n"
+ "in the system at the time @var{port-for-each} is invoked.\n"
+ "Changes to the port table while @var{port-for-each} is running\n"
+ "have no effect as far as @var{port-for-each} is concerned.")
+#define FUNC_NAME s_scm_port_for_each
+{
+ long i;
+ SCM ports;
+
+ SCM_VALIDATE_PROC (1, proc);
+
+ /* Even without pre-emptive multithreading, running arbitrary code
+ while scanning the port table is unsafe because the port table
+ can change arbitrarily (from a GC, for example). So we build a
+ list in advance while blocking the GC. -mvo */
+
+ scm_mutex_lock (&scm_i_port_table_mutex);
+ scm_block_gc++;
+ ports = SCM_EOL;
+ for (i = 0; i < scm_i_port_table_size; i++)
+ ports = scm_cons (scm_i_port_table[i]->port, ports);
+ scm_block_gc--;
+ scm_mutex_unlock (&scm_i_port_table_mutex);
+
+ while (ports != SCM_EOL)
{
- SCM thisport = scm_port_table[i]->port;
- int found = 0;
- SCM ports_ptr = ports;
-
- while (SCM_NNULLP (ports_ptr))
- {
- SCM port = SCM_COERCE_OUTPORT (SCM_CAR (ports_ptr));
- if (i == 0)
- SCM_VALIDATE_OPPORT (SCM_ARG1,port);
- if (SCM_EQ_P (port, thisport))
- found = 1;
- ports_ptr = SCM_CDR (ports_ptr);
- }
- if (found)
- i++;
- else
- /* i is not to be incremented here. */
- scm_close_port (thisport);
+ scm_call_1 (proc, SCM_CAR (ports));
+ ports = SCM_CDR (ports);
}
+
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
-
\f
/* Utter miscellany. Gosh, we should clean this up some time. */
SCM_DEFINE (scm_input_port_p, "input-port?", 1, 0, 0,
(SCM x),
- "Returns @code{#t} if @var{x} is an input port, otherwise returns\n"
- "@code{#f}. Any object satisfying this predicate also satisfies\n"
- "@code{port?}.")
+ "Return @code{#t} if @var{x} is an input port, otherwise return\n"
+ "@code{#f}. Any object satisfying this predicate also satisfies\n"
+ "@code{port?}.")
#define FUNC_NAME s_scm_input_port_p
{
- if (SCM_IMP (x))
- return SCM_BOOL_F;
- return SCM_BOOL(SCM_INPUT_PORT_P (x));
+ return SCM_BOOL (SCM_INPUT_PORT_P (x));
}
#undef FUNC_NAME
SCM_DEFINE (scm_output_port_p, "output-port?", 1, 0, 0,
(SCM x),
- "Returns @code{#t} if @var{x} is an output port, otherwise returns\n"
- "@code{#f}. Any object satisfying this predicate also satisfies\n"
- "@code{port?}.")
+ "Return @code{#t} if @var{x} is an output port, otherwise return\n"
+ "@code{#f}. Any object satisfying this predicate also satisfies\n"
+ "@code{port?}.")
#define FUNC_NAME s_scm_output_port_p
{
- if (SCM_IMP (x))
- return SCM_BOOL_F;
- if (SCM_PORT_WITH_PS_P (x))
- x = SCM_PORT_WITH_PS_PORT (x);
- return SCM_BOOL(SCM_OUTPUT_PORT_P (x));
+ x = SCM_COERCE_OUTPORT (x);
+ return SCM_BOOL (SCM_OUTPUT_PORT_P (x));
+}
+#undef FUNC_NAME
+
+SCM_DEFINE (scm_port_p, "port?", 1, 0, 0,
+ (SCM x),
+ "Return a boolean indicating whether @var{x} is a port.\n"
+ "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n"
+ "@var{x}))}.")
+#define FUNC_NAME s_scm_port_p
+{
+ return SCM_BOOL (SCM_PORTP (x));
}
#undef FUNC_NAME
SCM_DEFINE (scm_port_closed_p, "port-closed?", 1, 0, 0,
(SCM port),
- "Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.")
+ "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n"
+ "open.")
#define FUNC_NAME s_scm_port_closed_p
{
- SCM_VALIDATE_PORT (1,port);
- return SCM_NEGATE_BOOL(SCM_OPPORTP (port));
+ SCM_VALIDATE_PORT (1, port);
+ return SCM_BOOL (!SCM_OPPORTP (port));
}
#undef FUNC_NAME
SCM_DEFINE (scm_eof_object_p, "eof-object?", 1, 0, 0,
(SCM x),
- "Returns @code{#t} if @var{x} is an end-of-file object; otherwise\n"
- "returns @code{#f}.")
+ "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n"
+ "return @code{#f}.")
#define FUNC_NAME s_scm_eof_object_p
{
return SCM_BOOL(SCM_EOF_OBJECT_P (x));
SCM_DEFINE (scm_force_output, "force-output", 0, 1, 0,
(SCM port),
"Flush the specified output port, or the current output port if @var{port}\n"
- "is omitted. The current output buffer contents are passed to the \n"
+ "is omitted. The current output buffer contents are passed to the\n"
"underlying port implementation (e.g., in the case of fports, the\n"
"data will be written to the file and the output buffer will be cleared.)\n"
"It has no effect on an unbuffered port.\n\n"
else
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPOUTPORT (1,port);
+ SCM_VALIDATE_OPOUTPORT (1, port);
}
scm_flush (port);
return SCM_UNSPECIFIED;
"all open output ports. The return value is unspecified.")
#define FUNC_NAME s_scm_flush_all_ports
{
- int i;
+ size_t i;
- for (i = 0; i < scm_port_table_size; i++)
+ scm_mutex_lock (&scm_i_port_table_mutex);
+ for (i = 0; i < scm_i_port_table_size; i++)
{
- if (SCM_OPOUTPORTP (scm_port_table[i]->port))
- scm_flush (scm_port_table[i]->port);
+ if (SCM_OPOUTPORTP (scm_i_port_table[i]->port))
+ scm_flush (scm_i_port_table[i]->port);
}
+ scm_mutex_unlock (&scm_i_port_table_mutex);
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
SCM_DEFINE (scm_read_char, "read-char", 0, 1, 0,
(SCM port),
- "Returns the next character available from @var{port}, updating\n"
- "@var{port} to point to the following character. If no more\n"
- "characters are available, an end-of-file object is returned.")
+ "Return the next character available from @var{port}, updating\n"
+ "@var{port} to point to the following character. If no more\n"
+ "characters are available, the end-of-file object is returned.")
#define FUNC_NAME s_scm_read_char
{
int c;
if (SCM_UNBNDP (port))
port = scm_cur_inp;
- SCM_VALIDATE_OPINPORT (1,port);
+ SCM_VALIDATE_OPINPORT (1, port);
c = scm_getc (port);
if (EOF == c)
return SCM_EOF_VAL;
int
scm_fill_input (SCM port)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (pt->read_buf == pt->putback_buf)
{
scm_getc (SCM port)
{
int c;
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (pt->rw_active == SCM_PORT_WRITE)
- {
- /* may be marginally faster than calling scm_flush. */
- scm_ptobs[SCM_PTOBNUM (port)].flush (port);
- }
+ /* may be marginally faster than calling scm_flush. */
+ scm_ptobs[SCM_PTOBNUM (port)].flush (port);
if (pt->rw_random)
pt->rw_active = SCM_PORT_READ;
c = *(pt->read_pos++);
- if (c == '\n')
- {
- SCM_INCLINE (port);
- }
- else if (c == '\t')
+ switch (c)
{
- SCM_TABCOL (port);
+ case '\n':
+ SCM_INCLINE (port);
+ break;
+ case '\t':
+ SCM_TABCOL (port);
+ break;
+ default:
+ SCM_INCCOL (port);
+ break;
}
- else
- {
- SCM_INCCOL (port);
- }
-
+
return c;
}
scm_lfwrite (s, strlen (s), port);
}
+/* scm_lfwrite
+ *
+ * This function differs from scm_c_write; it updates port line and
+ * column. */
+
void
-scm_lfwrite (const char *ptr, scm_sizet size, SCM port)
+scm_lfwrite (const char *ptr, size_t size, SCM port)
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
- scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
if (pt->rw_active == SCM_PORT_READ)
scm_end_input (port);
ptob->write (port, ptr, size);
+ for (; size; ptr++, size--) {
+ if (*ptr == '\n') {
+ SCM_INCLINE(port);
+ }
+ else if (*ptr == '\t') {
+ SCM_TABCOL(port);
+ }
+ else {
+ SCM_INCCOL(port);
+ }
+ }
+
if (pt->rw_random)
pt->rw_active = SCM_PORT_WRITE;
}
+/* scm_c_read
+ *
+ * Used by an application to read arbitrary number of bytes from an
+ * SCM port. Same semantics as libc read, except that scm_c_read only
+ * returns less than SIZE bytes if at end-of-file.
+ *
+ * Warning: Doesn't update port line and column counts! */
+
+size_t
+scm_c_read (SCM port, void *buffer, size_t size)
+{
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ size_t n_read = 0, n_available;
+
+ if (pt->rw_active == SCM_PORT_WRITE)
+ scm_ptobs[SCM_PTOBNUM (port)].flush (port);
+
+ if (pt->rw_random)
+ pt->rw_active = SCM_PORT_READ;
+
+ if (SCM_READ_BUFFER_EMPTY_P (pt))
+ {
+ if (scm_fill_input (port) == EOF)
+ return 0;
+ }
+
+ n_available = pt->read_end - pt->read_pos;
+
+ while (n_available < size)
+ {
+ memcpy (buffer, pt->read_pos, n_available);
+ buffer = (char *) buffer + n_available;
+ pt->read_pos += n_available;
+ n_read += n_available;
+
+ if (SCM_READ_BUFFER_EMPTY_P (pt))
+ {
+ if (scm_fill_input (port) == EOF)
+ return n_read;
+ }
+
+ size -= n_available;
+ n_available = pt->read_end - pt->read_pos;
+ }
+
+ memcpy (buffer, pt->read_pos, size);
+ pt->read_pos += size;
+
+ return n_read + size;
+}
+
+/* scm_c_write
+ *
+ * Used by an application to write arbitrary number of bytes to an SCM
+ * port. Similar semantics as libc write. However, unlike libc
+ * write, scm_c_write writes the requested number of bytes and has no
+ * return value.
+ *
+ * Warning: Doesn't update port line and column counts!
+ */
+
+void
+scm_c_write (SCM port, const void *ptr, size_t size)
+{
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
+
+ if (pt->rw_active == SCM_PORT_READ)
+ scm_end_input (port);
+
+ ptob->write (port, ptr, size);
+
+ if (pt->rw_random)
+ pt->rw_active = SCM_PORT_WRITE;
+}
void
scm_flush (SCM port)
{
- scm_sizet i = SCM_PTOBNUM (port);
+ long i = SCM_PTOBNUM (port);
(scm_ptobs[i].flush) (port);
}
void
scm_end_input (SCM port)
{
- int offset;
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ long offset;
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (pt->read_buf == pt->putback_buf)
{
void
scm_ungetc (int c, SCM port)
+#define FUNC_NAME "scm_ungetc"
{
- scm_port *pt = SCM_PTAB_ENTRY (port);
+ scm_t_port *pt = SCM_PTAB_ENTRY (port);
if (pt->read_buf == pt->putback_buf)
/* already using the put-back buffer. */
if (pt->read_end == pt->read_buf + pt->read_buf_size
&& pt->read_buf == pt->read_pos)
{
- int new_size = pt->read_buf_size * 2;
- unsigned char *tmp =
- (unsigned char *) realloc (pt->putback_buf, new_size);
+ size_t new_size = pt->read_buf_size * 2;
+ unsigned char *tmp = (unsigned char *)
+ scm_gc_realloc (pt->putback_buf, pt->read_buf_size, new_size,
+ "putback buffer");
- if (tmp == NULL)
- scm_memory_error ("scm_ungetc");
pt->read_pos = pt->read_buf = pt->putback_buf = tmp;
pt->read_end = pt->read_buf + pt->read_buf_size;
pt->read_buf_size = pt->putback_buf_size = new_size;
if (pt->putback_buf == NULL)
{
pt->putback_buf
- = (unsigned char *) malloc (SCM_INITIAL_PUTBACK_BUF_SIZE);
- if (pt->putback_buf == NULL)
- scm_memory_error ("scm_ungetc");
+ = (unsigned char *) scm_gc_malloc (SCM_INITIAL_PUTBACK_BUF_SIZE,
+ "putback buffer");
pt->putback_buf_size = SCM_INITIAL_PUTBACK_BUF_SIZE;
}
else
SCM_COL(port) -= 1;
}
+#undef FUNC_NAME
void
SCM_DEFINE (scm_peek_char, "peek-char", 0, 1, 0,
(SCM port),
- "Returns the next character available from @var{port},\n"
- "@emph{without} updating @var{port} to point to the following\n"
- "character. If no more characters are available, an end-of-file object\n"
- "is returned.@footnote{The value returned by a call to @code{peek-char}\n"
- "is the same as the value that would have been returned by a call to\n"
- "@code{read-char} on the same port. The only difference is that the very\n"
- "next call to @code{read-char} or @code{peek-char} on that\n"
- "@var{port} will return the value returned by the preceding call to\n"
- "@code{peek-char}. In particular, a call to @code{peek-char} on an\n"
- "interactive port will hang waiting for input whenever a call to\n"
- "@code{read-char} would have hung.}")
+ "Return the next character available from @var{port},\n"
+ "@emph{without} updating @var{port} to point to the following\n"
+ "character. If no more characters are available, the\n"
+ "end-of-file object is returned.@footnote{The value returned by\n"
+ "a call to @code{peek-char} is the same as the value that would\n"
+ "have been returned by a call to @code{read-char} on the same\n"
+ "port. The only difference is that the very next call to\n"
+ "@code{read-char} or @code{peek-char} on that @var{port} will\n"
+ "return the value returned by the preceding call to\n"
+ "@code{peek-char}. In particular, a call to @code{peek-char} on\n"
+ "an interactive port will hang waiting for input whenever a call\n"
+ "to @code{read-char} would have hung.}")
#define FUNC_NAME s_scm_peek_char
{
int c;
if (SCM_UNBNDP (port))
port = scm_cur_inp;
else
- SCM_VALIDATE_OPINPORT (1,port);
+ SCM_VALIDATE_OPINPORT (1, port);
c = scm_getc (port);
if (EOF == c)
return SCM_EOF_VAL;
}
#undef FUNC_NAME
-SCM_DEFINE (scm_unread_char, "unread-char", 2, 0, 0,
+SCM_DEFINE (scm_unread_char, "unread-char", 1, 1, 0,
(SCM cobj, SCM port),
"Place @var{char} in @var{port} so that it will be read by the\n"
"next read operation. If called multiple times, the unread characters\n"
{
int c;
- SCM_VALIDATE_CHAR (1,cobj);
+ SCM_VALIDATE_CHAR (1, cobj);
if (SCM_UNBNDP (port))
port = scm_cur_inp;
else
- SCM_VALIDATE_OPINPORT (2,port);
+ SCM_VALIDATE_OPINPORT (2, port);
c = SCM_CHAR (cobj);
"@var{port} is not supplied, the current-input-port is used.")
#define FUNC_NAME s_scm_unread_string
{
- SCM_VALIDATE_STRING (1,str);
+ SCM_VALIDATE_STRING (1, str);
if (SCM_UNBNDP (port))
port = scm_cur_inp;
else
- SCM_VALIDATE_OPINPORT (2,port);
+ SCM_VALIDATE_OPINPORT (2, port);
- scm_ungets (SCM_ROCHARS (str), SCM_LENGTH (str), port);
+ scm_ungets (SCM_STRING_CHARS (str), SCM_STRING_LENGTH (str), port);
return str;
}
#undef FUNC_NAME
SCM_DEFINE (scm_seek, "seek", 3, 0, 0,
- (SCM object, SCM offset, SCM whence),
- "Sets the current position of @var{fd/port} to the integer @var{offset},\n"
- "which is interpreted according to the value of @var{whence}.\n\n"
- "One of the following variables should be supplied\n"
- "for @var{whence}:\n"
+ (SCM fd_port, SCM offset, SCM whence),
+ "Sets the current position of @var{fd/port} to the integer\n"
+ "@var{offset}, which is interpreted according to the value of\n"
+ "@var{whence}.\n"
+ "\n"
+ "One of the following variables should be supplied for\n"
+ "@var{whence}:\n"
"@defvar SEEK_SET\n"
"Seek from the beginning of the file.\n"
"@end defvar\n"
"@end defvar\n"
"@defvar SEEK_END\n"
"Seek from the end of the file.\n"
- "@end defvar\n\n"
- "If @var{fd/port} is a file descriptor, the underlying system call is\n"
- "@code{lseek}. @var{port} may be a string port.\n\n"
- "The value returned is the new position in the file. This means that\n"
- "the current position of a port can be obtained using:\n"
- "@smalllisp\n"
+ "@end defvar\n"
+ "If @var{fd/port} is a file descriptor, the underlying system\n"
+ "call is @code{lseek}. @var{port} may be a string port.\n"
+ "\n"
+ "The value returned is the new position in the file. This means\n"
+ "that the current position of a port can be obtained using:\n"
+ "@lisp\n"
"(seek port 0 SEEK_CUR)\n"
- "@end smalllisp")
+ "@end lisp")
#define FUNC_NAME s_scm_seek
{
off_t off;
off_t rv;
int how;
- object = SCM_COERCE_OUTPORT (object);
+ fd_port = SCM_COERCE_OUTPORT (fd_port);
- off = SCM_NUM2LONG (2,offset);
- SCM_VALIDATE_INUM_COPY (3,whence,how);
+ off = SCM_NUM2LONG (2, offset);
+ SCM_VALIDATE_INUM_COPY (3, whence, how);
if (how != SEEK_SET && how != SEEK_CUR && how != SEEK_END)
SCM_OUT_OF_RANGE (3, whence);
- if (SCM_OPPORTP (object))
+ if (SCM_OPPORTP (fd_port))
{
- scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
+ scm_t_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (fd_port);
if (!ptob->seek)
SCM_MISC_ERROR ("port is not seekable",
- scm_cons (object, SCM_EOL));
+ scm_cons (fd_port, SCM_EOL));
else
- rv = ptob->seek (object, off, how);
+ rv = ptob->seek (fd_port, off, how);
}
else /* file descriptor?. */
{
- SCM_VALIDATE_INUM (1,object);
- rv = lseek (SCM_INUM (object), off, how);
+ SCM_VALIDATE_INUM (1, fd_port);
+ rv = lseek (SCM_INUM (fd_port), off, how);
if (rv == -1)
SCM_SYSERROR;
}
}
#undef FUNC_NAME
+#ifdef __MINGW32__
+/* Define this function since it is not supported under Windows. */
+static int truncate (char *file, int length)
+{
+ int ret = -1, fdes;
+ if ((fdes = open (file, O_BINARY | O_WRONLY)) != -1)
+ {
+ ret = chsize (fdes, length);
+ close (fdes);
+ }
+ return ret;
+}
+#endif /* __MINGW32__ */
+
SCM_DEFINE (scm_truncate_file, "truncate-file", 1, 1, 0,
(SCM object, SCM length),
- "Truncates the object referred to by @var{obj} to at most @var{size} bytes.\n"
- "@var{obj} can be a string containing a file name or an integer file\n"
- "descriptor or a port. @var{size} may be omitted if @var{obj} is not\n"
- "a file name, in which case the truncation occurs at the current port.\n"
- "position.\n\n"
- "The return value is unspecified.")
+ "Truncates the object referred to by @var{object} to at most\n"
+ "@var{length} bytes. @var{object} can be a string containing a\n"
+ "file name or an integer file descriptor or a port.\n"
+ "@var{length} may be omitted if @var{object} is not a file name,\n"
+ "in which case the truncation occurs at the current port.\n"
+ "position. The return value is unspecified.")
#define FUNC_NAME s_scm_truncate_file
{
int rv;
if (SCM_UNBNDP (length))
{
/* must supply length if object is a filename. */
- if (SCM_ROSTRINGP (object))
- SCM_MISC_ERROR("must supply length if OBJECT is a filename",SCM_EOL);
+ if (SCM_STRINGP (object))
+ SCM_MISC_ERROR("must supply length if OBJECT is a filename", SCM_EOL);
length = scm_seek (object, SCM_INUM0, SCM_MAKINUM (SEEK_CUR));
}
- c_length = SCM_NUM2LONG (2,length);
+ c_length = SCM_NUM2LONG (2, length);
if (c_length < 0)
SCM_MISC_ERROR ("negative offset", SCM_EOL);
}
else if (SCM_OPOUTPORTP (object))
{
- scm_port *pt = SCM_PTAB_ENTRY (object);
- scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
+ scm_t_port *pt = SCM_PTAB_ENTRY (object);
+ scm_t_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
if (!ptob->truncate)
SCM_MISC_ERROR ("port is not truncatable", SCM_EOL);
}
else
{
- SCM_VALIDATE_ROSTRING (1,object);
- SCM_COERCE_SUBSTR (object);
- SCM_SYSCALL (rv = truncate (SCM_ROCHARS (object), c_length));
+ SCM_VALIDATE_STRING (1, object);
+ SCM_SYSCALL (rv = truncate (SCM_STRING_CHARS (object), c_length));
}
if (rv == -1)
SCM_SYSERROR;
SCM_DEFINE (scm_port_line, "port-line", 1, 0, 0,
(SCM port),
- "Return the current line number for PORT.")
+ "Return the current line number for @var{port}.")
#define FUNC_NAME s_scm_port_line
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
+ SCM_VALIDATE_OPENPORT (1, port);
return SCM_MAKINUM (SCM_LINUM (port));
}
#undef FUNC_NAME
SCM_DEFINE (scm_set_port_line_x, "set-port-line!", 2, 0, 0,
(SCM port, SCM line),
- "Set the current line number for PORT to LINE.")
+ "Set the current line number for @var{port} to @var{line}.")
#define FUNC_NAME s_scm_set_port_line_x
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
- SCM_VALIDATE_INUM (2,line);
+ SCM_VALIDATE_OPENPORT (1, port);
+ SCM_VALIDATE_INUM (2, line);
SCM_PTAB_ENTRY (port)->line_number = SCM_INUM (line);
return SCM_UNSPECIFIED;
}
SCM_DEFINE (scm_port_column, "port-column", 1, 0, 0,
(SCM port),
- "@deffnx primitive port-line [input-port]\n"
- "Return the current column number or line number of @var{input-port},\n"
+ "@deffnx {Scheme Procedure} port-line port\n"
+ "Return the current column number or line number of @var{port},\n"
"using the current input port if none is specified. If the number is\n"
"unknown, the result is #f. Otherwise, the result is a 0-origin integer\n"
"- i.e. the first character of the first line is line 0, column 0.\n"
"(However, when you display a file position, for example in an error\n"
- "message, we recommand you add 1 to get 1-origin integers. This is\n"
+ "message, we recommend you add 1 to get 1-origin integers. This is\n"
"because lines and column numbers traditionally start with 1, and that is\n"
"what non-programmers will find most natural.)")
#define FUNC_NAME s_scm_port_column
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
+ SCM_VALIDATE_OPENPORT (1, port);
return SCM_MAKINUM (SCM_COL (port));
}
#undef FUNC_NAME
SCM_DEFINE (scm_set_port_column_x, "set-port-column!", 2, 0, 0,
(SCM port, SCM column),
- "@deffnx primitive set-port-column! [input-port] column\n"
- "Set the current column or line number of @var{input-port}, using the\n"
+ "@deffnx {Scheme Procedure} set-port-line! port line\n"
+ "Set the current column or line number of @var{port}, using the\n"
"current input port if none is specified.")
#define FUNC_NAME s_scm_set_port_column_x
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
- SCM_VALIDATE_INUM (2,column);
+ SCM_VALIDATE_OPENPORT (1, port);
+ SCM_VALIDATE_INUM (2, column);
SCM_PTAB_ENTRY (port)->column_number = SCM_INUM (column);
return SCM_UNSPECIFIED;
}
#define FUNC_NAME s_scm_port_filename
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
- return SCM_PTAB_ENTRY (port)->file_name;
+ SCM_VALIDATE_OPENPORT (1, port);
+ return SCM_FILENAME (port);
}
#undef FUNC_NAME
#define FUNC_NAME s_scm_set_port_filename_x
{
port = SCM_COERCE_OUTPORT (port);
- SCM_VALIDATE_OPENPORT (1,port);
+ SCM_VALIDATE_OPENPORT (1, port);
/* We allow the user to set the filename to whatever he likes. */
- return SCM_PTAB_ENTRY (port)->file_name = filename;
+ SCM_SET_FILENAME (port, filename);
+ return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
}
int
-scm_port_print (SCM exp, SCM port, scm_print_state *pstate)
+scm_port_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)
{
char *type = SCM_PTOBNAME (SCM_PTOBNUM (exp));
if (!type)
return 1;
}
-extern void scm_make_fptob ();
-extern void scm_make_stptob ();
-extern void scm_make_sfptob ();
-
void
scm_ports_prehistory ()
{
scm_numptob = 0;
- scm_ptobs = (scm_ptob_descriptor *) malloc (sizeof (scm_ptob_descriptor));
-
- /* WARNING: These scm_newptob calls must be done in this order.
- * They must agree with the port declarations in tags.h.
- */
- /* scm_tc16_fport = */ scm_make_fptob ();
- /* scm_tc16_pipe was here */ scm_make_fptob (); /* dummy. */
- /* scm_tc16_strport = */ scm_make_stptob ();
- /* scm_tc16_sfport = */ scm_make_sfptob ();
+ scm_ptobs = (scm_t_ptob_descriptor *) scm_malloc (sizeof (scm_t_ptob_descriptor));
}
\f
/* Void ports. */
-long scm_tc16_void_port = 0;
+scm_t_bits scm_tc16_void_port = 0;
-static int fill_input_void_port (SCM port)
+static int fill_input_void_port (SCM port SCM_UNUSED)
{
return EOF;
}
static void
-write_void_port (SCM port, const void *data, size_t size)
+write_void_port (SCM port SCM_UNUSED,
+ const void *data SCM_UNUSED,
+ size_t size SCM_UNUSED)
{
}
SCM
scm_void_port (char *mode_str)
{
- int mode_bits;
- SCM answer;
- scm_port * pt;
+ scm_mutex_lock (&scm_i_port_table_mutex);
+ {
+ int mode_bits = scm_mode_bits (mode_str);
+ SCM answer = scm_new_port_table_entry (scm_tc16_void_port);
+ scm_t_port * pt = SCM_PTAB_ENTRY(answer);
- SCM_NEWCELL (answer);
- SCM_DEFER_INTS;
- mode_bits = scm_mode_bits (mode_str);
- pt = scm_add_to_port_table (answer);
- scm_port_non_buffer (pt);
- SCM_SETPTAB_ENTRY (answer, pt);
- SCM_SETSTREAM (answer, 0);
- SCM_SET_CELL_TYPE (answer, scm_tc16_void_port | mode_bits);
- SCM_ALLOW_INTS;
- return answer;
+ scm_port_non_buffer (pt);
+
+ SCM_SETSTREAM (answer, 0);
+ SCM_SET_CELL_TYPE (answer, scm_tc16_void_port | mode_bits);
+ scm_mutex_unlock (&scm_i_port_table_mutex);
+ return answer;
+ }
}
SCM_DEFINE (scm_sys_make_void_port, "%make-void-port", 1, 0, 0,
(SCM mode),
"Create and return a new void port. A void port acts like\n"
- "/dev/null. The @var{mode} argument\n"
+ "@file{/dev/null}. The @var{mode} argument\n"
"specifies the input/output modes for this port: see the\n"
"documentation for @code{open-file} in @ref{File Ports}.")
#define FUNC_NAME s_scm_sys_make_void_port
{
- SCM_VALIDATE_ROSTRING (1,mode);
- SCM_COERCE_SUBSTR (mode);
- return scm_void_port (SCM_ROCHARS (mode));
+ SCM_VALIDATE_STRING (1, mode);
+ return scm_void_port (SCM_STRING_CHARS (mode));
}
#undef FUNC_NAME
scm_init_ports ()
{
/* lseek() symbols. */
- scm_sysintern ("SEEK_SET", SCM_MAKINUM (SEEK_SET));
- scm_sysintern ("SEEK_CUR", SCM_MAKINUM (SEEK_CUR));
- scm_sysintern ("SEEK_END", SCM_MAKINUM (SEEK_END));
+ scm_c_define ("SEEK_SET", SCM_MAKINUM (SEEK_SET));
+ scm_c_define ("SEEK_CUR", SCM_MAKINUM (SEEK_CUR));
+ scm_c_define ("SEEK_END", SCM_MAKINUM (SEEK_END));
scm_tc16_void_port = scm_make_port_type ("void", fill_input_void_port,
write_void_port);
HCoop / bpt / guile.git / blobdiff