X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/8dc9439fc660ef7914d63fd8c1fc58092b5f6fa5..c9d15b05833feccf1cbc644ab534b9beeaa5b744:/libguile/fports.c diff --git a/libguile/fports.c b/libguile/fports.c index 69bf89603..5e4e6df69 100644 --- a/libguile/fports.c +++ b/libguile/fports.c @@ -1,48 +1,27 @@ -/* Copyright (C) 1995,1996,1997,1998,1999, 2000 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ -/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999, - gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */ +#define _LARGEFILE64_SOURCE /* ask for stat64 etc */ + +#ifdef HAVE_CONFIG_H +# include +#endif #include #include @@ -50,6 +29,9 @@ #include "libguile/strings.h" #include "libguile/validate.h" #include "libguile/gc.h" +#include "libguile/posix.h" +#include "libguile/dynwind.h" +#include "libguile/hashtab.h" #include "libguile/fports.h" @@ -58,34 +40,71 @@ #endif #ifdef HAVE_UNISTD_H #include -#else -scm_sizet fwrite (); #endif -#ifdef HAVE_ST_BLKSIZE +#ifdef HAVE_IO_H +#include +#endif +#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE #include #endif #include +#include #include "libguile/iselect.h" +/* Some defines for Windows (native port, not Cygwin). */ +#ifdef __MINGW32__ +# include +# include +#endif /* __MINGW32__ */ + +/* Mingw (version 3.4.5, circa 2006) has ftruncate as an alias for chsize + already, but have this code here in case that wasn't so in past versions, + or perhaps to help other minimal DOS environments. + + gnulib ftruncate.c has code using fcntl F_CHSIZE and F_FREESP, which + might be possibilities if we've got other systems without ftruncate. */ + +#if HAVE_CHSIZE && ! HAVE_FTRUNCATE +# define ftruncate(fd, size) chsize (fd, size) +#undef HAVE_FTRUNCATE +#define HAVE_FTRUNCATE 1 +#endif + +#if SIZEOF_OFF_T == SIZEOF_INT +#define OFF_T_MAX INT_MAX +#define OFF_T_MIN INT_MIN +#elif SIZEOF_OFF_T == SIZEOF_LONG +#define OFF_T_MAX LONG_MAX +#define OFF_T_MIN LONG_MIN +#elif SIZEOF_OFF_T == SIZEOF_LONG_LONG +#define OFF_T_MAX LONG_LONG_MAX +#define OFF_T_MIN LONG_LONG_MIN +#else +#error Oops, unknown OFF_T size +#endif + +scm_t_bits scm_tc16_fport; + + /* default buffer size, used if the O/S won't supply a value. */ -static const int default_buffer_size = 1024; +static const size_t default_buffer_size = 1024; /* create FPORT buffer with specified sizes (or -1 to use default size or 0 for no buffer. */ static void -scm_fport_buffer_add (SCM port, int read_size, int write_size) +scm_fport_buffer_add (SCM port, long read_size, int write_size) +#define FUNC_NAME "scm_fport_buffer_add" { - struct scm_fport *fp = SCM_FSTREAM (port); - scm_port *pt = SCM_PTAB_ENTRY (port); - 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); default_size = (fstat (fp->fdes, &st) == -1) ? default_buffer_size : st.st_blksize; @@ -100,9 +119,7 @@ scm_fport_buffer_add (SCM port, int read_size, int write_size) 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_gc_malloc_pointerless (read_size, "port buffer"); pt->read_pos = pt->read_end = pt->read_buf; pt->read_buf_size = read_size; } @@ -114,9 +131,7 @@ scm_fport_buffer_add (SCM port, int read_size, int write_size) 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_gc_malloc_pointerless (write_size, "port buffer"); pt->write_pos = pt->write_buf; pt->write_buf_size = write_size; } @@ -132,6 +147,7 @@ scm_fport_buffer_add (SCM port, int read_size, int write_size) else SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) | SCM_BUF0); } +#undef FUNC_NAME SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, (SCM port, SCM mode, SCM size), @@ -147,13 +163,14 @@ SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, "@end table") #define FUNC_NAME s_scm_setvbuf { - int cmode, csize; - scm_port *pt; + int cmode; + long csize; + scm_t_port *pt; port = SCM_COERCE_OUTPORT (port); SCM_VALIDATE_OPFPORT (1,port); - SCM_VALIDATE_INUM_COPY (2,mode,cmode); + cmode = scm_to_int (mode); if (cmode != _IONBF && cmode != _IOFBF && cmode != _IOLBF) scm_out_of_range (FUNC_NAME, mode); @@ -164,7 +181,7 @@ SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, } else { - SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) ^ SCM_BUFLINE); + SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) & ~(scm_t_bits)SCM_BUFLINE); } if (SCM_UNBNDP (size)) @@ -176,18 +193,25 @@ SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, } else { - SCM_VALIDATE_INUM_COPY (3,size,csize); + csize = scm_to_int (size); if (csize < 0 || (cmode == _IONBF && csize > 0)) scm_out_of_range (FUNC_NAME, size); } pt = SCM_PTAB_ENTRY (port); - /* silently discards buffered chars. */ + /* silently discards buffered and put-back chars. */ + if (pt->read_buf == pt->putback_buf) + { + pt->read_buf = pt->saved_read_buf; + pt->read_pos = pt->saved_read_pos; + pt->read_end = pt->saved_read_end; + pt->read_buf_size = pt->saved_read_buf_size; + } if (pt->read_buf != &pt->shortbuf) - free (pt->read_buf); + scm_gc_free (pt->read_buf, pt->read_buf_size, "port buffer"); if (pt->write_buf != &pt->shortbuf) - free (pt->write_buf); + scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer"); scm_fport_buffer_add (port, csize, csize); return SCM_UNSPECIFIED; @@ -195,33 +219,50 @@ SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, #undef FUNC_NAME /* Move ports with the specified file descriptor to new descriptors, - * reseting the revealed count to 0. + * resetting the revealed count to 0. */ - -void -scm_evict_ports (int fd) +static void +scm_i_evict_port (void *closure, SCM port) { - int i; + int fd = * (int*) closure; - for (i = 0; i < scm_port_table_size; i++) + if (SCM_FPORTP (port)) { - SCM port = scm_port_table[i]->port; + scm_t_port *p; + scm_t_fport *fp; - if (SCM_FPORTP (port)) - { - struct scm_fport *fp = SCM_FSTREAM (port); + /* XXX: In some cases, we can encounter a port with no associated ptab + entry. */ + p = SCM_PTAB_ENTRY (port); + fp = (p != NULL) ? (scm_t_fport *) p->stream : NULL; - if (fp->fdes == fd) - { - fp->fdes = dup (fd); - if (fp->fdes == -1) - scm_syserror ("scm_evict_ports"); - scm_set_port_revealed_x (port, SCM_MAKINUM (0)); - } + if ((fp != NULL) && (fp->fdes == fd)) + { + fp->fdes = dup (fd); + if (fp->fdes == -1) + scm_syserror ("scm_evict_ports"); + scm_set_port_revealed_x (port, scm_from_int (0)); } } } +void +scm_evict_ports (int fd) +{ + scm_c_port_for_each (scm_i_evict_port, (void *) &fd); +} + + +SCM_DEFINE (scm_file_port_p, "file-port?", 1, 0, 0, + (SCM obj), + "Determine whether @var{obj} is a port that is related to a file.") +#define FUNC_NAME s_scm_file_port_p +{ + return scm_from_bool (SCM_FPORTP (obj)); +} +#undef FUNC_NAME + + /* scm_open_file * Return a new port open on a given file. * @@ -231,12 +272,12 @@ scm_evict_ports (int fd) * Return the new port. */ SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0, - (SCM filename, SCM modes), - "Open the file whose name is @var{string}, and return a port\n" + (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 \n" - "which this is interpreted is similar to C stdio:\n\n" - "The first character must be one of the following:\n\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" @@ -244,48 +285,51 @@ SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0, "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 exist.\n" - "All writes to the port will go to the end of the file.\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\n" - "The following additional characters can be appended:\n\n" + "@end table\n" + "The following additional characters can be appended:\n" "@table @samp\n" + "@item b\n" + "Open the underlying file in binary mode, if supported by the operating system. " "@item +\n" "Open the port for both input and output. E.g., @code{r+}: open\n" "an existing file for both input and output.\n" "@item 0\n" - "Create an \"unbuffered\" port. In this case input and output operations\n" - "are passed directly to the underlying port implementation without\n" - "additional buffering. This is likely to slow down I/O operations.\n" - "The buffering mode can be changed while a port is in use\n" - "@pxref{Ports and File Descriptors, setvbuf}\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\n" - "In theory we could create read/write ports which were buffered in one\n" - "direction only. However this isn't included in the current interfaces.\n\n" - "If a file cannot be opened with the access requested,\n" - "@code{open-file} throws an exception.") + "@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_STRING (1, filename); - SCM_VALIDATE_STRING (2, modes); - SCM_STRING_COERCE_0TERMINATION_X (filename); - SCM_STRING_COERCE_0TERMINATION_X (modes); + scm_dynwind_begin (0); - file = SCM_STRING_CHARS (filename); - mode = SCM_STRING_CHARS (modes); + file = scm_to_locale_string (filename); + scm_dynwind_free (file); - switch (*mode) + md = scm_to_locale_string (mode); + scm_dynwind_free (md); + + switch (*md) { case 'r': flags |= O_RDONLY; @@ -297,9 +341,9 @@ SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0, 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) @@ -316,25 +360,70 @@ SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0, case 'l': /* line buffered: handled during output. */ break; default: - scm_out_of_range (FUNC_NAME, modes); + scm_out_of_range (FUNC_NAME, mode); } ptr++; } - SCM_SYSCALL (fdes = open (file, flags, 0666)); + SCM_SYSCALL (fdes = open_or_open64 (file, flags, 0666)); if (fdes == -1) { int en = errno; SCM_SYSERROR_MSG ("~A: ~S", - scm_cons (scm_makfrom0str (strerror (en)), + scm_cons (scm_strerror (scm_from_int (en)), scm_cons (filename, SCM_EOL)), en); } - port = scm_fdes_to_port (fdes, mode, filename); + port = scm_i_fdes_to_port (fdes, scm_i_mode_bits (mode), filename); + + scm_dynwind_end (); + return port; } #undef FUNC_NAME +#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'. @@ -343,16 +432,19 @@ SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0, NAME is a string to be used as the port's filename. */ SCM -scm_fdes_to_port (int fdes, char *mode, SCM name) +scm_i_fdes_to_port (int fdes, long mode_bits, SCM name) #define FUNC_NAME "scm_fdes_to_port" { - long mode_bits = scm_mode_bits (mode); SCM port; - scm_port *pt; + scm_t_port *pt; int flags; /* test that fdes is valid. */ +#ifdef __MINGW32__ + flags = getflags (fdes); +#else flags = fcntl (fdes, F_GETFL, 0); +#endif if (flags == -1) SCM_SYSERROR; flags &= O_ACCMODE; @@ -363,17 +455,16 @@ scm_fdes_to_port (int fdes, char *mode, SCM name) SCM_MISC_ERROR ("requested file mode not available on fdes", SCM_EOL); } - SCM_NEWCELL (port); - SCM_DEFER_INTS; - pt = scm_add_to_port_table (port); - SCM_SETPTAB_ENTRY (port, pt); - SCM_SET_CELL_TYPE (port, (scm_tc16_fport | mode_bits)); + scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); + port = scm_new_port_table_entry (scm_tc16_fport); + SCM_SET_CELL_TYPE(port, scm_tc16_fport | mode_bits); + pt = SCM_PTAB_ENTRY(port); { - struct scm_fport *fp - = (struct scm_fport *) malloc (sizeof (struct scm_fport)); - if (fp == NULL) - SCM_MEMORY_ERROR; + scm_t_fport *fp + = (scm_t_fport *) scm_gc_malloc_pointerless (sizeof (scm_t_fport), + "file port"); + fp->fdes = fdes; pt->rw_random = SCM_FDES_RANDOM_P (fdes); SCM_SETSTREAM (port, fp); @@ -383,18 +474,23 @@ scm_fdes_to_port (int fdes, char *mode, SCM name) scm_fport_buffer_add (port, -1, -1); } SCM_SET_FILENAME (port, name); - SCM_ALLOW_INTS; + scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); return port; } #undef FUNC_NAME +SCM +scm_fdes_to_port (int fdes, char *mode, SCM name) +{ + return scm_i_fdes_to_port (fdes, scm_mode_bits (mode), name); +} + /* Return a lower bound on the number of bytes available for input. */ static int fport_input_waiting (SCM port) { - int fdes = SCM_FSTREAM (port)->fdes; - #ifdef HAVE_SELECT + int fdes = SCM_FSTREAM (port)->fdes; struct timeval timeout; SELECT_TYPE read_set; SELECT_TYPE write_set; @@ -414,10 +510,15 @@ fport_input_waiting (SCM port) < 0) scm_syserror ("fport_input_waiting"); return FD_ISSET (fdes, &read_set) ? 1 : 0; -#elif defined (FIONREAD) + +#elif HAVE_IOCTL && defined (FIONREAD) + /* Note: cannot test just defined(FIONREAD) here, since mingw has FIONREAD + (for use with winsock ioctlsocket()) but not ioctl(). */ + int fdes = SCM_FSTREAM (port)->fdes; int remir; ioctl(fdes, FIONREAD, &remir); return remir; + #else scm_misc_error ("fport_input_waiting", "Not fully implemented on this platform", @@ -427,7 +528,7 @@ fport_input_waiting (SCM port) 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); @@ -435,29 +536,31 @@ prinfport (SCM exp,SCM port,scm_print_state *pstate) { int fdes; SCM name = SCM_FILENAME (exp); - if (SCM_STRINGP (name) || SCM_SYMBOLP (name)) + if (scm_is_string (name) || scm_is_symbol (name)) scm_display (name, port); else scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); scm_putc (' ', port); fdes = (SCM_FSTREAM (exp))->fdes; +#ifdef HAVE_TTYNAME if (isatty (fdes)) - scm_puts (ttyname (fdes), port); + scm_display (scm_ttyname (exp), port); else +#endif /* HAVE_TTYNAME */ scm_intprint (fdes, 10, port); } else { scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); scm_putc (' ', port); - scm_intprint (SCM_UNPACK (SCM_CDR (exp)), 16, port); + scm_uintprint ((scm_t_bits) SCM_PTAB_ENTRY (exp), 16, port); } scm_putc ('>', port); return 1; } -#ifdef GUILE_ISELECT +#ifndef __MINGW32__ /* thread-local block for input on fport's fdes. */ static void fport_wait_for_input (SCM port) @@ -477,28 +580,27 @@ fport_wait_for_input (SCM port) { FD_ZERO (&readfds); FD_SET (fdes, &readfds); - n = scm_internal_select (fdes + 1, &readfds, NULL, NULL, NULL); + n = scm_std_select (fdes + 1, &readfds, NULL, NULL, NULL); } while (n == -1 && errno == EINTR); } } -#endif +#endif /* !__MINGW32__ */ static void fport_flush (SCM port); -/* fill a port's read-buffer with a single read. - returns the first char 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 +#ifndef __MINGW32__ fport_wait_for_input (port); -#endif +#endif /* !__MINGW32__ */ SCM_SYSCALL (count = read (fp->fdes, pt->read_buf, pt->read_buf_size)); if (count == -1) scm_syserror ("fport_fill_input"); @@ -512,25 +614,25 @@ fport_fill_input (SCM port) } } -static off_t -fport_seek (SCM port, off_t offset, int whence) +static off_t_or_off64_t +fport_seek_or_seek64 (SCM port, off_t_or_off64_t offset, int whence) { - scm_port *pt = SCM_PTAB_ENTRY (port); - struct scm_fport *fp = SCM_FSTREAM (port); - off_t rv; - off_t result; + scm_t_port *pt = SCM_PTAB_ENTRY (port); + scm_t_fport *fp = SCM_FSTREAM (port); + off_t_or_off64_t rv; + off_t_or_off64_t result; if (pt->rw_active == SCM_PORT_WRITE) { if (offset != 0 || whence != SEEK_CUR) { fport_flush (port); - result = rv = lseek (fp->fdes, offset, whence); + result = rv = lseek_or_lseek64 (fp->fdes, offset, whence); } else { /* read current position without disturbing the buffer. */ - rv = lseek (fp->fdes, offset, whence); + rv = lseek_or_lseek64 (fp->fdes, offset, whence); result = rv + (pt->write_pos - pt->write_buf); } } @@ -540,13 +642,13 @@ fport_seek (SCM port, off_t offset, int whence) { /* could expand to avoid a second seek. */ scm_end_input (port); - result = rv = lseek (fp->fdes, offset, whence); + result = rv = lseek_or_lseek64 (fp->fdes, offset, whence); } else { /* read current position without disturbing the buffer (particularly the unread-char buffer). */ - rv = lseek (fp->fdes, offset, whence); + rv = lseek_or_lseek64 (fp->fdes, offset, whence); result = rv - (pt->read_end - pt->read_pos); if (pt->read_buf == pt->putback_buf) @@ -555,7 +657,7 @@ fport_seek (SCM port, off_t offset, int whence) } else /* SCM_PORT_NEITHER */ { - result = rv = lseek (fp->fdes, offset, whence); + result = rv = lseek_or_lseek64 (fp->fdes, offset, whence); } if (rv == -1) @@ -564,75 +666,157 @@ fport_seek (SCM port, off_t offset, int whence) return result; } +/* If we've got largefile and off_t isn't already off64_t then + fport_seek_or_seek64 needs a range checking wrapper to be fport_seek in + the port descriptor. + + Otherwise if no largefile, or off_t is the same as off64_t (which is the + case on NetBSD apparently), then fport_seek_or_seek64 is right to be + fport_seek already. */ + +#if GUILE_USE_64_CALLS && HAVE_STAT64 && SIZEOF_OFF_T != SIZEOF_OFF64_T +static off_t +fport_seek (SCM port, off_t offset, int whence) +{ + off64_t rv = fport_seek_or_seek64 (port, (off64_t) offset, whence); + if (rv > OFF_T_MAX || rv < OFF_T_MIN) + { + errno = EOVERFLOW; + scm_syserror ("fport_seek"); + } + return (off_t) rv; + +} +#else +#define fport_seek fport_seek_or_seek64 +#endif + +/* `how' has been validated and is one of SEEK_SET, SEEK_CUR or SEEK_END */ +SCM +scm_i_fport_seek (SCM port, SCM offset, int how) +{ + return scm_from_off_t_or_off64_t + (fport_seek_or_seek64 (port, scm_to_off_t_or_off64_t (offset), how)); +} + 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, const void *data, size_t size) +int +scm_i_fport_truncate (SCM port, SCM length) { - scm_port *pt = SCM_PTAB_ENTRY (port); + scm_t_fport *fp = SCM_FSTREAM (port); + return ftruncate_or_ftruncate64 (fp->fdes, scm_to_off_t_or_off64_t (length)); +} + +/* 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) +{ + 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_CELL_WORD_0 (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 work by this time. */ -extern int terminating; +extern int scm_i_terminating; static void fport_flush (SCM port) { - scm_port *pt = SCM_PTAB_ENTRY (port); - struct scm_fport *fp = SCM_FSTREAM (port); + scm_t_port *pt = SCM_PTAB_ENTRY (port); + scm_t_fport *fp = SCM_FSTREAM (port); unsigned char *ptr = pt->write_buf; - int init_size = pt->write_pos - pt->write_buf; - int remaining = init_size; + long init_size = pt->write_pos - pt->write_buf; + long remaining = init_size; while (remaining > 0) { - int count; + long count; SCM_SYSCALL (count = write (fp->fdes, ptr, remaining)); if (count < 0) { /* error. assume nothing was written this call, but fix up the buffer for any previous successful writes. */ - int done = init_size - remaining; + long done = init_size - remaining; if (done > 0) { @@ -644,7 +828,7 @@ fport_flush (SCM port) } pt->write_pos = pt->write_buf + remaining; } - if (terminating) + if (scm_i_terminating) { const char *msg = "Error: could not flush file-descriptor "; char buf[11]; @@ -675,8 +859,8 @@ fport_flush (SCM port) 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; @@ -694,8 +878,8 @@ fport_end_input (SCM port, int offset) 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); @@ -712,45 +896,47 @@ fport_close (SCM port) 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_gc_free (pt->read_buf, pt->read_buf_size, "port buffer"); if (pt->write_buf != &pt->shortbuf) - free (pt->write_buf); - free ((char *) fp); + scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer"); + scm_gc_free (fp, sizeof (*fp), "file port"); return rv; } -static scm_sizet +static size_t fport_free (SCM port) { fport_close (port); return 0; } -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 () { -#ifndef SCM_MAGIC_SNARFER + scm_tc16_fport = scm_make_fptob (); + + scm_c_define ("_IOFBF", scm_from_int (_IOFBF)); + scm_c_define ("_IOLBF", scm_from_int (_IOLBF)); + scm_c_define ("_IONBF", scm_from_int (_IONBF)); + #include "libguile/fports.x" -#endif - scm_sysintern ("_IOFBF", SCM_MAKINUM (_IOFBF)); - scm_sysintern ("_IOLBF", SCM_MAKINUM (_IOLBF)); - scm_sysintern ("_IONBF", SCM_MAKINUM (_IONBF)); } /*