* scm_validate.h: Added SCM_VALIDATE_THREAD.
* *.c: Remove SCM_NIMP(X) when it is an extraneous pre-test given
that SCM_FOOP macros all now include SCM_NIMP in their expansion.
This simplifies lots of code, making it far more readable.
GUILE_PROC1. Build guile-procedures.txt, and add that file to
pkgdata_DATA.
* load.c: Added `pkgdata-dir', `site-dir', `library-dir'
primitives.
* guile-doc-snarf.awk: Drop trailing space when no arguments:
e.g., "(foo )" is now "(foo)".
* *.c: moved all the documentation for primitives from
guile-doc/ref/{appendices,posix,scheme}.texi into the source code.
This leaves about half of the primitives undocumented. Also, all
the markup is currently still texinfo. I don't have a problem
with texinfo per se, but the markup is not very descriptive or
accurate.
function headers and argument checking. Switched SCM_PROC,
SCM_PROC1 macros to be GUILE_PROC, GUILE_PROC1 (may change names
later, but was useful to keep old versions around while migrate)
that has docstrings and argument lists embedded in the GUILE_PROC
macro invocations that expand into a function header. Use lots of
new SCM_VALIDATE_* macros to simplify error checking and reduce
tons of redundancy. This is very similar to what I did for Scwm.
Note that none of the extraction of the docstrings, nor software
engineering checks of Scwm is yet added to Guile. I'll work on
that tomorrow, I expect.
* Makefile.am: Added scm_validate.h to modinclude_HEADERS.
* chars.c: Added docstrings for the primitives defined in here.
* snarf.h: Added GUILE_PROC, GUILE_PROC1. Added
SCM_REGISTER_PROC to be like old SCM_PROC, though old SCM_PROC
still remains for now. Changed naming convention for the s_foo
string name of the primitive to be s_scm_foo for ease of use with
the macro.
* scm_validate.h: Lots of new SCM_VALIDATE macros to simplify
argument checking through guile. Maybe some of these should be
folded into the header file for the types they check, but for now
it was easiest to just stick them all in one place.
caller of the ptob seek procedure to the implementation. This
gives more control in general to the ptob seek: in particular the
change of 1999-10-20 can be made to work without breaking seek on
string ports. There's a comment in NEWS about upgrading port
types.
* ports.c (scm_seek): don't reset the port buffers here.
* fports.c (fport_seek): reset the buffers, except for the
0 SEEK_CUR case.
* strports.c (st_end_input): (bug fix): decrement pt->read_pos by
offset. check that it's not less than read_buf.
(st_seek): reset the buffers first, unless it's the 0 SEEK_CUR
case and currently reading.
random access. rw_active needs to be maintained even for single
directional ports, otherwise scm_seek and probably other things are
broken. (thanks to Roland Orre).
* strports.c (scm_mkstrport): set rw_random to 1 unconditionally.
* ports.c (scm_add_to_port_table): initialise rw_random to 0.
* ports.h (scm_port): change the comments on rw_random and rw_active.
* strports.c (scm_strport_to_string): create the string from
pt->read_buf instead of an expression that evaluates to the
same thing.
* gdbint.c (gdb_print): don't just use SCM_CHARS to get a C string
from the port: the port's buffer may not be NUL terminated.
SCM_PORT_READ, SCM_PORT_WRITE, and SCM_PORT_NEITHER (instead of
zero). The debugger knows about enums, but doesn't know about
#defines.
(typedef scm_port): Declare rw_active member to be an enum
scm_port_rw_active.
* fports.c (fport_flush, fport_end_input): Use SCM_PORT_NEITHER
instead of zero.
* ports.c (scm_add_to_port_table): Same.
* strports.c (st_flush, st_end_input): Same.
* 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.
it's more efficient for unbuffered fports (e.g., sockets.)
* ports.c (scm_puts): use ptob->write.
* vports.c (scm_make_sfptob): set write proc in ptob.
* strports.c (scm_make_stptob): set write proc in ptob.
* ports.c (write_void_port): new procedure.
* vports.c (sf_write): new procedure.
* ports.c (scm_lfwrite): use ptob->write.
* strports.c (st_write): new procedure.
* fports.c (fport_write): new procedure.
(scm_make_fptob): set write in ptob to fport_write.
* ports.h: prototype for scm_set_port_write.
* ports.c (scm_make_port_type): initialise ptob write procedure.
(scm_set_port_write): new proc.
* unif.c (scm_uniform_array_read_x), ports.c (scm_getc): increment
read_pos after scm_fill_buffer.
* ioext.c (scm_do_read_line): simplify by ignoring the fill_buffer
return char.
* vports.c (sf_fill_buffer), strports.c (stfill_buffer),
fports.c (fport_fill_buffer): implement the interface change.
* ports.c (scm_fill_buffer): interface change: no longer increments
read_pos past the character that's returned. it seems clearer to
leave it to the caller to decide what to do (thanks Jim).
* vports.c (sf_fill_buffer): put the read char into the buffer
as well as returning it.
* ports.c (scm_grow_port_cbuf): residue of this deleted procedure
deleted.
* strports.c (scm_strprint_obj): simplify. start with initial
buffer size of 0.
(st_seek): don't allow string to be extended if seeking past
the end of a read-only port.
1999-07-12 Gary Houston <ghouston@easynet.co.uk>
* strports.c (st_seek): change the resize checks.
* ports.c (scm_ftruncate): throw error if offset works out negative.
* strports.c (st_flush): increase string size in blocks of
SCM_WRITE_BLOCK instead of 1. set read_end to read_pos if
it's greater and reset read_buf_size.
(scm_mkstrport): set rw_randow if only writing, since read_buf needs
to be maintained for output ports too (it holds the written
part of the string, while write_buf may have unwritten buffer
chars.)
(st_truncate): rewritten.
(top of file): added a few notes.
1999-07-06 Gary Houston <ghouston@easynet.co.uk>
* strports.c (st_grow_port): set pt->read_pos. set
pt->read_buf_size one less than pt->write_buf_size if there's
an unwritten char at the end of the string. similarly for
pt->read_end.
(st_resize_port): renamed from st_grow_port.
(st_seek): simplify by assuming that pt->write_pos == pt->read_pos.
seek from read_end instead of write_end for SEEK_END.
(st_ftruncate): calculate current length using readbuf, not write
buf.
(scm_strport_to_string): use read_buf_size for length.
(stfill_buffer): don't re-initialise the readbuf.
1999-07-05 Gary Houston <ghouston@easynet.co.uk>
* strports.c (scm_strport_to_string): new procedure.
(scm_call_with_output_string, scm_strprint_obj): use
scm_strport_to_string.
used SCM_INUM0 instead of SCM_MAKINUM (0) in a few places.
* unif.c (scm_uniform_array_write): likewise.
* ioext.c (scm_redirect_port): likewise.
* ports.c (scm_putc): call scm_read_flush.
(scm_puts): likewise.
(scm_lfwrite): likewise.
(scm_lseek): likewise.
(scm_ftruncate): likewise.
* ports.c (scm_fill_buffer): don't take pt argument. change callers.
(read_flush_void_port): new proc, for void port ptob.
* vports.c (sf_read_flush): likewise.
* strports.c (st_read_flush): take offset arg.
* fports.c (local_read_flush): use offset, don't reset putback
buffer here.
* ports.h (scm_ptobfuns): let read_flush take an offset argument,
which is the number of chars from the putback buffer.
* ports.c (scm_read_flush): new procedure, resets the putback
buffer before calling the ptob routine.
extra character at the end of the string in the result.
* fports.c, fports.h, gc.c, gdbint.c, ioext.c, ports.c, ports.h,
scmsigs.c, strports.c, vports.c: Install the sources which
actually correspond to the changes described below. I got the
ChangeLog entries and the patch from two different places...
newline. A bit faster, and definitely hairier.
(scm_read_line): Count newlines here instead.
* strings.c (scm_take_str): New function.
(scm_take0str): Reimplement in terms of scm_take_str. * strings.h
(scm_take_str): New declaration. * ioext.c (scm_read_line): Use
scm_take_str, to avoid copying the string.
Add some simple-minded support for line buffered ports.
* ports.h (SCM_BUFLINE): New flag for ports.
* init.c (scm_init_standard_ports): Request line-buffering on
the standard output port.
* * ports.c (scm_mode_bits): Recognize 'l' as a request for line
buffering.
(scm_putc, scm_puts, scm_lfwrite): If the port is line-buffered,
and there's a newline to be written, flush the port.
* ports.c: (scm_lseek): clear buffers even if just reading current
position.
* fports.c (local_fclose): call local_fflush unconditionally.
(various): don't use the scm_must... memory procs.
* ports.h (scm_port): make read_pos a pointer to const.
strports.c: take care of rw_active and rw_randow.
fports.c: scm_fport_drain_input: removed. do it all in ports.c.
strports.c (scm_mkstrport): check that pos is reasonable.
ioext.c (scm_ftell, scm_fseek): use lseek.
(SCM_CLEAR_BUFFERS): macro deleted.
ioext.c (redirect_port: use ptob fflush, read_flush.
ports.h (scm_ptobfuns): add ftruncate.
ports.c (scm_newptob): set ftruncate.
adjust ptob tables.
* ports.c (scm_ftruncate): new procedure.
fports.c (local_ftrunate), strports.c (str_ftruncate): new procs.
strports.c (st_seek, st_grow_port): new procs.
fports.h (scm_port): change size types from int to off_t.
ports.c (scm_init_ports): initialise the seek symbols here
instead of in ioext.c.
strports.c (scm_call_with_output_string): start with an empty
string, so seek and ftruncate can be used.
* ports.h (scm_ptobfuns): add a read_flush procedure which is the
equivalent to fflush for the read buffer.
* ports.c (scm_newptob): set read_flush.
ports.c (void_port_ptob): set read_flush.
fports.c (local_read_flush): new proc. add to ptob.
strport.c (st_read_flush): likewise.
vport.c (sf_read_flush): likewise.
fports.h (struct scm_fport): remove random member. there's nothing
left but fdes. leaving it as a struct to allow for future changes.
fports.c: replace usage of scm_fport::random with scm_port::rw_random.
ports.c: (scm_putc, scm_puts, scm_lfwrite): call the read_flush
ptob proc if the read buffer is filled.
* ports.h (scm_port): add a rw_random member and replace
reading and writing members with rw_active member.
SCM_PORT_READ/SCM_PORT_WRITE: new values.
* ports.h (struct scm_port_table): add writing and reading members
to replace write_needs_seek: it isn't good enough for non-fports.
ports.c, ioext.c, fports.c: corresponding changes.
(struct scm_port_table): give it a typedef and rename to scm_port.
ports.c, fports.c, strports.c, vports.c, ioext.c, ports.h:
corresponding changes.
* ports.c (scm_newptob): bugfix: set seek member.
* * (scm_lseek): new procedure, using code from ioext.c:scm_fseek
and generalised to all port types.
* scmsigs.c (scm_init_scmsigs): set the SA_RESTART flag for all
signals (it was only being done for handlers installed from Scheme).
Otherwise (for example) SIGSTOP followed by SIGCONT on an interpreter
waiting for input caused an EINTR error from read.
* ports.h (struct scm_port_table): make all the char members
unsigned, so they convert to int without becoming negative if large.
* fports.c (scm_fdes_wait_for_input): forgot to check compilation
with threads enabled. rename this procedure to
fport_wait_for_input and take a port instead of a fdes.
use scm_fport_input_waiting_p instead of scm_fdes_waiting_p.
* readline.c (scm_readline): Applied a patch from Greg Harvey to
get readline support working again: use fdopen to get FILE objects.
* gc.c (scm_init_storage): install an atexit proc to flush the
ports.
(cleanup): the new proc. it sets a global variable which can be
checked by the ptob flush procs to avoid trying to throw
exceptions during exit. not very pleasant but it seems more reliable.
* fports.c (local_fflush): check terminating variable and if set
don't throw exception.
* CHECKME: that the atexit proc is installed if unexec used.
* throw.c (scm_handle_by_message): don't flush all ports here.
it still causes bus errors.
* fports.h (SCM_FPORT_CLEAR_BUFFERS): rename to SCM_CLEAR_BUFFERS
and move to ioext.c.
* fports.c (scm_fdes_waiting_p): merged into fport_input_waiting_p.
* ports.c (scm_char_ready_p): check the port buffer and call the
ptob entry if needed.
* ports.h (scm_ptobfuns): input_waiting_p added. change all the
ptob initialisers. use it in char-ready
* ioext.c (scm_do_read_line): moved from ports.c. make it static.
* vports.c (sfflush): modified to write a char (since softports
currently use shortbuf.)
* fports.c (scm_standard_stream_to_port): moved to init.c and
made static.
* init.c (scm_init_standard_ports): make stdout and stderr
unbuffered if connected to a terminal. with stdio they
were line-buffered by default.
* ports.h (scm_ptobfuns): change fflush return to void.
change flush proc definitions.
* strports.c (scm_call_with_output_string): get size from
buffer instead of port stream.
(scm_strprint_obj): likewise.
(st_flush): new proc.
* ports.h (struct scm_port_table): added write_end member,
as an optimisation. set it where write_buf_size is set.
* ports.h (struct scm_port_table): change stream from void *
back to SCM. SCM presumably must be large enough to hold a
pointer (and probably vice versa but who knows.)
(SCM_SSTREAM): deleted. change users back to SCM_STREAM.
(scm_puts): rewritten
* fports.c (local_ffwrite, local_fputs): removed.
* strports.c (stputc, stputs, stwrite): dyked out (FIXME)
* vports.c (sfputc, sfputs, sfwrite) likewise.
* ports.c (write_void_port, puts_void_port): removed.
(putc_void_port, getc_void_port, fgets_void_port): likewise.
* ports.c (scm_lfwrite): rewritten using fport.c version.
* fports.c (local_fputc): deleted.
* ports.c (scm_add_to_port_table): initialise write_needs_seek.
* ports.h (scm_ptobfuns): add seek function pointer.
* fports.c: set it to local_seek, new procedure.
* fports.h (SCM_MAYBE_DRAIN_INPUT): moved to ports.c.
use ptob for seek. take ptob instead of fport arg.
* ports.h (struct scm_port_table): new member write_needs_seek,
replaces reading member in fport struct.
* vports.c (sfgetc): store the getted char into the buffer.
rename to sf_fill_buffer and install it for fill-buffer in ptob.
the Scheme interface is still a procedure that gets a char.
(scm_make_soft_port): set up the port buffer (shortbuf).
* fports.c (local_fgetc, local_fgets): deleted.
* strports.c (stgetc): likewise.
* ports.c: scm_generic_fgets: likewise.
* ports.h (scm_ptobfuns): add fill_buffer.
* ports.c (scm_newptob): assign it.
* strports.c (scm_mkstrport): set up the buffer.
put just the string into the stream, not cons (pos stream).
(stfill_buffer): new proc.
* ports.h: fport buffer moved into port table: to be
used for all port types.
* throw.c (scm_handle_by_message): flush ports at exit.
* socket.c (scm_sock_fd_to_port): use scm_fdes_to_port.
(scm_getsockopt, scm_setsockopt, scm_shutdown, scm_connect,
scm_bind, scm_listen, scm_accept, scm_getsockname,
scm_getpeername, scm_recv, scm_send, scm_recvfrom,
scm_sendto,
use SCM_FPORT_FDES. use SCM_OPFPORTP not SCM_FPORTP.
* posix.c (scm_getgroups): use SCM_ALLOW/DEFER_INTS.
(scm_ttyname): use SCM_FPORT_FDES.
(scm_tcgetpgrp, scm_tcsetpgrp): likewise.
* ioext.c (scm_isatty_p): use SCM_FPORT_FDES.
(scm_fdes_to_ports): modified.
(scm_fdopen): use scm_fdes_to_port.
* ports.c (scm_init_ports): don't try to flush ports using
atexit(). it's too late, errors will cause SEGV.
* fports.c (scm_fport_buffer_add): new procedure.
* fports.h (SCM_FDES_RANDOM_P): new macro. use it in
scm_fdes_to_port and scm_redirect_port.
* ioext.c (scm_redirect_port): use setvbuf to set buffers in the
new port. reset fp->random.
* fports.c (scm_fdes_to_port), ports.c (scm_void_port),
filesys.c (scm_opendir):
restore defer interrupts while the port is constructed.
* (scm_setvbuf): if mode is _IOFBF and size is not supplied,
derive buffer size from fdes or use a default.
(scm_fdes_to_port): use setvbuf instead of creating the buffers
directly.
vports.c (various places): use SCM_SSTREAM.
strports.c: likewise.
* gdbint.c: likewise.
* ports.h (SCM_SSTREAM): new macro.
* fports.c (scm_input_waiting_p): use scm_return_first, since port
may be removed from the stack by the tail call to scm_fdes_waiting_p.
* fports.h (SCM_CLEAR_BUFFERS): new macro.
* ports.c (scm_force_output): call scm_fflush.
* print.c (scm_newline): don't check errno for EPIPE (it wouldn't
* reach this point.) don't flush port (if scm_cur_outp).
* fports.h (SCM_FPORT_FDES): new macro.
* vports.c (sfflush): don't need to set errno.
* ports.c: install scm_flush_all_ports to be run on exit.
ports.c fports.c ioext.c posix.c socket.c net_db.c filesys.c:
removed all uses of SCM_DEFER/ALLOW ints for now. they were mainly
just protecting errno. some may need to be put back.
* scmsigs.c (take_signal): save and restore errno while this
proc runs.
*fports.c (print_pipe_port, local_pclose, scm_pipob): deleted.
* open-pipe, close-pipe are emulated in (ice-9 popen)
ports.c (scm_ports_prehistory): don't init scm_pipob.
ports.h (scm_tc16_pipe): deleted.
posix.c (scm_open_pipe, scm_close_pipe): deleted.
* ioext.c (scm_primitive_move_to_fdes): use fport.
* fport.c (scm_fport_fill_buffer): flush write buffer if needed.
change arg type from scm_fport to SCM port.
fport.h (SCM_SETFDES): removed.
(SCM_MAYBE_DRAIN_INPUT): new macro.
* ioext.c (scm_dup_to_fdes): use SCM_FSTREAM.
(scm_ftell): always use lseek and account for the buffer.
(scm_fileno): use fport buffer.
(scm_fseek): clear fport buffers. always use lseek.
* posix.c (scm_pipe): use fport buffer.
* unif.c: include fports.h instead of genio.h.
* fports.c (scm_fdes_wait_for_input, scm_fport_fill_buffer): new
procedures.
(local_fgetc): use them.
(local_ffwrite): use buffer.
(local_fgets): use buffer.
(scm_setbuf0): deleted.
(scm_setvbuf): set the buffer.
(scm_setfileno): deleted.
(scm_evict_ports): set fdes directly.
* (scm_freopen): deleted. doesn't seem useful in Guile.
(scm_stdio_to_port): deleted.
fports.h (struct scm_fport): add shortbuf member to avoid separate
code for unbuffered ports.
(SCM_FPORTP, SCM_OPFPORTP, SCM_OPINFPORTP, SCM_OPOUTFPORTP): moved
from ports.h.
* genio.c, genio.h: move contents into ports.c, ports.h. The
division wasn't useful.
* fports.c, fports.h (scm_fport_drain_input): new procedure.
* ports.c (scm_drain_input): call scm_fport_drain_input.
* scm_fdes_waiting_p: new procedure.
* fports.c (scm_fdes_to_port): allocate read and/or write buffers.
(scm_input_waiting_p): check the buffer.
(local_fgetc, local_fflush, local_fputc): likewise.
* fports.h (scm_fport): read/write_buf,_pos,_buf_end,,_buf_size:
new members.
* init.c (scm_init_standard_ports): pass fdes instead of FILE *.
* * ports.c (scm_drain_input): new procedure.
ports.h: prototype.
* fports.c (FPORT_READ_SAFE, FPORT_WRITE_SAFE, FPORT_ALL_OKAY,
pre_read, pre_write): removed.
(local_fputc, local_fputs, local_ffwrite): use write, not stdio.
(scm_standard_stream_to_port): change first arg from FILE * to
int fdes.
(local_fflush): flush fdes, not FILE *.
* fports.h (SCM_NOFTELL): removed.
* genio.c, ports.c: don't include filesys.h.
* genio.c (scm_getc): don't use scm_internal_select if FPORT.
do it in fports.c:local_fgetc.
* genio.c: don't use SCM_SYSCALL when calling ptob procedures.
do it where it's needed in the port smobs.
* filesys.c (scm_input_waiting_p): moved to fports.c, stdio
buffer support removed. take SCM arg, not FILE *.
* filesys.h: prototype moved too.
* fports.c (scm_fdes_to_port): new procedure.
(local_fgetc): use read not fgetc.
(local_fclose): use close, not fclose.
(local_fgets): use read, not fgets
* fports.h: prototype for scm_fdes_to_port.
* fports.h (scm_fport): new struct.
* fports.c (scm_open_file): use open, not fopen.
#include fcntl.h
* ports.h (struct scm_port_table): change stream from SCM to void *.
* ports.c (scm_add_to_port_table): check for memory allocation error.
(scm_prinport): remove MSDOS hair.
(scm_void_port): set stream to 0 instead of SCM_BOOL_F.
(scm_close_port): don't throw errors: do it in fports.c.
they get passed the port object, not the port's stream.
* ports.h (scm_ptobfuns): Rename all `stream' arguments to `port'.
* gc.c (scm_gc_sweep): Pass the port itself to the free function.
* genio.c (scm_putc, scm_puts, scm_lfwrite, scm_fflush, scm_getc):
Pass the port itself to the scm_ptobs function.
* ports.c (scm_close_port, scm_force_output, scm_flush_all_ports,
scm_generic_fgets): Same.
(putc_void_port, puts_void_port, write_void_port, flush_void_port,
getc_void_port, fgets_void_port, close_void_port): Just change the
argument names; these functions don't really do anything.
* fports.c (local_fgetc, local_fgets, local_fclose, local_fflush,
local_fputc, local_fputs, local_ffwrite, local_pclose): Take the
port as an argument, and use SCM_STREAM to get the stdio FILE *.
Also, use prototyped definitions, and get rid of the extra
declarations.
(scm_fptob, scm_pipob): We don't need casts here any more.
* strports.c (prinstpt): Use prototype declarations.
(stputc, stwrite, stputs, stgetc): Take the port as an argument,
and use SCM_STREAM to get the string info. Also, use prototyped
definitions, and get rid of the extra declarations.
* vports.c (sfputc, sfwrite, sfputs, sfflush, sfgetc, sfclose,
noop0): Same.
Added #include "objects.h"
* eval.c (scm_makprom): Added SCM_DEFER_INTS and SCM_ALLOW_INTS.
Add #include "feature.h".
* ports.h (SCM_EOF_OBJECT_P): New macro predicate.
This test is needed at many places in the code and should be
abstracted. (Motivated by the need of this test in libguiletk.)
* ports.c (scm_eof_object_p), vports.c (sfgetc), strports.c
(scm_eval_string), load.c (scm_primitive_load,
scm_read_and_eval_x), gh_eval.c (gh_eval_str):
Use SCM_EOF_OBJECT_P.
* eval.c (scm_init_eval): Add feature `delay'.
* gdbint.c (gdb_read): update scm_lreadr usage.
* load.h: update prototypes.
* load.c (scm_primitive_load, scm_read_and_eval_x,
scm_primitive_load_path): remove case_insensitive_p, sharp arguments.
* read.h: add prototype for scm_read_hash_extend. Change args for
other prototypes.
* read.c (scm_read_hash_procedures): new variable.
(scm_read_hash_extend): new procedure.
(scm_get_hash_procedure): new procedure.
* (scm_lreadr): use scm_get_hash_procedure instead of an argument
for extended # processing.
(scm_read, scm_lreadr, scm_lreadrecparen, scm_lreadparen,
scm_read_token): remove case_i, sharp arguments. Change callers.
* read.h (SCM_N_READ_OPTIONS): increase to 3.
(SCM_CASE_INSENSITIVE_P): define.
* read.c: add case-insensitive option to scm_read_opts.
* (scm_read_token): use SCM_CASE_INSENSITIVE_P instead of an argument
to determine whether to convert symbol case.
(default_case_i): definition removed.
* read.c (scm_read_token): if case_i, downcase ic before doing
anything with it.
eval.h, feature.c, filesys.c, fports.c, gc.c, gsubr.c, init.c,
ioext.c, kw.c, list.c, load.c, mallocs.c, numbers.c, numbers.h,
pairs.c, pairs.h, ports.c, ports.h, posix.c, procprop.c, procs.c,
procs.h, ramap.c, read.c, root.c, srcprop.c, srcprop.h,
strports.c, symbols.c, tags.h, throw.c, unif.c, variable.c,
vports.c: Cleaned up use of pairs: Don't make any special
assumptions about the internal structure of selectors and
mutators: SCM_CXR (<e1>) = <e2> --> SCM_SETCXR (<e1>, <e2>),
SCM_CXR (<e1>) &= <e2> --> SCM_SETAND_CXR (<e1>, <e2>) etc.
(Among other things, this change makes it easier to build Guile
with certain compilers which have problems with casted lvalues.)
