[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.  */

#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

\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 ()
{
#ifndef SCM_MAGIC_SNARFER
#include "libguile/rw.x"
#endif

  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
	46	#include <errno.h>
fbbdb121	47	#include <string.h>
b0e5fd8c GH	48
	49	#include "libguile/_scm.h"
	50	#include "libguile/fports.h"
	51	#include "libguile/ports.h"
	52	#include "libguile/root.h"
	53	#include "libguile/rw.h"
	54	#include "libguile/strings.h"
	55	#include "libguile/validate.h"
fee12d18 MV	56	#include "libguile/modules.h"
fee12d18 MV	57	#include "libguile/strports.h"
b0e5fd8c GH	58
	59	#ifdef HAVE_UNISTD_H
	60	#include <unistd.h>
	61	#endif
	62
	63	\f
	64
	65	#if defined (EAGAIN)
	66	#define SCM_MAYBE_EAGAIN \|\| errno == EAGAIN
	67	#else
	68	#define SCM_MAYBE_EAGAIN
	69	#endif
	70
	71	#if defined (EWOULDBLOCK)
	72	#define SCM_MAYBE_EWOULDBLOCK \|\| errno == EWOULDBLOCK
	73	#else
	74	#define SCM_MAYBE_EWOULDBLOCK
	75	#endif
	76
	77	/* MAYBE there is EAGAIN way of defining this macro but now I EWOULDBLOCK. */
	78	#define SCM_EBLOCK(errno) \
	79	(0 SCM_MAYBE_EAGAIN SCM_MAYBE_EWOULDBLOCK)
	80
	81	SCM_DEFINE (scm_read_string_x_partial, "read-string!/partial", 1, 3, 0,
	82	(SCM str, SCM port_or_fdes, SCM start, SCM end),
99004a28 GH	83	"Read characters from a port or file descriptor into a\n"
	84	"string @var{str}. A port must have an underlying file\n"
	85	"descriptor --- a so-called fport. This procedure is\n"
	86	"scsh-compatible and can efficiently read large strings.\n"
	87	"It will:\n\n"
b0e5fd8c GH	88	"@itemize\n"
	89	"@item\n"
	90	"attempt to fill the entire string, unless the @var{start}\n"
	91	"and/or @var{end} arguments are supplied. i.e., @var{start}\n"
	92	"defaults to 0 and @var{end} defaults to\n"
	93	"@code{(string-length str)}\n"
	94	"@item\n"
	95	"use the current input port if @var{port_or_fdes} is not\n"
	96	"supplied.\n"
	97	"@item\n"
99004a28 GH	98	"return fewer than the requested number of characters in some\n"
	99	"cases, e.g., on end of file, if interrupted by a signal, or if\n"
	100	"not all the characters are immediately available.\n"
b0e5fd8c	101	"@item\n"
99004a28 GH	102	"wait indefinitely for some input if no characters are\n"
	103	"currently available,\n"
	104	"unless the port is in non-blocking mode.\n"
	105	"@item\n"
	106	"read characters from the port's input buffers if available,\n"
	107	"instead from the underlying file descriptor.\n"
b0e5fd8c GH	108	"@item\n"
	109	"return @code{#f} if end-of-file is encountered before reading\n"
	110	"any characters, otherwise return the number of characters\n"
	111	"read.\n"
	112	"@item\n"
	113	"return 0 if the port is in non-blocking mode and no characters\n"
	114	"are immediately available.\n"
	115	"@item\n"
	116	"return 0 if the request is for 0 bytes, with no\n"
99004a28	117	"end-of-file check.\n"
b0e5fd8c GH	118	"@end itemize")
	119	#define FUNC_NAME s_scm_read_string_x_partial
	120	{
	121	char *dest;
c014a02e ML	122	long read_len;
c014a02e ML	123	long chars_read = 0;
b0e5fd8c GH	124	int fdes;
	125
	126	{
c014a02e ML	127	long offset;
c014a02e ML	128	long last;
b0e5fd8c GH	129
	130	SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, dest, 3, start, offset,
	131	4, end, last);
	132	dest += offset;
	133	read_len = last - offset;
	134	}
	135
	136	if (SCM_INUMP (port_or_fdes))
	137	fdes = SCM_INUM (port_or_fdes);
	138	else
	139	{
	140	SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_inp : port_or_fdes;
	141
	142	SCM_VALIDATE_OPFPORT (2, port);
	143	SCM_VALIDATE_INPUT_PORT (2, port);
	144
	145	/* if there's anything in the port buffers, use it, but then
	146	don't touch the file descriptor. otherwise the
	147	"return immediately if something is available" rule may
	148	be violated. */
	149	chars_read = scm_take_from_input_buffers (port, dest, read_len);
	150	fdes = SCM_FPORT_FDES (port);
	151	}
	152
	153	if (chars_read == 0 && read_len > 0) /* don't confuse read_len == 0 with
	154	EOF. */
	155	{
	156	SCM_SYSCALL (chars_read = read (fdes, dest, read_len));
	157	if (chars_read == -1)
	158	{
	159	if (SCM_EBLOCK (errno))
	160	chars_read = 0;
	161	else
	162	SCM_SYSERROR;
	163	}
	164	else if (chars_read == 0)
	165	return SCM_BOOL_F;
	166	}
	167	return scm_long2num (chars_read);
	168	}
	169	#undef FUNC_NAME
	170
99004a28 GH	171	SCM_DEFINE (scm_write_string_partial, "write-string/partial", 1, 3, 0,
	172	(SCM str, SCM port_or_fdes, SCM start, SCM end),
	173	"Write characters from a string @var{str} to a port or file\n"
	174	"descriptor. A port must have an underlying file descriptor\n"
	175	"--- a so-called fport. This procedure is\n"
	176	"scsh-compatible and can efficiently write large strings.\n"
	177	"It will:\n\n"
	178	"@itemize\n"
	179	"@item\n"
	180	"attempt to write the entire string, unless the @var{start}\n"
	181	"and/or @var{end} arguments are supplied. i.e., @var{start}\n"
	182	"defaults to 0 and @var{end} defaults to\n"
	183	"@code{(string-length str)}\n"
	184	"@item\n"
	185	"use the current output port if @var{port_of_fdes} is not\n"
	186	"supplied.\n"
	187	"@item\n"
	188	"in the case of a buffered port, store the characters in the\n"
	189	"port's output buffer, if all will fit. If they will not fit\n"
	190	"then any existing buffered characters will be flushed\n"
	191	"before attempting\n"
	192	"to write the new characters directly to the underlying file\n"
	193	"descriptor. If the port is in non-blocking mode and\n"
	194	"buffered characters can not be flushed immediately, then an\n"
	195	"@code{EAGAIN} system-error exception will be raised (Note:\n"
	196	"scsh does not support the use of non-blocking buffered ports.)\n"
	197	"@item\n"
	198	"write fewer than the requested number of\n"
	199	"characters in some cases, e.g., if interrupted by a signal or\n"
	200	"if not all of the output can be accepted immediately.\n"
	201	"@item\n"
	202	"wait indefinitely for at least one character\n"
	203	"from @var{str} to be accepted by the port, unless the port is\n"
	204	"in non-blocking mode.\n"
	205	"@item\n"
	206	"return the number of characters accepted by the port.\n"
	207	"@item\n"
	208	"return 0 if the port is in non-blocking mode and can not accept\n"
	209	"at least one character from @var{str} immediately\n"
	210	"@item\n"
	211	"return 0 immediately if the request size is 0 bytes.\n"
	212	"@end itemize")
	213	#define FUNC_NAME s_scm_write_string_partial
	214	{
	215	char *src;
	216	long write_len;
	217	int fdes;
	218
	219	{
	220	long offset;
	221	long last;
	222
	223	SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, src, 3, start, offset,
	224	4, end, last);
	225	src += offset;
	226	write_len = last - offset;
	227	}
	228
	229	if (write_len == 0)
	230	return SCM_INUM0;
	231
	232	if (SCM_INUMP (port_or_fdes))
	233	fdes = SCM_INUM (port_or_fdes);
	234	else
235	{
236	SCM port = SCM_UNBNDP (port_or_fdes) ? scm_cur_outp : port_or_fdes;
92c2555f	237	scm_t_port *pt;
99004a28 GH	238	off_t space;
	239
	240	SCM_VALIDATE_OPFPORT (2, port);
	241	SCM_VALIDATE_OUTPUT_PORT (2, port);
	242	pt = SCM_PTAB_ENTRY (port);
	243	/* filling the last character in the buffer would require a flush. */
	244	space = pt->write_end - pt->write_pos - 1;
	245	if (space >= write_len)
	246	{
	247	memcpy (pt->write_pos, src, write_len);
	248	pt->write_pos += write_len;
	249	return scm_long2num (write_len);
	250	}
	251	if (pt->write_pos > pt->write_buf)
	252	scm_flush (port);
	253	fdes = SCM_FPORT_FDES (port);
	254	}
	255	{
	256	long rv;
	257
	258	SCM_SYSCALL (rv = write (fdes, src, write_len));
	259	if (rv == -1)
	260	{
	261	if (SCM_EBLOCK (errno))
	262	rv = 0;
	263	else
	264	SCM_SYSERROR;
	265	}
	266
	267	return scm_long2num (rv);
	268	}
	269	}
	270	#undef FUNC_NAME
	271
e615ee8d MV	272	SCM
e615ee8d MV	273	scm_init_rw_builtins ()
b0e5fd8c	274	{
b0e5fd8c GH	275	#ifndef SCM_MAGIC_SNARFER
	276	#include "libguile/rw.x"
	277	#endif
	278
e615ee8d MV	279	return SCM_UNSPECIFIED;
	280	}
	281
	282	void
	283	scm_init_rw ()
	284	{
9a441ddb	285	scm_c_define_gsubr ("%init-rw-builtins", 0, 0, 0, scm_init_rw_builtins);
b0e5fd8c GH	286	}
	287
	288	/*
	289	Local Variables:
	290	c-file-style: "gnu"
	291	End:
	292	*/