[bpt/guile.git] / libguile / rw.c

/* 	Copyright (C) 2001 Free Software Foundation, Inc.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * 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 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.
 *
 * 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.  */

\f

/* This is the C part of the (ice-9 rw) module.  */

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include <errno.h>
#include <string.h>

#include "libguile/_scm.h"
#include "libguile/fports.h"
#include "libguile/ports.h"
#include "libguile/root.h"
#include "libguile/rw.h"
#include "libguile/strings.h"
#include "libguile/validate.h"
#include "libguile/modules.h"
#include "libguile/strports.h"

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_IO_H
#include <io.h>
#endif

\f

#if defined (EAGAIN)
#define SCM_MAYBE_EAGAIN || errno == EAGAIN
#else
#define SCM_MAYBE_EAGAIN
#endif

#if defined (EWOULDBLOCK)
#define SCM_MAYBE_EWOULDBLOCK || errno == EWOULDBLOCK
#else
#define SCM_MAYBE_EWOULDBLOCK
#endif

/* MAYBE there is EAGAIN way of defining this macro but now I EWOULDBLOCK.  */
#define SCM_EBLOCK(errno) \
   (0 SCM_MAYBE_EAGAIN SCM_MAYBE_EWOULDBLOCK)

SCM_DEFINE (scm_read_string_x_partial, "read-string!/partial", 1, 3, 0,
	    (SCM str, SCM port_or_fdes, SCM start, SCM end),
	    "Read characters from a port or file descriptor into a\n"
	    "string @var{str}.  A port must have an underlying file\n"
	    "descriptor --- a so-called fport.  This procedure is\n"
	    "scsh-compatible and can efficiently read large strings.\n"
	    "It will:\n\n"
	    "@itemize\n"
	    "@item\n"
	    "attempt to fill the entire string, unless the @var{start}\n"
	    "and/or @var{end} arguments are supplied.  i.e., @var{start}\n"
	    "defaults to 0 and @var{end} defaults to\n"
	    "@code{(string-length str)}\n"
	    "@item\n"
	    "use the current input port if @var{port_or_fdes} is not\n"
	    "supplied.\n" 
	    "@item\n"
	    "return fewer than the requested number of characters in some\n"
	    "cases, e.g., on end of file, if interrupted by a signal, or if\n"
	    "not all the characters are immediately available.\n"
	    "@item\n"
	    "wait indefinitely for some input if no characters are\n"
	    "currently available,\n"
	    "unless the port is in non-blocking mode.\n"
	    "@item\n"
	    "read characters from the port's input buffers if available,\n"
	    "instead from the underlying file descriptor.\n"
	    "@item\n"
	    "return @code{#f} if end-of-file is encountered before reading\n"
            "any characters, otherwise return the number of characters\n"
	    "read.\n"
	    "@item\n"
	    "return 0 if the port is in non-blocking mode and no characters\n"
	    "are immediately available.\n"
	    "@item\n"
	    "return 0 if the request is for 0 bytes, with no\n"
	    "end-of-file check.\n"
	    "@end itemize")
#define FUNC_NAME s_scm_read_string_x_partial
{
  char *dest;
  long read_len;
  long chars_read = 0;
  int fdes;

  {
    long offset;
    long last;

    SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, dest, 3, start, offset,
				      4, end, last);
    dest += offset;
    read_len = last - offset;
  }

  if (SCM_INUMP (port_or_fdes))
    fdes = SCM_INUM (port_or_fdes);
  else
    {
      SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_inp : port_or_fdes;

      SCM_VALIDATE_OPFPORT (2, port);
      SCM_VALIDATE_INPUT_PORT (2, port);

      /* if there's anything in the port buffers, use it, but then
	 don't touch the file descriptor.  otherwise the
	 "return immediately if something is available" rule may
	 be violated.  */
      chars_read = scm_take_from_input_buffers (port, dest, read_len);
      fdes = SCM_FPORT_FDES (port);
    }

  if (chars_read == 0 && read_len > 0) /* don't confuse read_len == 0 with
					  EOF.  */
    {
      SCM_SYSCALL (chars_read = read (fdes, dest, read_len));
      if (chars_read == -1)
	{
	  if (SCM_EBLOCK (errno))
	    chars_read = 0;
	  else
	    SCM_SYSERROR;
        }
      else if (chars_read == 0)
	return SCM_BOOL_F;
    }
  return scm_long2num (chars_read);
}
#undef FUNC_NAME

SCM_DEFINE (scm_write_string_partial, "write-string/partial", 1, 3, 0,
	    (SCM str, SCM port_or_fdes, SCM start, SCM end),
	    "Write characters from a string @var{str} to a port or file\n"
	    "descriptor.  A port must have an underlying file descriptor\n"
	    "--- a so-called fport.  This procedure is\n"
	    "scsh-compatible and can efficiently write large strings.\n"
	    "It will:\n\n"
	    "@itemize\n"
	    "@item\n"
	    "attempt to write the entire string, unless the @var{start}\n"
	    "and/or @var{end} arguments are supplied.  i.e., @var{start}\n"
	    "defaults to 0 and @var{end} defaults to\n"
	    "@code{(string-length str)}\n"
	    "@item\n"
	    "use the current output port if @var{port_of_fdes} is not\n"
	    "supplied.\n"
	    "@item\n"
	    "in the case of a buffered port, store the characters in the\n"
	    "port's output buffer, if all will fit.  If they will not fit\n"
	    "then any existing buffered characters will be flushed\n"
	    "before attempting\n"
	    "to write the new characters directly to the underlying file\n"
	    "descriptor.  If the port is in non-blocking mode and\n"
	    "buffered characters can not be flushed immediately, then an\n"
	    "@code{EAGAIN} system-error exception will be raised (Note:\n"
	    "scsh does not support the use of non-blocking buffered ports.)\n"
	    "@item\n"
	    "write fewer than the requested number of\n"
	    "characters in some cases, e.g., if interrupted by a signal or\n"
	    "if not all of the output can be accepted immediately.\n"
	    "@item\n"
	    "wait indefinitely for at least one character\n"
	    "from @var{str} to be accepted by the port, unless the port is\n"
	    "in non-blocking mode.\n"
	    "@item\n"
	    "return the number of characters accepted by the port.\n"
	    "@item\n"
	    "return 0 if the port is in non-blocking mode and can not accept\n"
	    "at least one character from @var{str} immediately\n"
	    "@item\n"
	    "return 0 immediately if the request size is 0 bytes.\n"
	    "@end itemize")
#define FUNC_NAME s_scm_write_string_partial
{
  char *src;
  long write_len;
  int fdes;

  {
    long offset;
    long last;

    SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, src, 3, start, offset,
				      4, end, last);
    src += offset;
    write_len = last - offset;
  }

  if (write_len == 0)
    return SCM_INUM0;

  if (SCM_INUMP (port_or_fdes))
    fdes = SCM_INUM (port_or_fdes);
  else
    {
      SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_outp : port_or_fdes;
      scm_t_port *pt;
      off_t space;

      SCM_VALIDATE_OPFPORT (2, port);
      SCM_VALIDATE_OUTPUT_PORT (2, port);
      pt = SCM_PTAB_ENTRY (port);
      /* filling the last character in the buffer would require a flush.  */
      space = pt->write_end - pt->write_pos - 1;
      if (space >= write_len)
	{
	  memcpy (pt->write_pos, src, write_len);
	  pt->write_pos += write_len;
	  return scm_long2num (write_len);
	}
      if (pt->write_pos > pt->write_buf)
	scm_flush (port);
      fdes = SCM_FPORT_FDES (port);
    }
  {
    long rv;

    SCM_SYSCALL (rv = write (fdes, src, write_len));
    if (rv == -1)
      {
	if (SCM_EBLOCK (errno))
	  rv = 0;
	else
	  SCM_SYSERROR;
      }
    
    return scm_long2num (rv);
  }
}
#undef FUNC_NAME

SCM 
scm_init_rw_builtins ()
{
#include "libguile/rw.x"

  return SCM_UNSPECIFIED;
}

void
scm_init_rw ()
{
  scm_c_define_gsubr ("%init-rw-builtins", 0, 0, 0, scm_init_rw_builtins);
}

/*
  Local Variables:
  c-file-style: "gnu"
  End:
*/
Commit	Line	Data
b0e5fd8c GH	1	/* Copyright (C) 2001 Free Software Foundation, Inc.
	2	*
	3	* This program is free software; you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License as published by
	5	* the Free Software Foundation; either version 2, or (at your option)
	6	* any later version.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this software; see the file COPYING. If not, write to
	15	* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
	16	* Boston, MA 02111-1307 USA
	17	*
	18	* As a special exception, the Free Software Foundation gives permission
	19	* for additional uses of the text contained in its release of GUILE.
	20	*
	21	* The exception is that, if you link the GUILE library with other files
	22	* to produce an executable, this does not by itself cause the
	23	* resulting executable to be covered by the GNU General Public License.
	24	* Your use of that executable is in no way restricted on account of
	25	* linking the GUILE library code into it.
	26	*
	27	* This exception does not however invalidate any other reasons why
	28	* the executable file might be covered by the GNU General Public License.
	29	*
	30	* This exception applies only to the code released by the
	31	* Free Software Foundation under the name GUILE. If you copy
	32	* code from other Free Software Foundation releases into a copy of
	33	* GUILE, as the General Public License permits, the exception does
	34	* not apply to the code that you add in this way. To avoid misleading
	35	* anyone as to the status of such modified files, you must delete
	36	* this exception notice from them.
	37	*
	38	* If you write modifications of your own for GUILE, it is your choice
	39	* whether to permit this exception to apply to your modifications.
	40	* If you do not wish that, delete this exception notice. */
	41
	42	\f
	43
	44	/* This is the C part of the (ice-9 rw) module. */
	45
7b5a83d3 RB	46	#if HAVE_CONFIG_H
	47	# include <config.h>
	48	#endif
	49
b0e5fd8c	50	#include <errno.h>
fbbdb121	51	#include <string.h>
b0e5fd8c GH	52
	53	#include "libguile/_scm.h"
	54	#include "libguile/fports.h"
	55	#include "libguile/ports.h"
	56	#include "libguile/root.h"
	57	#include "libguile/rw.h"
	58	#include "libguile/strings.h"
	59	#include "libguile/validate.h"
fee12d18 MV	60	#include "libguile/modules.h"
fee12d18 MV	61	#include "libguile/strports.h"
b0e5fd8c GH	62
	63	#ifdef HAVE_UNISTD_H
	64	#include <unistd.h>
	65	#endif
7beabedb MG	66	#ifdef HAVE_IO_H
	67	#include <io.h>
	68	#endif
b0e5fd8c GH	69
	70	\f
	71
	72	#if defined (EAGAIN)
	73	#define SCM_MAYBE_EAGAIN \|\| errno == EAGAIN
	74	#else
	75	#define SCM_MAYBE_EAGAIN
	76	#endif
	77
	78	#if defined (EWOULDBLOCK)
	79	#define SCM_MAYBE_EWOULDBLOCK \|\| errno == EWOULDBLOCK
	80	#else
	81	#define SCM_MAYBE_EWOULDBLOCK
	82	#endif
	83
	84	/* MAYBE there is EAGAIN way of defining this macro but now I EWOULDBLOCK. */
	85	#define SCM_EBLOCK(errno) \
	86	(0 SCM_MAYBE_EAGAIN SCM_MAYBE_EWOULDBLOCK)
	87
	88	SCM_DEFINE (scm_read_string_x_partial, "read-string!/partial", 1, 3, 0,
	89	(SCM str, SCM port_or_fdes, SCM start, SCM end),
99004a28 GH	90	"Read characters from a port or file descriptor into a\n"
	91	"string @var{str}. A port must have an underlying file\n"
	92	"descriptor --- a so-called fport. This procedure is\n"
	93	"scsh-compatible and can efficiently read large strings.\n"
	94	"It will:\n\n"
b0e5fd8c GH	95	"@itemize\n"
	96	"@item\n"
	97	"attempt to fill the entire string, unless the @var{start}\n"
	98	"and/or @var{end} arguments are supplied. i.e., @var{start}\n"
	99	"defaults to 0 and @var{end} defaults to\n"
	100	"@code{(string-length str)}\n"
	101	"@item\n"
	102	"use the current input port if @var{port_or_fdes} is not\n"
	103	"supplied.\n"
	104	"@item\n"
99004a28 GH	105	"return fewer than the requested number of characters in some\n"
	106	"cases, e.g., on end of file, if interrupted by a signal, or if\n"
	107	"not all the characters are immediately available.\n"
b0e5fd8c	108	"@item\n"
99004a28 GH	109	"wait indefinitely for some input if no characters are\n"
	110	"currently available,\n"
	111	"unless the port is in non-blocking mode.\n"
	112	"@item\n"
	113	"read characters from the port's input buffers if available,\n"
	114	"instead from the underlying file descriptor.\n"
b0e5fd8c GH	115	"@item\n"
	116	"return @code{#f} if end-of-file is encountered before reading\n"
	117	"any characters, otherwise return the number of characters\n"
	118	"read.\n"
	119	"@item\n"
	120	"return 0 if the port is in non-blocking mode and no characters\n"
	121	"are immediately available.\n"
	122	"@item\n"
	123	"return 0 if the request is for 0 bytes, with no\n"
99004a28	124	"end-of-file check.\n"
b0e5fd8c GH	125	"@end itemize")
	126	#define FUNC_NAME s_scm_read_string_x_partial
	127	{
	128	char *dest;
c014a02e ML	129	long read_len;
c014a02e ML	130	long chars_read = 0;
b0e5fd8c GH	131	int fdes;
	132
	133	{
c014a02e ML	134	long offset;
c014a02e ML	135	long last;
b0e5fd8c GH	136
	137	SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, dest, 3, start, offset,
	138	4, end, last);
	139	dest += offset;
	140	read_len = last - offset;
	141	}
	142
	143	if (SCM_INUMP (port_or_fdes))
	144	fdes = SCM_INUM (port_or_fdes);
	145	else
	146	{
	147	SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_inp : port_or_fdes;
	148
	149	SCM_VALIDATE_OPFPORT (2, port);
	150	SCM_VALIDATE_INPUT_PORT (2, port);
	151
	152	/* if there's anything in the port buffers, use it, but then
	153	don't touch the file descriptor. otherwise the
	154	"return immediately if something is available" rule may
	155	be violated. */
	156	chars_read = scm_take_from_input_buffers (port, dest, read_len);
	157	fdes = SCM_FPORT_FDES (port);
	158	}
	159
	160	if (chars_read == 0 && read_len > 0) /* don't confuse read_len == 0 with
	161	EOF. */
	162	{
	163	SCM_SYSCALL (chars_read = read (fdes, dest, read_len));
	164	if (chars_read == -1)
	165	{
	166	if (SCM_EBLOCK (errno))
	167	chars_read = 0;
	168	else
	169	SCM_SYSERROR;
	170	}
	171	else if (chars_read == 0)
	172	return SCM_BOOL_F;
	173	}
	174	return scm_long2num (chars_read);
	175	}
	176	#undef FUNC_NAME
	177
99004a28 GH	178	SCM_DEFINE (scm_write_string_partial, "write-string/partial", 1, 3, 0,
	179	(SCM str, SCM port_or_fdes, SCM start, SCM end),
	180	"Write characters from a string @var{str} to a port or file\n"
	181	"descriptor. A port must have an underlying file descriptor\n"
	182	"--- a so-called fport. This procedure is\n"
	183	"scsh-compatible and can efficiently write large strings.\n"
	184	"It will:\n\n"
	185	"@itemize\n"
	186	"@item\n"
	187	"attempt to write the entire string, unless the @var{start}\n"
	188	"and/or @var{end} arguments are supplied. i.e., @var{start}\n"
	189	"defaults to 0 and @var{end} defaults to\n"
	190	"@code{(string-length str)}\n"
	191	"@item\n"
	192	"use the current output port if @var{port_of_fdes} is not\n"
	193	"supplied.\n"
	194	"@item\n"
	195	"in the case of a buffered port, store the characters in the\n"
	196	"port's output buffer, if all will fit. If they will not fit\n"
	197	"then any existing buffered characters will be flushed\n"
	198	"before attempting\n"
	199	"to write the new characters directly to the underlying file\n"
	200	"descriptor. If the port is in non-blocking mode and\n"
	201	"buffered characters can not be flushed immediately, then an\n"
	202	"@code{EAGAIN} system-error exception will be raised (Note:\n"
	203	"scsh does not support the use of non-blocking buffered ports.)\n"
	204	"@item\n"
	205	"write fewer than the requested number of\n"
	206	"characters in some cases, e.g., if interrupted by a signal or\n"
	207	"if not all of the output can be accepted immediately.\n"
	208	"@item\n"
	209	"wait indefinitely for at least one character\n"
	210	"from @var{str} to be accepted by the port, unless the port is\n"
	211	"in non-blocking mode.\n"
	212	"@item\n"
	213	"return the number of characters accepted by the port.\n"
	214	"@item\n"
	215	"return 0 if the port is in non-blocking mode and can not accept\n"
	216	"at least one character from @var{str} immediately\n"
	217	"@item\n"
	218	"return 0 immediately if the request size is 0 bytes.\n"
	219	"@end itemize")
	220	#define FUNC_NAME s_scm_write_string_partial
	221	{
	222	char *src;
	223	long write_len;
	224	int fdes;
	225
	226	{
	227	long offset;
	228	long last;
	229
	230	SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, src, 3, start, offset,
	231	4, end, last);
	232	src += offset;
	233	write_len = last - offset;
	234	}
	235
	236	if (write_len == 0)
	237	return SCM_INUM0;
	238
	239	if (SCM_INUMP (port_or_fdes))
	240	fdes = SCM_INUM (port_or_fdes);
	241	else
242	{
243	SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_outp : port_or_fdes;
92c2555f	244	scm_t_port *pt;
99004a28 GH	245	off_t space;
	246
	247	SCM_VALIDATE_OPFPORT (2, port);
	248	SCM_VALIDATE_OUTPUT_PORT (2, port);
	249	pt = SCM_PTAB_ENTRY (port);
	250	/* filling the last character in the buffer would require a flush. */
	251	space = pt->write_end - pt->write_pos - 1;
	252	if (space >= write_len)
	253	{
	254	memcpy (pt->write_pos, src, write_len);
	255	pt->write_pos += write_len;
	256	return scm_long2num (write_len);
	257	}
	258	if (pt->write_pos > pt->write_buf)
	259	scm_flush (port);
	260	fdes = SCM_FPORT_FDES (port);
	261	}
	262	{
	263	long rv;
	264
	265	SCM_SYSCALL (rv = write (fdes, src, write_len));
	266	if (rv == -1)
	267	{
	268	if (SCM_EBLOCK (errno))
	269	rv = 0;
	270	else
	271	SCM_SYSERROR;
	272	}
	273
	274	return scm_long2num (rv);
	275	}
	276	}
	277	#undef FUNC_NAME
	278
e615ee8d MV	279	SCM
e615ee8d MV	280	scm_init_rw_builtins ()
b0e5fd8c	281	{
b0e5fd8c	282	#include "libguile/rw.x"
b0e5fd8c	283
e615ee8d MV	284	return SCM_UNSPECIFIED;
	285	}
	286
	287	void
	288	scm_init_rw ()
	289	{
9a441ddb	290	scm_c_define_gsubr ("%init-rw-builtins", 0, 0, 0, scm_init_rw_builtins);
b0e5fd8c GH	291	}
	292
	293	/*
	294	Local Variables:
	295	c-file-style: "gnu"
	296	End:
	297	*/