-/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
- *
+/* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+ * 2004, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ *
* 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.
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
*
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
*
* 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
*/
\f
#define _LARGEFILE64_SOURCE /* ask for stat64 etc */
+#define _GNU_SOURCE /* ask for LONG_LONG_MAX/LONG_LONG_MIN */
#ifdef HAVE_CONFIG_H
# include <config.h>
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
#include <sys/stat.h>
#endif
-
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
#include <errno.h>
#include <sys/types.h>
+#include <full-write.h>
+
#include "libguile/iselect.h"
/* Some defines for Windows (native port, not Cygwin). */
# include <winsock2.h>
#endif /* __MINGW32__ */
+#include <full-write.h>
+
/* Mingw (version 3.4.5, circa 2006) has ftruncate as an alias for chsize
already, but have this code here in case that wasn't so in past versions,
or perhaps to help other minimal DOS environments.
gnulib ftruncate.c has code using fcntl F_CHSIZE and F_FREESP, which
might be possibilities if we've got other systems without ftruncate. */
-#if HAVE_CHSIZE && ! HAVE_FTRUNCATE
+#if defined HAVE_CHSIZE && ! defined HAVE_FTRUNCATE
# define ftruncate(fd, size) chsize (fd, size)
-#undef HAVE_FTRUNCATE
-#define HAVE_FTRUNCATE 1
+# undef HAVE_FTRUNCATE
+# define HAVE_FTRUNCATE 1
#endif
#if SIZEOF_OFF_T == SIZEOF_INT
{
int cmode;
long csize;
+ SCM drained;
scm_t_port *pt;
port = SCM_COERCE_OUTPORT (port);
pt = SCM_PTAB_ENTRY (port);
- /* silently discards buffered and put-back chars. */
+ if (SCM_INPUT_PORT_P (port))
+ drained = scm_drain_input (port);
+ else
+ drained = scm_nullstr;
+
+ if (SCM_OUTPUT_PORT_P (port))
+ scm_flush (port);
+
if (pt->read_buf == pt->putback_buf)
{
pt->read_buf = pt->saved_read_buf;
scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer");
scm_fport_buffer_add (port, csize, csize);
+
+ if (scm_is_true (drained) && scm_c_string_length (drained))
+ scm_unread_string (drained, port);
+
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
#undef FUNC_NAME
+static SCM sys_file_port_name_canonicalization;
+SCM_SYMBOL (sym_relative, "relative");
+SCM_SYMBOL (sym_absolute, "absolute");
+
+static SCM
+fport_canonicalize_filename (SCM filename)
+{
+ SCM mode = scm_fluid_ref (sys_file_port_name_canonicalization);
+
+ if (!scm_is_string (filename))
+ {
+ return filename;
+ }
+ else if (scm_is_eq (mode, sym_relative))
+ {
+ SCM path, rel;
+
+ path = scm_variable_ref (scm_c_module_lookup (scm_the_root_module (),
+ "%load-path"));
+ rel = scm_i_relativize_path (filename, path);
+
+ return scm_is_true (rel) ? rel : filename;
+ }
+ else if (scm_is_eq (mode, sym_absolute))
+ {
+ char *str, *canon;
+
+ str = scm_to_locale_string (filename);
+ canon = canonicalize_file_name (str);
+ free (str);
+
+ return canon ? scm_take_locale_string (canon) : filename;
+ }
+ else
+ {
+ return filename;
+ }
+}
+
+
/* scm_open_file
* Return a new port open on a given file.
*
* Return the new port.
*/
SCM_DEFINE (scm_open_file, "open-file", 2, 0, 0,
- (SCM filename, SCM mode),
+ (SCM filename, SCM mode),
"Open the file whose name is @var{filename}, and return a port\n"
"representing that file. The attributes of the port are\n"
"determined by the @var{mode} string. The way in which this is\n"
"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. "
+ "Open the underlying file in binary mode, if supported by the system.\n"
+ "Also, open the file using the binary-compatible character encoding\n"
+ "\"ISO-8859-1\", ignoring the port's encoding and the coding declaration\n"
+ "at the top of the input file, if any.\n"
"@item +\n"
"Open the port for both input and output. E.g., @code{r+}: open\n"
"an existing file for both input and output.\n"
"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"
+ "When the file is opened, this procedure will scan for a coding\n"
+ "declaration@pxref{Character Encoding of Source Files}. If present\n"
+ "will use that encoding for interpreting the file. Otherwise, the\n"
+ "port's encoding will be used.\n"
+ "\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"
#define FUNC_NAME s_scm_open_file
{
SCM port;
- int fdes;
- int flags = 0;
- char *file;
- char *md;
- char *ptr;
+ int fdes, flags = 0, use_encoding = 1;
+ unsigned int retries;
+ char *file, *md, *ptr;
scm_dynwind_begin (0);
flags = (flags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
break;
case 'b':
+ use_encoding = 0;
#if defined (O_BINARY)
flags |= O_BINARY;
#endif
}
ptr++;
}
- SCM_SYSCALL (fdes = open_or_open64 (file, flags, 0666));
- if (fdes == -1)
+
+ for (retries = 0, fdes = -1;
+ fdes < 0 && retries < 2;
+ retries++)
{
- int en = errno;
+ SCM_SYSCALL (fdes = open_or_open64 (file, flags, 0666));
+ if (fdes == -1)
+ {
+ int en = errno;
+
+ if (en == EMFILE && retries == 0)
+ /* Run the GC in case it collects open file ports that are no
+ longer referenced. */
+ scm_i_gc (FUNC_NAME);
+ else
+ SCM_SYSERROR_MSG ("~A: ~S",
+ scm_cons (scm_strerror (scm_from_int (en)),
+ scm_cons (filename, SCM_EOL)), en);
+ }
+ }
- SCM_SYSERROR_MSG ("~A: ~S",
- scm_cons (scm_strerror (scm_from_int (en)),
- scm_cons (filename, SCM_EOL)), en);
+ /* Create a port from this file descriptor. The port's encoding is initially
+ %default-port-encoding. */
+ port = scm_i_fdes_to_port (fdes, scm_i_mode_bits (mode),
+ fport_canonicalize_filename (filename));
+
+ if (use_encoding)
+ {
+ /* If this file has a coding declaration, use that as the port
+ encoding. */
+ if (SCM_INPUT_PORT_P (port))
+ {
+ char *enc = scm_i_scan_for_encoding (port);
+ if (enc != NULL)
+ scm_i_set_port_encoding_x (port, enc);
+ }
}
- port = scm_i_fdes_to_port (fdes, scm_i_mode_bits (mode), filename);
+ else
+ /* If this is a binary file, use the binary-friendly ISO-8859-1
+ encoding. */
+ scm_i_set_port_encoding_x (port, NULL);
scm_dynwind_end ();
static int
fport_input_waiting (SCM port)
{
-#ifdef HAVE_SELECT
int fdes = SCM_FSTREAM (port)->fdes;
+
+ /* `FD_SETSIZE', which is 1024 on GNU systems, effectively limits the
+ highest numerical value of file descriptors that can be monitored.
+ Thus, use poll(2) whenever that is possible. */
+
+#ifdef HAVE_POLL
+ struct pollfd pollfd = { fdes, POLLIN, 0 };
+
+ if (poll (&pollfd, 1, 0) < 0)
+ scm_syserror ("fport_input_waiting");
+
+ return pollfd.revents & POLLIN ? 1 : 0;
+
+#elif defined(HAVE_SELECT)
struct timeval timeout;
SELECT_TYPE read_set;
SELECT_TYPE write_set;
scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port);
scm_putc (' ', port);
fdes = (SCM_FSTREAM (exp))->fdes;
-
-#ifdef HAVE_TTYNAME
+
+#if (defined HAVE_TTYNAME) && (defined HAVE_POSIX)
if (isatty (fdes))
scm_display (scm_ttyname (exp), port);
else
return 1;
}
-#ifndef __MINGW32__
-/* thread-local block for input on fport's fdes. */
-static void
-fport_wait_for_input (SCM port)
-{
- int fdes = SCM_FSTREAM (port)->fdes;
-
- if (!fport_input_waiting (port))
- {
- int n;
- SELECT_TYPE readfds;
- int flags = fcntl (fdes, F_GETFL);
-
- if (flags == -1)
- scm_syserror ("scm_fdes_wait_for_input");
- if (!(flags & O_NONBLOCK))
- do
- {
- FD_ZERO (&readfds);
- FD_SET (fdes, &readfds);
- n = scm_std_select (fdes + 1, &readfds, NULL, NULL, NULL);
- }
- while (n == -1 && errno == EINTR);
- }
-}
-#endif /* !__MINGW32__ */
-
static void fport_flush (SCM port);
/* fill a port's read-buffer with a single read. returns the first
char or EOF if end of file. */
-static int
+static scm_t_wchar
fport_fill_input (SCM port)
{
long count;
scm_t_port *pt = SCM_PTAB_ENTRY (port);
scm_t_fport *fp = SCM_FSTREAM (port);
-#ifndef __MINGW32__
- fport_wait_for_input (port);
-#endif /* !__MINGW32__ */
SCM_SYSCALL (count = read (fp->fdes, pt->read_buf, pt->read_buf_size));
if (count == -1)
scm_syserror ("fport_fill_input");
if (count == 0)
- return EOF;
+ return (scm_t_wchar) EOF;
else
{
pt->read_pos = pt->read_buf;
}
}
-static off_t_or_off64_t
-fport_seek_or_seek64 (SCM port, off_t_or_off64_t offset, int whence)
+static scm_t_off
+fport_seek (SCM port, scm_t_off offset, int whence)
{
scm_t_port *pt = SCM_PTAB_ENTRY (port);
scm_t_fport *fp = SCM_FSTREAM (port);
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)
+fport_truncate (SCM port, scm_t_off length)
{
scm_t_fport *fp = SCM_FSTREAM (port);
scm_syserror ("ftruncate");
}
-int
-scm_i_fport_truncate (SCM port, SCM length)
-{
- 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;
-
- while (remaining > 0)
- {
- size_t done;
-
- SCM_SYSCALL (done = write (fdes, data, remaining));
-
- if (done == -1)
- SCM_SYSERROR;
- remaining -= done;
- data = ((const char *) data) + done;
- }
-}
-#undef FUNC_NAME
-
static void
fport_write (SCM port, const void *data, size_t size)
+#define FUNC_NAME "fport_write"
{
/* 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))
{
- /* "unbuffered" port, or
- port with empty buffer and data won't fit in buffer. */
- write_all (port, data, size);
+ /* Unbuffered port, or port with empty buffer and data won't fit in
+ buffer. */
+ if (full_write (SCM_FPORT_FDES (port), data, size) < size)
+ SCM_SYSERROR;
+
return;
}
{
- off_t space = pt->write_end - pt->write_pos;
+ scm_t_off space = pt->write_end - pt->write_pos;
if (size <= space)
{
if (size >= pt->write_buf_size)
{
- write_all (port, ptr, remaining);
+ if (full_write (SCM_FPORT_FDES (port), ptr, remaining)
+ < remaining)
+ SCM_SYSERROR;
return;
}
else
fport_flush (port);
}
}
-
-/* becomes 1 when process is exiting: normal exception handling won't
- work by this time. */
-extern int scm_i_terminating;
+#undef FUNC_NAME
static void
fport_flush (SCM port)
{
+ size_t written;
scm_t_port *pt = SCM_PTAB_ENTRY (port);
scm_t_fport *fp = SCM_FSTREAM (port);
- unsigned char *ptr = pt->write_buf;
- long init_size = pt->write_pos - pt->write_buf;
- long remaining = init_size;
-
- while (remaining > 0)
- {
- 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. */
- long done = init_size - remaining;
-
- if (done > 0)
- {
- int i;
-
- for (i = 0; i < remaining; i++)
- {
- *(pt->write_buf + i) = *(pt->write_buf + done + i);
- }
- pt->write_pos = pt->write_buf + remaining;
- }
- if (scm_i_terminating)
- {
- const char *msg = "Error: could not flush file-descriptor ";
- char buf[11];
+ size_t count = pt->write_pos - pt->write_buf;
- write (2, msg, strlen (msg));
- sprintf (buf, "%d\n", fp->fdes);
- write (2, buf, strlen (buf));
+ written = full_write (fp->fdes, pt->write_buf, count);
+ if (written < count)
+ scm_syserror ("scm_flush");
- count = remaining;
- }
- else if (scm_gc_running_p)
- {
- /* silently ignore the error. scm_error would abort if we
- called it now. */
- count = remaining;
- }
- else
- scm_syserror ("fport_flush");
- }
- ptr += count;
- remaining -= count;
- }
pt->write_pos = pt->write_buf;
pt->rw_active = SCM_PORT_NEITHER;
}
scm_c_define ("_IOLBF", scm_from_int (_IOLBF));
scm_c_define ("_IONBF", scm_from_int (_IONBF));
+ sys_file_port_name_canonicalization = scm_make_fluid ();
+ scm_c_define ("%file-port-name-canonicalization",
+ sys_file_port_name_canonicalization);
+
#include "libguile/fports.x"
}
HCoop / bpt / guile.git / blobdiff