mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-17 17:20:29 +02:00
Code Activity

1999-08-11 Gary Houston <ghouston@easynet.co.uk>

Browse source 
* fports.c (fport_input_waiting): if select is used, return 1
	instead of whatever FD_ISSET expands to.  maybe it will be useful
	to interpret the value from the input_waiting ptob procedure as a
	lower bound on the number of bytes available.

	* Mikael asked for a few names to be changed...

	* ports.c (scm_make_port_type): take the write procedure as the
	second argument instead of the flush procedure.
	* ports.h (scm_ptob_descriptor): rename the ptob procedures:
	fflush -> flush,  read_flush -> end_input,  fclose -> close,
	fill_buffer -> fill_input,  ftruncate -> truncate,
	input_waiting_p -> input_waiting.

	* ports.c (end_input_void_port): was read_flush_void_port.
	(scm_set_port_end_input): was scm_set_port_flush_input.
	(scm_set_port_flush): was scm_set_port_write.
	(scm_set_port_input_waiting): was scm_set_port_input_waiting_p
	(scm_end_input): was scm_read_flush.
	(scm_fill_input): was scm_fill_buffer.
	(scm_flush): was scm_fflush.
	* fports.c (fport_input_waiting): renamed from fport_input_waiting_p.
	(fport_end_input): was local_read_flush.
	(fport_flush): was local_fflush.
	(fport_close): was local_fclose.
	(fport_truncate): was local_ftruncate.
	(fport_seek): was local_seek.
	(fport_free): was local_free.
	(fport_fill_input): was fport_fill_buffer.
	* strports.c (st_end_input): was st_read_flush.
	(st_truncate): was st_ftruncate.
	* vports.c: (sf_flush): was sfflush.
	(sf_close): was sfclose.
	(sf_fill_input): was sf_fill_buffer.

	* ports.c, fports.c, strports, vports.c, ioext.c, unif.c, filesys.c:
	change callers.
This commit is contained in:
Gary Houston 1999-08-11 18:35:42 +00:00
parent df061ffca7
commit affc96b533
9 changed files with 165 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

40
libguile/ChangeLog
View file

@ -1,3 +1,43 @@
1999-08-11 Gary Houston <ghouston@easynet.co.uk>
* fports.c (fport_input_waiting): if select is used, return 1
instead of whatever FD_ISSET expands to. maybe it will be useful
to interpret the value from the input_waiting ptob procedure as a
lower bound on the number of bytes available.
* Mikael asked for a few names to be changed...
* ports.c (scm_make_port_type): take the write procedure as the
second argument instead of the flush procedure.
* ports.h (scm_ptob_descriptor): rename the ptob procedures:
fflush -> flush, read_flush -> end_input, fclose -> close,
fill_buffer -> fill_input, ftruncate -> truncate,
input_waiting_p -> input_waiting.
* ports.c (end_input_void_port): was read_flush_void_port.
(scm_set_port_end_input): was scm_set_port_flush_input.
(scm_set_port_flush): was scm_set_port_write.
(scm_set_port_input_waiting): was scm_set_port_input_waiting_p
(scm_end_input): was scm_read_flush.
(scm_fill_input): was scm_fill_buffer.
(scm_flush): was scm_fflush.
* fports.c (fport_input_waiting): renamed from fport_input_waiting_p.
(fport_end_input): was local_read_flush.
(fport_flush): was local_fflush.
(fport_close): was local_fclose.
(fport_truncate): was local_ftruncate.
(fport_seek): was local_seek.
(fport_free): was local_free.
(fport_fill_input): was fport_fill_buffer.
* strports.c (st_end_input): was st_read_flush.
(st_truncate): was st_ftruncate.
* vports.c: (sf_flush): was sfflush.
(sf_close): was sfclose.
(sf_fill_input): was sf_fill_buffer.
* ports.c, fports.c, strports, vports.c, ioext.c, unif.c, filesys.c:
change callers.
1999-08-06 Mikael Djurfeldt <mdj@thalamus.nada.kth.se> 1999-08-06 Mikael Djurfeldt <mdj@thalamus.nada.kth.se>
* eval.c (SCM_IM_DISPATCH): Rewrote dispatch protocol. Dispatch * eval.c (SCM_IM_DISPATCH): Rewrote dispatch protocol. Dispatch

2
libguile/filesys.c
View file

@ -956,7 +956,7 @@ scm_fsync (SCM object)
if (SCM_NIMP (object) && SCM_OPFPORTP (object)) if (SCM_NIMP (object) && SCM_OPFPORTP (object))
{ {
scm_fflush (object); scm_flush (object);
fdes = SCM_FPORT_FDES (object); fdes = SCM_FPORT_FDES (object);
} }
else else

62
libguile/fports.c
View file

@ -311,9 +311,9 @@ scm_fdes_to_port (int fdes, char *mode, SCM name)
} }
/* Check whether an fport's fdes can supply input. */ /* Return a lower bound on the number of bytes available for input. */
static int static int
fport_input_waiting_p (SCM port) fport_input_waiting (SCM port)
{ {
int fdes = SCM_FSTREAM (port)->fdes; int fdes = SCM_FSTREAM (port)->fdes;
@ -335,14 +335,14 @@ fport_input_waiting_p (SCM port)
if (select (SELECT_SET_SIZE, if (select (SELECT_SET_SIZE,
&read_set, &write_set, &except_set, &timeout) &read_set, &write_set, &except_set, &timeout)
< 0) < 0)
scm_syserror ("fport_input_waiting_p"); scm_syserror ("fport_input_waiting");
return FD_ISSET (fdes, &read_set); return FD_ISSET (fdes, &read_set) ? 1 : 0;
#elif defined (FIONREAD) #elif defined (FIONREAD)
int remir; int remir;
ioctl(fdes, FIONREAD, &remir); ioctl(fdes, FIONREAD, &remir);
return remir; return remir;
#else #else
scm_misc_error ("fport_input_waiting_p", scm_misc_error ("fport_input_waiting",
"Not fully implemented on this platform", "Not fully implemented on this platform",
SCM_EOL); SCM_EOL);
#endif #endif
@ -392,7 +392,7 @@ fport_wait_for_input (SCM port)
{ {
int fdes = SCM_FSTREAM (port)->fdes; int fdes = SCM_FSTREAM (port)->fdes;
if (!fport_input_waiting_p (port)) if (!fport_input_waiting (port))
{ {
int n; int n;
SELECT_TYPE readfds; SELECT_TYPE readfds;
@ -412,13 +412,13 @@ fport_wait_for_input (SCM port)
} }
#endif #endif
static void local_fflush (SCM port); static void fport_flush (SCM port);
/* fill a port's read-buffer with a single read. /* fill a port's read-buffer with a single read.
returns the first char and moves the read_pos pointer past it. returns the first char and moves the read_pos pointer past it.
or returns EOF if end of file. */ or returns EOF if end of file. */
static int static int
fport_fill_buffer (SCM port) fport_fill_input (SCM port)
{ {
int count; int count;
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -429,7 +429,7 @@ fport_fill_buffer (SCM port)
#endif #endif
SCM_SYSCALL (count = read (fp->fdes, pt->read_buf, pt->read_buf_size)); SCM_SYSCALL (count = read (fp->fdes, pt->read_buf, pt->read_buf_size));
if (count == -1) if (count == -1)
scm_syserror ("fport_fill_buffer"); scm_syserror ("fport_fill_input");
if (count == 0) if (count == 0)
return EOF; return EOF;
else else
@ -441,18 +441,18 @@ fport_fill_buffer (SCM port)
} }
static off_t static off_t
local_seek (SCM port, off_t offset, int whence) fport_seek (SCM port, off_t offset, int whence)
{ {
struct scm_fport *fp = SCM_FSTREAM (port); struct scm_fport *fp = SCM_FSTREAM (port);
off_t result = lseek (fp->fdes, offset, whence); off_t result = lseek (fp->fdes, offset, whence);
if (result == -1) if (result == -1)
scm_syserror ("local_seek"); scm_syserror ("fport_seek");
return result; return result;
} }
static void static void
local_ftruncate (SCM port, off_t length) fport_truncate (SCM port, off_t length)
{ {
struct scm_fport *fp = SCM_FSTREAM (port); struct scm_fport *fp = SCM_FSTREAM (port);
@ -486,12 +486,12 @@ fport_write (SCM port, void *data, size_t size)
size -= write_len; size -= write_len;
input += write_len; input += write_len;
if (write_len == space) if (write_len == space)
local_fflush (port); fport_flush (port);
} }
/* handle line buffering. */ /* handle line buffering. */
if ((SCM_CAR (port) & SCM_BUFLINE) && memchr (data, '\n', size)) if ((SCM_CAR (port) & SCM_BUFLINE) && memchr (data, '\n', size))
local_fflush (port); fport_flush (port);
} }
} }
@ -500,7 +500,7 @@ fport_write (SCM port, void *data, size_t size)
extern int terminating; extern int terminating;
static void static void
local_fflush (SCM port) fport_flush (SCM port)
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
struct scm_fport *fp = SCM_FSTREAM (port); struct scm_fport *fp = SCM_FSTREAM (port);
@ -530,7 +530,7 @@ local_fflush (SCM port)
pt->write_pos = pt->write_buf + remaining; pt->write_pos = pt->write_buf + remaining;
} }
if (!terminating) if (!terminating)
scm_syserror ("local_fflush"); scm_syserror ("fport_flush");
else else
{ {
const char *msg = "Error: could not flush file-descriptor "; const char *msg = "Error: could not flush file-descriptor ";
@ -552,7 +552,7 @@ local_fflush (SCM port)
/* clear the read buffer and adjust the file position for unread bytes. */ /* clear the read buffer and adjust the file position for unread bytes. */
static void static void
local_read_flush (SCM port, int offset) fport_end_input (SCM port, int offset)
{ {
struct scm_fport *fp = SCM_FSTREAM (port); struct scm_fport *fp = SCM_FSTREAM (port);
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -565,22 +565,22 @@ local_read_flush (SCM port, int offset)
/* will throw error if unread-char used at beginning of file /* will throw error if unread-char used at beginning of file
then attempting to write. seems correct. */ then attempting to write. seems correct. */
if (lseek (fp->fdes, -offset, SEEK_CUR) == -1) if (lseek (fp->fdes, -offset, SEEK_CUR) == -1)
scm_syserror ("local_read_flush"); scm_syserror ("fport_end_input");
} }
pt->rw_active = 0; pt->rw_active = 0;
} }
static int static int
local_fclose (SCM port) fport_close (SCM port)
{ {
struct scm_fport *fp = SCM_FSTREAM (port); struct scm_fport *fp = SCM_FSTREAM (port);
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
int rv; int rv;
local_fflush (port); fport_flush (port);
SCM_SYSCALL (rv = close (fp->fdes)); SCM_SYSCALL (rv = close (fp->fdes));
if (rv == -1 && errno != EBADF) if (rv == -1 && errno != EBADF)
scm_syserror ("local_fclose"); scm_syserror ("fport_close");
if (pt->read_buf == pt->putback_buf) if (pt->read_buf == pt->putback_buf)
pt->read_buf = pt->saved_read_buf; pt->read_buf = pt->saved_read_buf;
if (pt->read_buf != &pt->shortbuf) if (pt->read_buf != &pt->shortbuf)
@ -592,9 +592,9 @@ local_fclose (SCM port)
} }
static scm_sizet static scm_sizet
local_free (SCM port) fport_free (SCM port)
{ {
local_fclose (port); fport_close (port);
return 0; return 0;
} }
@ -603,15 +603,15 @@ void scm_make_fptob (void); /* Called from ports.c */
void void
scm_make_fptob () scm_make_fptob ()
{ {
long tc = scm_make_port_type ("file", fport_fill_buffer, local_fflush); long tc = scm_make_port_type ("file", fport_fill_input, fport_write);
scm_set_port_free (tc, local_free); scm_set_port_free (tc, fport_free);
scm_set_port_print (tc, prinfport); scm_set_port_print (tc, prinfport);
scm_set_port_write (tc, fport_write); scm_set_port_flush (tc, fport_flush);
scm_set_port_flush_input (tc, local_read_flush); scm_set_port_end_input (tc, fport_end_input);
scm_set_port_close (tc, local_fclose); scm_set_port_close (tc, fport_close);
scm_set_port_seek (tc, local_seek); scm_set_port_seek (tc, fport_seek);
scm_set_port_truncate (tc, local_ftruncate); scm_set_port_truncate (tc, fport_truncate);
scm_set_port_input_waiting_p (tc, fport_input_waiting_p); scm_set_port_input_waiting (tc, fport_input_waiting);
} }
void void

8
libguile/ioext.c
View file

@ -196,7 +196,7 @@ scm_do_read_line (SCM port, int *len_p)
break; break;
/* Get more characters. */ /* Get more characters. */
if (scm_fill_buffer (port) == EOF) if (scm_fill_input (port) == EOF)
{ {
/* If we're missing a final newline in the file, return /* If we're missing a final newline in the file, return
what we did get, sans newline. */ what we did get, sans newline. */
@ -252,7 +252,7 @@ scm_read_line (port)
pt = SCM_PTAB_ENTRY (port); pt = SCM_PTAB_ENTRY (port);
if (pt->rw_active == SCM_PORT_WRITE) if (pt->rw_active == SCM_PORT_WRITE)
scm_ptobs[SCM_PTOBNUM (port)].fflush (port); scm_ptobs[SCM_PTOBNUM (port)].flush (port);
s = scm_do_read_line (port, &slen); s = scm_do_read_line (port, &slen);
@ -341,9 +341,9 @@ scm_redirect_port (old, new)
/* must flush to old fdes. */ /* must flush to old fdes. */
if (pt->rw_active == SCM_PORT_WRITE) if (pt->rw_active == SCM_PORT_WRITE)
ptob->fflush (new); ptob->flush (new);
else if (pt->rw_active == SCM_PORT_READ) else if (pt->rw_active == SCM_PORT_READ)
scm_read_flush (new); scm_end_input (new);
ans = dup2 (oldfd, newfd); ans = dup2 (oldfd, newfd);
if (ans == -1) if (ans == -1)
scm_syserror (s_redirect_port); scm_syserror (s_redirect_port);

109
libguile/ports.c
View file

@ -89,32 +89,19 @@ scm_markstream (ptr)
} }
/* /*
* This is how different port types currently use ptob fields.
*
* fports: free, flush, read_flush, close,
* fill_buffer, seek, truncate, input_waiting_p
*
* strports: mark, flush, read_flush,
* fill_buffer, seek, truncate
*
* softports: mark, flush, read_flush, close,
* fill_buffer
*
* voidports: (default values)
*
* We choose to use an interface similar to the smob interface with * We choose to use an interface similar to the smob interface with
* fill_buffer and write_flush as standard fields, passed to the port * fill_input and write as standard fields, passed to the port
* type constructor, and optional fields set by setters. * type constructor, and optional fields set by setters.
*/ */
static void flush_void_port (SCM port); static void flush_void_port (SCM port);
static void read_flush_void_port (SCM port, int offset); static void end_input_void_port (SCM port, int offset);
static void write_void_port (SCM port, void *data, size_t size); static void write_void_port (SCM port, void *data, size_t size);
long long
scm_make_port_type (char *name, scm_make_port_type (char *name,
int (*fill_buffer) (SCM port), int (*fill_input) (SCM port),
void (*write_flush) (SCM port)) void (*write) (SCM port, void *data, size_t size))
{ {
char *tmp; char *tmp;
if (255 <= scm_numptob) if (255 <= scm_numptob)
@ -126,21 +113,24 @@ scm_make_port_type (char *name,
if (tmp) if (tmp)
{ {
scm_ptobs = (scm_ptob_descriptor *) tmp; scm_ptobs = (scm_ptob_descriptor *) tmp;
scm_ptobs[scm_numptob].name = name; scm_ptobs[scm_numptob].name = name;
scm_ptobs[scm_numptob].mark = 0; scm_ptobs[scm_numptob].mark = 0;
scm_ptobs[scm_numptob].free = scm_free0; scm_ptobs[scm_numptob].free = scm_free0;
scm_ptobs[scm_numptob].print = scm_port_print; scm_ptobs[scm_numptob].print = scm_port_print;
scm_ptobs[scm_numptob].equalp = 0; scm_ptobs[scm_numptob].equalp = 0;
scm_ptobs[scm_numptob].write = write_void_port; scm_ptobs[scm_numptob].close = 0;
scm_ptobs[scm_numptob].fflush = (write_flush
? write_flush scm_ptobs[scm_numptob].write = write;
: flush_void_port); scm_ptobs[scm_numptob].flush = flush_void_port;
scm_ptobs[scm_numptob].read_flush = read_flush_void_port;
scm_ptobs[scm_numptob].fclose = 0; scm_ptobs[scm_numptob].end_input = end_input_void_port;
scm_ptobs[scm_numptob].fill_buffer = fill_buffer; scm_ptobs[scm_numptob].fill_input = fill_input;
scm_ptobs[scm_numptob].input_waiting = 0;
scm_ptobs[scm_numptob].seek = 0; scm_ptobs[scm_numptob].seek = 0;
scm_ptobs[scm_numptob].ftruncate = 0; scm_ptobs[scm_numptob].truncate = 0;
scm_ptobs[scm_numptob].input_waiting_p = 0;
scm_numptob++; scm_numptob++;
} }
SCM_ALLOW_INTS; SCM_ALLOW_INTS;
@ -179,22 +169,21 @@ scm_set_port_equalp (long tc, SCM (*equalp) (SCM, SCM))
} }
void void
scm_set_port_write (long tc, void (*write_proc) (SCM port, void *data, scm_set_port_flush (long tc, void (*flush) (SCM port))
size_t size))
{ {
scm_ptobs[SCM_TC2PTOBNUM (tc)].write = write_proc; scm_ptobs[SCM_TC2PTOBNUM (tc)].flush = flush;
} }
void void
scm_set_port_flush_input (long tc, void (*flush_input) (SCM port, int offset)) scm_set_port_end_input (long tc, void (*end_input) (SCM port, int offset))
{ {
scm_ptobs[SCM_TC2PTOBNUM (tc)].read_flush = flush_input; scm_ptobs[SCM_TC2PTOBNUM (tc)].end_input = end_input;
} }
void void
scm_set_port_close (long tc, int (*close) (SCM)) scm_set_port_close (long tc, int (*close) (SCM))
{ {
scm_ptobs[SCM_TC2PTOBNUM (tc)].fclose = close; scm_ptobs[SCM_TC2PTOBNUM (tc)].close = close;
} }
void void
@ -208,13 +197,13 @@ scm_set_port_seek (long tc, off_t (*seek) (SCM port,
void void
scm_set_port_truncate (long tc, void (*truncate) (SCM port, off_t length)) scm_set_port_truncate (long tc, void (*truncate) (SCM port, off_t length))
{ {
scm_ptobs[SCM_TC2PTOBNUM (tc)].ftruncate = truncate; scm_ptobs[SCM_TC2PTOBNUM (tc)].truncate = truncate;
} }
void void
scm_set_port_input_waiting_p (long tc, int (*waitingp) (SCM)) scm_set_port_input_waiting (long tc, int (*input_waiting) (SCM))
{ {
scm_ptobs[SCM_TC2PTOBNUM (tc)].input_waiting_p = waitingp; scm_ptobs[SCM_TC2PTOBNUM (tc)].input_waiting = input_waiting;
} }
@ -246,8 +235,8 @@ scm_char_ready_p (port)
{ {
scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)]; scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
if (ptob->input_waiting_p) if (ptob->input_waiting)
return (ptob->input_waiting_p (port)) ? SCM_BOOL_T : SCM_BOOL_F; return (ptob->input_waiting (port)) ? SCM_BOOL_T : SCM_BOOL_F;
else else
return SCM_BOOL_T; return SCM_BOOL_T;
} }
@ -580,8 +569,8 @@ scm_close_port (port)
if (SCM_CLOSEDP (port)) if (SCM_CLOSEDP (port))
return SCM_BOOL_F; return SCM_BOOL_F;
i = SCM_PTOBNUM (port); i = SCM_PTOBNUM (port);
if (scm_ptobs[i].fclose) if (scm_ptobs[i].close)
rv = (scm_ptobs[i].fclose) (port); rv = (scm_ptobs[i].close) (port);
else else
rv = 0; rv = 0;
scm_remove_from_port_table (port); scm_remove_from_port_table (port);
@ -671,7 +660,7 @@ scm_force_output (port)
SCM_ASSERT (SCM_NIMP (port) && SCM_OPOUTPORTP (port), port, SCM_ARG1, SCM_ASSERT (SCM_NIMP (port) && SCM_OPOUTPORTP (port), port, SCM_ARG1,
s_force_output); s_force_output);
} }
scm_fflush (port); scm_flush (port);
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
} }
@ -684,7 +673,7 @@ scm_flush_all_ports (void)
for (i = 0; i < scm_port_table_size; i++) for (i = 0; i < scm_port_table_size; i++)
{ {
if (SCM_OPOUTPORTP (scm_port_table[i]->port)) if (SCM_OPOUTPORTP (scm_port_table[i]->port))
scm_fflush (scm_port_table[i]->port); scm_flush (scm_port_table[i]->port);
} }
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
} }
@ -707,10 +696,10 @@ scm_read_char (port)
} }
/* this should only be called when the read buffer is empty. it /* this should only be called when the read buffer is empty. it
tries to refill the buffer. it returns the first char from tries to refill the read buffer. it returns the first char from
the port, which is either EOF or *(pt->read_pos). */ the port, which is either EOF or *(pt->read_pos). */
int int
scm_fill_buffer (SCM port) scm_fill_input (SCM port)
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -724,7 +713,7 @@ scm_fill_buffer (SCM port)
if (pt->read_pos < pt->read_end) if (pt->read_pos < pt->read_end)
return *(pt->read_pos); return *(pt->read_pos);
} }
return scm_ptobs[SCM_PTOBNUM (port)].fill_buffer (port); return scm_ptobs[SCM_PTOBNUM (port)].fill_input (port);
} }
int int
@ -736,8 +725,8 @@ scm_getc (port)
if (pt->rw_active == SCM_PORT_WRITE) if (pt->rw_active == SCM_PORT_WRITE)
{ {
/* may be marginally faster than calling scm_fflush. */ /* may be marginally faster than calling scm_flush. */
scm_ptobs[SCM_PTOBNUM (port)].fflush (port); scm_ptobs[SCM_PTOBNUM (port)].flush (port);
} }
if (pt->rw_random) if (pt->rw_random)
@ -745,7 +734,7 @@ scm_getc (port)
if (pt->read_pos >= pt->read_end) if (pt->read_pos >= pt->read_end)
{ {
if (scm_fill_buffer (port) == EOF) if (scm_fill_input (port) == EOF)
return EOF; return EOF;
} }
@ -793,7 +782,7 @@ scm_lfwrite (ptr, size, port)
scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)]; scm_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)];
if (pt->rw_active == SCM_PORT_READ) if (pt->rw_active == SCM_PORT_READ)
scm_read_flush (port); scm_end_input (port);
ptob->write (port, ptr, size); ptob->write (port, ptr, size);
@ -803,15 +792,15 @@ scm_lfwrite (ptr, size, port)
void void
scm_fflush (port) scm_flush (port)
SCM port; SCM port;
{ {
scm_sizet i = SCM_PTOBNUM (port); scm_sizet i = SCM_PTOBNUM (port);
(scm_ptobs[i].fflush) (port); (scm_ptobs[i].flush) (port);
} }
void void
scm_read_flush (port) scm_end_input (port)
SCM port; SCM port;
{ {
int offset; int offset;
@ -828,7 +817,7 @@ scm_read_flush (port)
else else
offset = 0; offset = 0;
scm_ptobs[SCM_PTOBNUM (port)].read_flush (port, offset); scm_ptobs[SCM_PTOBNUM (port)].end_input (port, offset);
} }
@ -1015,9 +1004,9 @@ scm_lseek (SCM object, SCM offset, SCM whence)
else else
{ {
if (pt->rw_active == SCM_PORT_READ) if (pt->rw_active == SCM_PORT_READ)
scm_read_flush (object); scm_end_input (object);
else if (pt->rw_active == SCM_PORT_WRITE) else if (pt->rw_active == SCM_PORT_WRITE)
ptob->fflush (object); ptob->flush (object);
rv = ptob->seek (object, off, how); rv = ptob->seek (object, off, how);
} }
@ -1064,14 +1053,14 @@ scm_truncate_file (SCM object, SCM length)
scm_port *pt = SCM_PTAB_ENTRY (object); scm_port *pt = SCM_PTAB_ENTRY (object);
scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object); scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
if (!ptob->ftruncate) if (!ptob->truncate)
scm_misc_error (s_truncate_file, "port is not truncatable", SCM_EOL); scm_misc_error (s_truncate_file, "port is not truncatable", SCM_EOL);
if (pt->rw_active == SCM_PORT_READ) if (pt->rw_active == SCM_PORT_READ)
scm_read_flush (object); scm_end_input (object);
else if (pt->rw_active == SCM_PORT_WRITE) else if (pt->rw_active == SCM_PORT_WRITE)
ptob->fflush (object); ptob->flush (object);
ptob->ftruncate (object, c_length); ptob->truncate (object, c_length);
rv = 0; rv = 0;
} }
else else
@ -1241,7 +1230,7 @@ flush_void_port (SCM port)
} }
static void static void
read_flush_void_port (SCM port, int offset) end_input_void_port (SCM port, int offset)
{ {
} }
@ -1294,6 +1283,6 @@ scm_init_ports ()
scm_sysintern ("SEEK_CUR", SCM_MAKINUM (SEEK_CUR)); scm_sysintern ("SEEK_CUR", SCM_MAKINUM (SEEK_CUR));
scm_sysintern ("SEEK_END", SCM_MAKINUM (SEEK_END)); scm_sysintern ("SEEK_END", SCM_MAKINUM (SEEK_END));
scm_tc16_void_port = scm_make_port_type ("void", 0, 0); scm_tc16_void_port = scm_make_port_type ("void", 0, write_void_port);
#include "ports.x" #include "ports.x"
} }

43
libguile/ports.h
View file

@ -169,6 +169,7 @@ extern int scm_port_table_size; /* Number of ports in scm_port_table. */
/* port-type description. */
typedef struct scm_ptob_descriptor typedef struct scm_ptob_descriptor
{ {
char *name; char *name;
@ -176,14 +177,18 @@ typedef struct scm_ptob_descriptor
scm_sizet (*free) (SCM); scm_sizet (*free) (SCM);
int (*print) (SCM exp, SCM port, scm_print_state *pstate); int (*print) (SCM exp, SCM port, scm_print_state *pstate);
SCM (*equalp) (SCM, SCM); SCM (*equalp) (SCM, SCM);
int (*close) (SCM port);
void (*write) (SCM port, void *data, size_t size); void (*write) (SCM port, void *data, size_t size);
void (*fflush) (SCM port); void (*flush) (SCM port);
void (*read_flush) (SCM port, int offset);
int (*fclose) (SCM port); void (*end_input) (SCM port, int offset);
int (*fill_buffer) (SCM port); int (*fill_input) (SCM port);
int (*input_waiting) (SCM port);
off_t (*seek) (SCM port, off_t OFFSET, int WHENCE); off_t (*seek) (SCM port, off_t OFFSET, int WHENCE);
void (*ftruncate) (SCM port, off_t length); void (*truncate) (SCM port, off_t length);
int (*input_waiting_p) (SCM port);
} scm_ptob_descriptor; } scm_ptob_descriptor;
#define SCM_TC2PTOBNUM(x) (0x0ff & ((x) >> 8)) #define SCM_TC2PTOBNUM(x) (0x0ff & ((x) >> 8))
@ -201,8 +206,9 @@ extern int scm_port_table_room;
extern SCM scm_markstream SCM_P ((SCM ptr)); extern SCM scm_markstream SCM_P ((SCM ptr));
extern long scm_make_port_type (char *name, extern long scm_make_port_type (char *name,
int (*fill_buffer) (SCM port), int (*fill_input) (SCM port),
void (*write_flush) (SCM port)); void (*write) (SCM port, void *data,
size_t size));
extern void scm_set_port_mark (long tc, SCM (*mark) (SCM)); extern void scm_set_port_mark (long tc, SCM (*mark) (SCM));
extern void scm_set_port_free (long tc, scm_sizet (*free) (SCM)); extern void scm_set_port_free (long tc, scm_sizet (*free) (SCM));
extern void scm_set_port_print (long tc, extern void scm_set_port_print (long tc,
@ -210,14 +216,13 @@ extern void scm_set_port_print (long tc,
SCM port, SCM port,
scm_print_state *pstate)); scm_print_state *pstate));
extern void scm_set_port_equalp (long tc, SCM (*equalp) (SCM, SCM)); extern void scm_set_port_equalp (long tc, SCM (*equalp) (SCM, SCM));
extern void scm_set_port_write (long tc,
void (*write_proc) (SCM port,
void *data,
size_t size));
extern void scm_set_port_flush_input (long tc,
void (*flush_input) (SCM port,
int offset));
extern void scm_set_port_close (long tc, int (*close) (SCM)); extern void scm_set_port_close (long tc, int (*close) (SCM));
extern void scm_set_port_flush (long tc,
void (*flush) (SCM port));
extern void scm_set_port_end_input (long tc,
void (*end_input) (SCM port,
int offset));
extern void scm_set_port_seek (long tc, extern void scm_set_port_seek (long tc,
off_t (*seek) (SCM port, off_t (*seek) (SCM port,
off_t OFFSET, off_t OFFSET,
@ -225,7 +230,7 @@ extern void scm_set_port_seek (long tc,
extern void scm_set_port_truncate (long tc, extern void scm_set_port_truncate (long tc,
void (*truncate) (SCM port, void (*truncate) (SCM port,
off_t length)); off_t length));
extern void scm_set_port_input_waiting_p (long tc, int (*waitingp) (SCM)); extern void scm_set_port_input_waiting (long tc, int (*input_waiting) (SCM));
extern SCM scm_char_ready_p SCM_P ((SCM port)); extern SCM scm_char_ready_p SCM_P ((SCM port));
extern SCM scm_drain_input (SCM port); extern SCM scm_drain_input (SCM port);
extern SCM scm_current_input_port SCM_P ((void)); extern SCM scm_current_input_port SCM_P ((void));
@ -256,9 +261,9 @@ extern SCM scm_read_char SCM_P ((SCM port));
extern void scm_putc SCM_P ((char c, SCM port)); extern void scm_putc SCM_P ((char c, SCM port));
extern void scm_puts SCM_P ((char *str_data, SCM port)); extern void scm_puts SCM_P ((char *str_data, SCM port));
extern void scm_lfwrite SCM_P ((char *ptr, scm_sizet size, SCM port)); extern void scm_lfwrite SCM_P ((char *ptr, scm_sizet size, SCM port));
extern void scm_fflush SCM_P ((SCM port)); extern void scm_flush SCM_P ((SCM port));
extern void scm_read_flush (SCM port); extern void scm_end_input (SCM port);
extern int scm_fill_buffer (SCM port); extern int scm_fill_input (SCM port);
extern int scm_getc SCM_P ((SCM port)); extern int scm_getc SCM_P ((SCM port));
extern void scm_ungetc SCM_P ((int c, SCM port)); extern void scm_ungetc SCM_P ((int c, SCM port));
extern void scm_ungets SCM_P ((char *s, int n, SCM port)); extern void scm_ungets SCM_P ((char *s, int n, SCM port));

12
libguile/strports.c
View file

@ -141,7 +141,7 @@ st_write (SCM port, void *data, size_t size)
} }
static void static void
st_read_flush (SCM port, int offset) st_end_input (SCM port, int offset)
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -197,7 +197,7 @@ st_seek (SCM port, off_t offset, int whence)
} }
static void static void
st_ftruncate (SCM port, off_t length) st_truncate (SCM port, off_t length)
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -376,12 +376,12 @@ void scm_make_stptob (void); /* Called from ports.c */
void void
scm_make_stptob () scm_make_stptob ()
{ {
long tc = scm_make_port_type ("string", stfill_buffer, st_flush); long tc = scm_make_port_type ("string", stfill_buffer, st_write);
scm_set_port_mark (tc, scm_markstream); scm_set_port_mark (tc, scm_markstream);
scm_set_port_flush_input (tc, st_read_flush); scm_set_port_end_input (tc, st_end_input);
scm_set_port_write (tc, st_write); scm_set_port_flush (tc, st_flush);
scm_set_port_seek (tc, st_seek); scm_set_port_seek (tc, st_seek);
scm_set_port_truncate (tc, st_ftruncate); scm_set_port_truncate (tc, st_truncate);
} }
void void

4
libguile/unif.c
View file

@ -1547,7 +1547,7 @@ loop:
char *dest = SCM_CHARS (v) + (cstart + offset) * sz; char *dest = SCM_CHARS (v) + (cstart + offset) * sz;
if (pt->rw_active == SCM_PORT_WRITE) if (pt->rw_active == SCM_PORT_WRITE)
scm_fflush (port_or_fd); scm_flush (port_or_fd);
ans = cend - offset; ans = cend - offset;
while (remaining > 0) while (remaining > 0)
@ -1564,7 +1564,7 @@ loop:
} }
else else
{ {
if (scm_fill_buffer (port_or_fd) == EOF) if (scm_fill_input (port_or_fd) == EOF)
{ {
if (remaining % sz != 0) if (remaining % sz != 0)
{ {

16
libguile/vports.c
View file

@ -60,7 +60,7 @@
static void static void
sfflush (SCM port) sf_flush (SCM port)
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
SCM stream = pt->stream; SCM stream = pt->stream;
@ -96,9 +96,9 @@ sf_write (SCM port, void *data, size_t size)
but perhaps softports could the use port buffer in the same way as but perhaps softports could the use port buffer in the same way as
fports. */ fports. */
/* returns a single character. */ /* places a single char in the input buffer. */
static int static int
sf_fill_buffer (SCM port) sf_fill_input (SCM port)
{ {
SCM p = SCM_STREAM (port); SCM p = SCM_STREAM (port);
SCM ans; SCM ans;
@ -106,7 +106,7 @@ sf_fill_buffer (SCM port)
ans = scm_apply (SCM_VELTS (p)[3], SCM_EOL, SCM_EOL); /* get char. */ ans = scm_apply (SCM_VELTS (p)[3], SCM_EOL, SCM_EOL); /* get char. */
if (SCM_FALSEP (ans) || SCM_EOF_OBJECT_P (ans)) if (SCM_FALSEP (ans) || SCM_EOF_OBJECT_P (ans))
return EOF; return EOF;
SCM_ASSERT (SCM_ICHRP (ans), ans, SCM_ARG1, "sf_fill_buffer"); SCM_ASSERT (SCM_ICHRP (ans), ans, SCM_ARG1, "sf_fill_input");
{ {
scm_port *pt = SCM_PTAB_ENTRY (port); scm_port *pt = SCM_PTAB_ENTRY (port);
@ -119,7 +119,7 @@ sf_fill_buffer (SCM port)
static int static int
sfclose (SCM port) sf_close (SCM port)
{ {
SCM p = SCM_STREAM (port); SCM p = SCM_STREAM (port);
SCM f = SCM_VELTS (p)[4]; SCM f = SCM_VELTS (p)[4];
@ -165,10 +165,10 @@ void scm_make_sfptob (void); /* Called from ports.c */
void void
scm_make_sfptob () scm_make_sfptob ()
{ {
long tc = scm_make_port_type ("soft", sf_fill_buffer, sfflush); long tc = scm_make_port_type ("soft", sf_fill_input, sf_write);
scm_set_port_mark (tc, scm_markstream); scm_set_port_mark (tc, scm_markstream);
scm_set_port_write (tc, sf_write); scm_set_port_flush (tc, sf_flush);
scm_set_port_close (tc, sfclose); scm_set_port_close (tc, sf_close);
} }
void void