#endif
#endif
-/* Whether we're using Guile < 2.2 and its clumsy port API. */
-
-#define USING_GUILE_BEFORE_2_2 \
- (SCM_MAJOR_VERSION == 2 && SCM_MINOR_VERSION == 0)
-
-
/* A ui-file for sending output to Guile. */
class ioscm_file_port : public ui_file
/* Think of this as the lseek value maintained by the kernel.
This value is always in the range [0, size]. */
ULONGEST current;
-
-#if USING_GUILE_BEFORE_2_2
- /* The size of the internal r/w buffers.
- Scheme ports aren't a straightforward mapping to memory r/w.
- Generally the user specifies how much to r/w and all access is
- unbuffered. We don't try to provide equivalent access, but we allow
- the user to specify these values to help get something similar. */
- unsigned read_buf_size, write_buf_size;
-#endif
};
/* Copies of the original system input/output/error ports.
static SCM orig_error_port_scm;
/* This is the stdio port descriptor, scm_ptob_descriptor. */
-#if USING_GUILE_BEFORE_2_2
-static scm_t_bits stdio_port_desc;
-#else
static scm_t_port_type *stdio_port_desc;
-#endif
/* Note: scm_make_port_type takes a char * instead of a const char *. */
static /*const*/ char stdio_port_desc_name[] = "gdb:stdio-port";
enum oport { GDB_STDOUT, GDB_STDERR };
/* This is the memory port descriptor, scm_ptob_descriptor. */
-#if USING_GUILE_BEFORE_2_2
-static scm_t_bits memory_port_desc;
-#else
static scm_t_port_type *memory_port_desc;
-#endif
/* Note: scm_make_port_type takes a char * instead of a const char *. */
static /*const*/ char memory_port_desc_name[] = "gdb:memory-port";
-#if USING_GUILE_BEFORE_2_2
-
-/* The default amount of memory to fetch for each read/write request.
- Scheme ports don't provide a way to specify the size of a read,
- which is important to us to minimize the number of inferior interactions,
- which over a remote link can be important. To compensate we augment the
- port API with a new function that let's the user specify how much the next
- read request should fetch. This is the initial value for each new port. */
-static const unsigned default_read_buf_size = 16;
-static const unsigned default_write_buf_size = 16;
-
-/* Arbitrarily limit memory port buffers to 1 byte to 4K. */
-static const unsigned min_memory_port_buf_size = 1;
-static const unsigned max_memory_port_buf_size = 4096;
-
-/* "out of range" error message for buf sizes. */
-static gdb::unique_xmalloc_ptr<char> out_of_range_buf_size;
-
-#else
-
/* The maximum values to use for get_natural_buffer_sizes. */
static const unsigned natural_buf_size = 16;
-#endif
-
/* Keywords used by open-memory. */
static SCM mode_keyword;
static SCM start_keyword;
\f
/* Helper to do the low level work of opening a port. */
-#if USING_GUILE_BEFORE_2_2
-
-static SCM
-ioscm_open_port (scm_t_bits port_type, long mode_bits, scm_t_bits stream)
-{
- SCM port;
-
-#if 0 /* TODO: Guile doesn't export this. What to do? */
- scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex);
-#endif
-
- port = scm_new_port_table_entry (port_type);
-
- SCM_SET_CELL_TYPE (port, port_type | mode_bits);
- SCM_SETSTREAM (port, stream);
-
-#if 0 /* TODO: Guile doesn't export this. What to do? */
- scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex);
-#endif
-
- return port;
-}
-
-#else
-
static SCM
ioscm_open_port (scm_t_port_type *port_type, long mode_bits, scm_t_bits stream)
{
return scm_c_make_port (port_type, mode_bits, stream);
}
-#endif
-
\f
/* Support for connecting Guile's stdio ports to GDB's stdio ports. */
}
}
-#if USING_GUILE_BEFORE_2_2
-
-/* The scm_t_ptob_descriptor.input_waiting "method".
- Return a lower bound on the number of bytes available for input. */
-
-static int
-ioscm_input_waiting (SCM port)
-{
- int fdes = 0;
-
- if (! scm_is_eq (port, input_port_scm))
- return 0;
-
-#ifdef HAVE_POLL
- {
- /* This is copied from libguile/fports.c. */
- struct pollfd pollfd = { fdes, POLLIN, 0 };
- static int use_poll = -1;
-
- if (use_poll < 0)
- {
- /* This is copied from event-loop.c: poll cannot be used for stdin on
- m68k-motorola-sysv. */
- struct pollfd test_pollfd = { fdes, POLLIN, 0 };
-
- if (poll (&test_pollfd, 1, 0) == 1 && (test_pollfd.revents & POLLNVAL))
- use_poll = 0;
- else
- use_poll = 1;
- }
-
- if (use_poll)
- {
- /* Guile doesn't export SIGINT hooks like Python does.
- For now pass EINTR to scm_syserror, that's what fports.c does. */
- if (poll (&pollfd, 1, 0) < 0)
- scm_syserror (FUNC_NAME);
-
- return pollfd.revents & POLLIN ? 1 : 0;
- }
- }
- /* Fall through. */
-#endif
-
- {
- struct timeval timeout;
- fd_set input_fds;
- int num_fds = fdes + 1;
- int num_found;
-
- memset (&timeout, 0, sizeof (timeout));
- FD_ZERO (&input_fds);
- FD_SET (fdes, &input_fds);
-
- num_found = interruptible_select (num_fds,
- &input_fds, NULL, NULL,
- &timeout);
- if (num_found < 0)
- {
- /* Guile doesn't export SIGINT hooks like Python does.
- For now pass EINTR to scm_syserror, that's what fports.c does. */
- scm_syserror (FUNC_NAME);
- }
- return num_found > 0 && FD_ISSET (fdes, &input_fds);
- }
-}
-
-/* The scm_t_ptob_descriptor.fill_input "method". */
-
-static int
-ioscm_fill_input (SCM port)
-{
- /* Borrowed from libguile/fports.c. */
- long count;
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
-
- /* If we're called on stdout,stderr, punt. */
- if (! scm_is_eq (port, input_port_scm))
- return (scm_t_wchar) EOF; /* Set errno and return -1? */
-
- gdb_flush (gdb_stdout);
- gdb_flush (gdb_stderr);
-
- count = gdb_stdin->read ((char *) pt->read_buf, pt->read_buf_size);
- if (count == -1)
- scm_syserror (FUNC_NAME);
- if (count == 0)
- return (scm_t_wchar) EOF;
-
- pt->read_pos = pt->read_buf;
- pt->read_end = pt->read_buf + count;
- return *pt->read_buf;
-}
-
-/* Write to gdb's stdout or stderr. */
-
-static void
-ioscm_write (SCM port, const void *data, size_t size)
-{
-
- /* If we're called on stdin, punt. */
- if (scm_is_eq (port, input_port_scm))
- return;
-
- gdbscm_gdb_exception exc {};
- try
- {
- if (scm_is_eq (port, error_port_scm))
- fputsn_filtered ((const char *) data, size, gdb_stderr);
- else
- fputsn_filtered ((const char *) data, size, gdb_stdout);
- }
- catch (const gdb_exception &except)
- {
- exc = unpack (except);
- }
- GDBSCM_HANDLE_GDB_EXCEPTION (exc);
-}
-
-/* Flush gdb's stdout or stderr. */
-
-static void
-ioscm_flush (SCM port)
-{
- /* If we're called on stdin, punt. */
- if (scm_is_eq (port, input_port_scm))
- return;
-
- if (scm_is_eq (port, error_port_scm))
- {
- if (gdb_stderr != nullptr)
- gdb_flush (gdb_stderr);
- }
- else
- {
- if (gdb_stdout != nullptr)
- gdb_flush (gdb_stdout);
- }
-}
-
-#else /* !USING_GUILE_BEFORE_2_2 */
-
/* Read up to COUNT bytes into bytevector DST at offset START. Return the
number of bytes read, zero for the end of file. */
return count;
}
-#endif /* !USING_GUILE_BEFORE_2_2 */
-
/* Initialize the gdb stdio port type.
N.B. isatty? will fail on these ports, it is only supported for file
ioscm_init_gdb_stdio_port (void)
{
stdio_port_desc = scm_make_port_type (stdio_port_desc_name,
-#if USING_GUILE_BEFORE_2_2
- ioscm_fill_input,
-#else
ioscm_read_from_port,
-#endif
ioscm_write);
-#if USING_GUILE_BEFORE_2_2
- scm_set_port_input_waiting (stdio_port_desc, ioscm_input_waiting);
- scm_set_port_flush (stdio_port_desc, ioscm_flush);
-#else
scm_set_port_read_wait_fd (stdio_port_desc, STDIN_FILENO);
-#endif
}
#define GDB_STDIO_BUFFER_DEFAULT_SIZE 1024
-#if USING_GUILE_BEFORE_2_2
-
-/* Subroutine of ioscm_make_gdb_stdio_port to simplify it.
- Set up the buffers of port PORT.
- MODE_BITS are the mode bits of PORT. */
-
-static void
-ioscm_init_stdio_buffers (SCM port, long mode_bits)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- int size = mode_bits & SCM_BUF0 ? 0 : GDB_STDIO_BUFFER_DEFAULT_SIZE;
- int writing = (mode_bits & SCM_WRTNG) != 0;
-
- /* This is heavily copied from scm_fport_buffer_add. */
-
- if (!writing && size > 0)
- {
- pt->read_buf
- = (unsigned char *) scm_gc_malloc_pointerless (size, "port buffer");
- pt->read_pos = pt->read_end = pt->read_buf;
- pt->read_buf_size = size;
- }
- else
- {
- pt->read_pos = pt->read_buf = pt->read_end = &pt->shortbuf;
- pt->read_buf_size = 1;
- }
-
- if (writing && size > 0)
- {
- pt->write_buf
- = (unsigned char *) scm_gc_malloc_pointerless (size, "port buffer");
- pt->write_pos = pt->write_buf;
- pt->write_buf_size = size;
- }
- else
- {
- pt->write_buf = pt->write_pos = &pt->shortbuf;
- pt->write_buf_size = 1;
- }
- pt->write_end = pt->write_buf + pt->write_buf_size;
-}
-
-#else
-
static void
ioscm_init_stdio_buffers (SCM port, long mode_bits)
{
scm_from_size_t (GDB_STDIO_BUFFER_DEFAULT_SIZE));
}
-#endif
-
/* Create a gdb stdio port. */
static SCM
static SCM
gdbscm_stdio_port_p (SCM scm)
{
-#if USING_GUILE_BEFORE_2_2
- /* This is copied from SCM_FPORTP. */
- return scm_from_bool (!SCM_IMP (scm)
- && (SCM_TYP16 (scm) == stdio_port_desc));
-#else
return scm_from_bool (SCM_PORTP (scm)
&& (SCM_PORT_TYPE (scm) == stdio_port_desc));
-#endif
}
\f
/* GDB's ports are accessed via functions to keep them read-only. */
return 1;
}
-#if USING_GUILE_BEFORE_2_2
-
-/* "fill_input" method for memory ports. */
-
-static int
-gdbscm_memory_port_fill_input (SCM port)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
- size_t to_read;
-
- /* "current" is the offset of the first byte we want to read. */
- gdb_assert (iomem->current <= iomem->size);
- if (iomem->current == iomem->size)
- return EOF;
-
- /* Don't read outside the allowed memory range. */
- to_read = pt->read_buf_size;
- if (to_read > iomem->size - iomem->current)
- to_read = iomem->size - iomem->current;
-
- if (target_read_memory (iomem->start + iomem->current, pt->read_buf,
- to_read) != 0)
- gdbscm_memory_error (FUNC_NAME, _("error reading memory"), SCM_EOL);
-
- iomem->current += to_read;
- pt->read_pos = pt->read_buf;
- pt->read_end = pt->read_buf + to_read;
- return *pt->read_buf;
-}
-
-/* "end_input" method for memory ports.
- Clear the read buffer and adjust the file position for unread bytes. */
-
-static void
-gdbscm_memory_port_end_input (SCM port, int offset)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
- size_t remaining = pt->read_end - pt->read_pos;
-
- /* Note: Use of "int offset" is specified by Guile ports API. */
- if ((offset < 0 && remaining + offset > remaining)
- || (offset > 0 && remaining + offset < remaining))
- {
- gdbscm_out_of_range_error (FUNC_NAME, 0, scm_from_int (offset),
- _("overflow in offset calculation"));
- }
- offset += remaining;
-
- if (offset > 0)
- {
- pt->read_pos = pt->read_end;
- /* Throw error if unread-char used at beginning of file
- then attempting to write. Seems correct. */
- if (!ioscm_lseek_address (iomem, -offset, SEEK_CUR))
- {
- gdbscm_out_of_range_error (FUNC_NAME, 0, scm_from_int (offset),
- _("bad offset"));
- }
- }
-
- pt->rw_active = SCM_PORT_NEITHER;
-}
-
-/* "flush" method for memory ports. */
-
-static void
-gdbscm_memory_port_flush (SCM port)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
- size_t to_write = pt->write_pos - pt->write_buf;
-
- if (to_write == 0)
- return;
-
- /* There's no way to indicate a short write, so if the request goes past
- the end of the port's memory range, flag an error. */
- if (to_write > iomem->size - iomem->current)
- {
- gdbscm_out_of_range_error (FUNC_NAME, 0,
- gdbscm_scm_from_ulongest (to_write),
- _("writing beyond end of memory range"));
- }
-
- if (target_write_memory (iomem->start + iomem->current, pt->write_buf,
- to_write) != 0)
- gdbscm_memory_error (FUNC_NAME, _("error writing memory"), SCM_EOL);
-
- iomem->current += to_write;
- pt->write_pos = pt->write_buf;
- pt->rw_active = SCM_PORT_NEITHER;
-}
-
-/* "seek" method for memory ports. */
-
-static scm_t_off
-gdbscm_memory_port_seek (SCM port, scm_t_off offset, int whence)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
- CORE_ADDR result;
- int rc;
-
- if (pt->rw_active == SCM_PORT_WRITE)
- {
- if (offset != 0 || whence != SEEK_CUR)
- {
- gdbscm_memory_port_flush (port);
- rc = ioscm_lseek_address (iomem, offset, whence);
- result = iomem->current;
- }
- else
- {
- /* Read current position without disturbing the buffer,
- but flag an error if what's in the buffer goes outside the
- allowed range. */
- CORE_ADDR current = iomem->current;
- size_t delta = pt->write_pos - pt->write_buf;
-
- if (current + delta < current
- || current + delta > iomem->size)
- rc = 0;
- else
- {
- result = current + delta;
- rc = 1;
- }
- }
- }
- else if (pt->rw_active == SCM_PORT_READ)
- {
- if (offset != 0 || whence != SEEK_CUR)
- {
- scm_end_input (port);
- rc = ioscm_lseek_address (iomem, offset, whence);
- result = iomem->current;
- }
- else
- {
- /* Read current position without disturbing the buffer
- (particularly the unread-char buffer). */
- CORE_ADDR current = iomem->current;
- size_t remaining = pt->read_end - pt->read_pos;
-
- if (current - remaining > current
- || current - remaining < iomem->start)
- rc = 0;
- else
- {
- result = current - remaining;
- rc = 1;
- }
-
- if (rc != 0 && pt->read_buf == pt->putback_buf)
- {
- size_t saved_remaining = pt->saved_read_end - pt->saved_read_pos;
-
- if (result - saved_remaining > result
- || result - saved_remaining < iomem->start)
- rc = 0;
- else
- result -= saved_remaining;
- }
- }
- }
- else /* SCM_PORT_NEITHER */
- {
- rc = ioscm_lseek_address (iomem, offset, whence);
- result = iomem->current;
- }
-
- if (rc == 0)
- {
- gdbscm_out_of_range_error (FUNC_NAME, 0,
- gdbscm_scm_from_longest (offset),
- _("bad seek"));
- }
-
- /* TODO: The Guile API doesn't support 32x64. We can't fix that here,
- and there's no need to throw an error if the new address can't be
- represented in a scm_t_off. But we could return something less
- clumsy. */
- return result;
-}
-
-/* "write" method for memory ports. */
-
-static void
-gdbscm_memory_port_write (SCM port, const void *void_data, size_t size)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
- const gdb_byte *data = (const gdb_byte *) void_data;
-
- /* There's no way to indicate a short write, so if the request goes past
- the end of the port's memory range, flag an error. */
- if (size > iomem->size - iomem->current)
- {
- gdbscm_out_of_range_error (FUNC_NAME, 0, gdbscm_scm_from_ulongest (size),
- _("writing beyond end of memory range"));
- }
-
- if (pt->write_buf == &pt->shortbuf)
- {
- /* Unbuffered port. */
- if (target_write_memory (iomem->start + iomem->current, data, size) != 0)
- gdbscm_memory_error (FUNC_NAME, _("error writing memory"), SCM_EOL);
- iomem->current += size;
- return;
- }
-
- /* Note: The edge case of what to do when the buffer exactly fills is
- debatable. Guile flushes when the buffer exactly fills up, so we
- do too. It's counter-intuitive to my mind, but in case there's a
- subtlety somewhere that depends on this, we do the same. */
-
- {
- size_t space = pt->write_end - pt->write_pos;
-
- if (size < space)
- {
- /* Data fits in buffer, and does not fill it. */
- memcpy (pt->write_pos, data, size);
- pt->write_pos += size;
- }
- else
- {
- memcpy (pt->write_pos, data, space);
- pt->write_pos = pt->write_end;
- gdbscm_memory_port_flush (port);
- {
- const gdb_byte *ptr = data + space;
- size_t remaining = size - space;
-
- if (remaining >= pt->write_buf_size)
- {
- if (target_write_memory (iomem->start + iomem->current, ptr,
- remaining) != 0)
- gdbscm_memory_error (FUNC_NAME, _("error writing memory"),
- SCM_EOL);
- iomem->current += remaining;
- }
- else
- {
- memcpy (pt->write_pos, ptr, remaining);
- pt->write_pos += remaining;
- }
- }
- }
- }
-}
-
-/* "close" method for memory ports. */
-
-static int
-gdbscm_memory_port_close (SCM port)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
-
- gdbscm_memory_port_flush (port);
-
- if (pt->read_buf == pt->putback_buf)
- pt->read_buf = pt->saved_read_buf;
- if (pt->read_buf != &pt->shortbuf)
- xfree (pt->read_buf);
- if (pt->write_buf != &pt->shortbuf)
- xfree (pt->write_buf);
- scm_gc_free (iomem, sizeof (*iomem), "memory port");
-
- return 0;
-}
-
-/* "free" method for memory ports. */
-
-static size_t
-gdbscm_memory_port_free (SCM port)
-{
- gdbscm_memory_port_close (port);
-
- return 0;
-}
-
-/* Re-initialize a memory port, updating its read/write buffer sizes.
- An exception is thrown if the port is unbuffered.
- TODO: Allow switching buffered/unbuffered.
- An exception is also thrown if data is still buffered, except in the case
- where the buffer size isn't changing (since that's just a nop). */
-
-static void
-ioscm_reinit_memory_port (SCM port, size_t read_buf_size,
- size_t write_buf_size, const char *func_name)
-{
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
-
- gdb_assert (read_buf_size >= min_memory_port_buf_size
- && read_buf_size <= max_memory_port_buf_size);
- gdb_assert (write_buf_size >= min_memory_port_buf_size
- && write_buf_size <= max_memory_port_buf_size);
-
- /* First check if the port is unbuffered. */
-
- if (pt->read_buf == &pt->shortbuf)
- {
- gdb_assert (pt->write_buf == &pt->shortbuf);
- scm_misc_error (func_name, _("port is unbuffered: ~a"),
- scm_list_1 (port));
- }
-
- /* Next check if anything is buffered. */
-
- if (read_buf_size != pt->read_buf_size
- && pt->read_end != pt->read_buf)
- {
- scm_misc_error (func_name, _("read buffer not empty: ~a"),
- scm_list_1 (port));
- }
-
- if (write_buf_size != pt->write_buf_size
- && pt->write_pos != pt->write_buf)
- {
- scm_misc_error (func_name, _("write buffer not empty: ~a"),
- scm_list_1 (port));
- }
-
- /* Now we can update the buffer sizes, but only if the size has changed. */
-
- if (read_buf_size != pt->read_buf_size)
- {
- iomem->read_buf_size = read_buf_size;
- pt->read_buf_size = read_buf_size;
- xfree (pt->read_buf);
- pt->read_buf = (unsigned char *) xmalloc (pt->read_buf_size);
- pt->read_pos = pt->read_end = pt->read_buf;
- }
-
- if (write_buf_size != pt->write_buf_size)
- {
- iomem->write_buf_size = write_buf_size;
- pt->write_buf_size = write_buf_size;
- xfree (pt->write_buf);
- pt->write_buf = (unsigned char *) xmalloc (pt->write_buf_size);
- pt->write_pos = pt->write_buf;
- pt->write_end = pt->write_buf + pt->write_buf_size;
- }
-}
-
-#else /* !USING_GUILE_BEFORE_2_2 */
-
/* The semantics get weird if the buffer size is larger than the port range,
so provide a better default buffer size. */
SCM_SETSTREAM (port, NULL);
}
-#endif /* !USING_GUILE_BEFORE_2_2 */
-
/* "print" method for memory ports. */
static int
ioscm_init_memory_port_type (void)
{
memory_port_desc = scm_make_port_type (memory_port_desc_name,
-#if USING_GUILE_BEFORE_2_2
- gdbscm_memory_port_fill_input,
-#else
gdbscm_memory_port_read,
-#endif
gdbscm_memory_port_write);
-#if USING_GUILE_BEFORE_2_2
- scm_set_port_end_input (memory_port_desc, gdbscm_memory_port_end_input);
- scm_set_port_flush (memory_port_desc, gdbscm_memory_port_flush);
- scm_set_port_free (memory_port_desc, gdbscm_memory_port_free);
-#else
scm_set_port_get_natural_buffer_sizes (memory_port_desc,
gdbscm_get_natural_buffer_sizes);
-#endif
scm_set_port_seek (memory_port_desc, gdbscm_memory_port_seek);
scm_set_port_close (memory_port_desc, gdbscm_memory_port_close);
scm_set_port_print (memory_port_desc, gdbscm_memory_port_print);
return iomem;
}
-#if USING_GUILE_BEFORE_2_2
-
-/* Helper for gdbscm_open_memory to finish initializing the port.
- The port has address range [start,end).
- This means that address of 0xff..ff is not accessible.
- I can live with that. */
-
-static void
-ioscm_init_memory_port_buffers (SCM port)
-{
- ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (port);
-
- int buffered = (SCM_CELL_WORD_0 (port) & SCM_BUF0) == 0;
- if (buffered)
- {
- iomem->read_buf_size = default_read_buf_size;
- iomem->write_buf_size = default_write_buf_size;
- }
- else
- {
- iomem->read_buf_size = 1;
- iomem->write_buf_size = 1;
- }
-
- scm_t_port *pt = SCM_PTAB_ENTRY (port);
- /* Match the expectation of `binary-port?'. */
- pt->encoding = NULL;
- pt->rw_random = 1;
- pt->read_buf_size = iomem->read_buf_size;
- pt->write_buf_size = iomem->write_buf_size;
- if (buffered)
- {
- pt->read_buf = (unsigned char *) xmalloc (pt->read_buf_size);
- pt->write_buf = (unsigned char *) xmalloc (pt->write_buf_size);
- }
- else
- {
- pt->read_buf = &pt->shortbuf;
- pt->write_buf = &pt->shortbuf;
- }
- pt->read_pos = pt->read_end = pt->read_buf;
- pt->write_pos = pt->write_buf;
- pt->write_end = pt->write_buf + pt->write_buf_size;
-}
-
-#endif
-
/* (open-memory [#:mode string] [#:start address] [#:size integer]) -> port
Return a port that can be used for reading and writing memory.
MODE is a string, and must be one of "r", "w", or "r+".
port = ioscm_open_port (memory_port_desc, mode_bits,
(scm_t_bits) stream);
-#if USING_GUILE_BEFORE_2_2
- ioscm_init_memory_port_buffers (port);
-#endif
-
scm_dynwind_end ();
/* TODO: Set the file name as "memory-start-end"? */
static int
gdbscm_is_memory_port (SCM obj)
{
-#if USING_GUILE_BEFORE_2_2
- return !SCM_IMP (obj) && (SCM_TYP16 (obj) == memory_port_desc);
-#else
return SCM_PORTP (obj) && (SCM_PORT_TYPE (obj) == memory_port_desc);
-#endif
}
/* (memory-port? obj) -> boolean */
static SCM
gdbscm_memory_port_read_buffer_size (SCM port)
{
-#if USING_GUILE_BEFORE_2_2
- ioscm_memory_port *iomem;
-
- SCM_ASSERT_TYPE (gdbscm_is_memory_port (port), port, SCM_ARG1, FUNC_NAME,
- memory_port_desc_name);
-
- iomem = (ioscm_memory_port *) SCM_STREAM (port);
- return scm_from_uint (iomem->read_buf_size);
-#else
return scm_from_uint (0);
-#endif
}
/* (set-memory-port-read-buffer-size! port size) -> unspecified
static SCM
gdbscm_set_memory_port_read_buffer_size_x (SCM port, SCM size)
{
-#if USING_GUILE_BEFORE_2_2
- ioscm_memory_port *iomem;
-
- SCM_ASSERT_TYPE (gdbscm_is_memory_port (port), port, SCM_ARG1, FUNC_NAME,
- memory_port_desc_name);
- SCM_ASSERT_TYPE (scm_is_integer (size), size, SCM_ARG2, FUNC_NAME,
- _("integer"));
-
- if (!scm_is_unsigned_integer (size, min_memory_port_buf_size,
- max_memory_port_buf_size))
- {
- gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, size,
- out_of_range_buf_size.get ());
- }
-
- iomem = (ioscm_memory_port *) SCM_STREAM (port);
- ioscm_reinit_memory_port (port, scm_to_uint (size), iomem->write_buf_size,
- FUNC_NAME);
-
- return SCM_UNSPECIFIED;
-#else
return scm_setvbuf (port, scm_from_utf8_symbol ("block"), size);
-#endif
}
/* (memory-port-write-buffer-size port) -> integer */
static SCM
gdbscm_memory_port_write_buffer_size (SCM port)
{
-#if USING_GUILE_BEFORE_2_2
- ioscm_memory_port *iomem;
-
- SCM_ASSERT_TYPE (gdbscm_is_memory_port (port), port, SCM_ARG1, FUNC_NAME,
- memory_port_desc_name);
-
- iomem = (ioscm_memory_port *) SCM_STREAM (port);
- return scm_from_uint (iomem->write_buf_size);
-#else
return scm_from_uint (0);
-#endif
}
/* (set-memory-port-write-buffer-size! port size) -> unspecified
static SCM
gdbscm_set_memory_port_write_buffer_size_x (SCM port, SCM size)
{
-#if USING_GUILE_BEFORE_2_2
- ioscm_memory_port *iomem;
-
- SCM_ASSERT_TYPE (gdbscm_is_memory_port (port), port, SCM_ARG1, FUNC_NAME,
- memory_port_desc_name);
- SCM_ASSERT_TYPE (scm_is_integer (size), size, SCM_ARG2, FUNC_NAME,
- _("integer"));
-
- if (!scm_is_unsigned_integer (size, min_memory_port_buf_size,
- max_memory_port_buf_size))
- {
- gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, size,
- out_of_range_buf_size.get ());
- }
-
- iomem = (ioscm_memory_port *) SCM_STREAM (port);
- ioscm_reinit_memory_port (port, iomem->read_buf_size, scm_to_uint (size),
- FUNC_NAME);
-
- return SCM_UNSPECIFIED;
-#else
return scm_setvbuf (port, scm_from_utf8_symbol ("block"), size);
-#endif
}
\f
/* Initialize gdb ports. */
start_keyword = scm_from_latin1_keyword ("start");
size_keyword = scm_from_latin1_keyword ("size");
-#if USING_GUILE_BEFORE_2_2
- /* Error message text for "out of range" memory port buffer sizes. */
-
- out_of_range_buf_size = xstrprintf ("size not between %u - %u",
- min_memory_port_buf_size,
- max_memory_port_buf_size);
-#endif
}
projects / thirdparty / binutils-gdb.git / commitdiff
