/* Return a new port of type PORT_TYPE. */
static inline SCM
make_port (scm_t_bits port_type)
{
SCM port;
char *c_buffer;
scm_t_port *c_port;
c_buffer = scm_gc_calloc (PORT_BUFFER_SIZE, "custom-port-buffer");
port = scm_new_port_table_entry (port_type);
/* Associate C_BUFFER with PORT, for test purposes. */
SCM_SETSTREAM (port, (scm_t_bits) c_buffer);
/* Use C_BUFFER as PORT's internal buffer. */
c_port = SCM_PTAB_ENTRY (port);
c_port->read_pos = c_port->read_buf = (unsigned char *) c_buffer;
c_port->read_end = (unsigned char *) c_buffer + PORT_BUFFER_SIZE;
c_port->read_buf_size = PORT_BUFFER_SIZE;
/* Mark PORT as open and readable. */
SCM_SET_CELL_TYPE (port, port_type | SCM_OPN | SCM_RDNG);
return port;
}
static void
ioscm_init_memory_port (SCM port, CORE_ADDR start, CORE_ADDR end)
{
scm_t_port *pt;
ioscm_memory_port *iomem;
int buffered = (SCM_CELL_WORD_0 (port) & SCM_BUF0) == 0;
gdb_assert (start <= end);
iomem = (ioscm_memory_port *) scm_gc_malloc_pointerless (sizeof (*iomem),
"memory port");
iomem->start = start;
iomem->end = end;
iomem->size = end - start;
iomem->current = 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;
}
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;
SCM_SETSTREAM (port, iomem);
}
static int
mu_port_close (SCM port)
{
struct mu_port *mp = MU_PORT (port);
scm_port *pt = SCM_PTAB_ENTRY (port);
mu_port_flush (port);
mu_stream_close (mp->stream);
SCM_SETSTREAM (port, NULL);
if (pt->read_buf != &pt->shortbuf)
free (pt->read_buf);
if (pt->write_buf != &pt->shortbuf)
free (pt->write_buf);
free (mp);
return 0;
}
SCM
mu_port_make_from_stream (SCM msg, mu_stream_t stream, long mode)
{
struct mu_port *mp;
SCM port;
scm_port *pt;
mp = scm_gc_malloc (sizeof (struct mu_port), "mu-port");
mp->msg = msg;
mp->stream = stream;
mp->offset = 0;
port = scm_new_port_table_entry (scm_tc16_smuport | mode);
pt = SCM_PTAB_ENTRY (port);
pt->rw_random = mu_stream_is_seekable (stream);
SCM_SETSTREAM (port, mp);
mu_port_alloc_buffer (port, 0, 0);
/* FIXME:
SCM_PTAB_ENTRY (port)->file_name = "name";*/
return port;
}
static int
#else
static void
#endif
ptob_close (SCM channel)
{
struct channel_data *ch = _scm_to_channel_data (channel);
#if USING_GUILE_BEFORE_2_2
scm_port *pt = SCM_PTAB_ENTRY (channel);
ptob_flush (channel);
#endif
if (ch && ssh_channel_is_open (ch->ssh_channel))
{
_gssh_log_debug ("ptob_close", "closing and freeing the channel...",
channel);
ssh_channel_close (ch->ssh_channel);
ssh_channel_free (ch->ssh_channel);
_gssh_log_debug1 ("ptob_close", "closing and freeing the channel... done");
}
else
{
_gssh_log_debug1 ("ptob_close", "the channel is already freeed.");
}
SCM_SETSTREAM (channel, NULL);
#if USING_GUILE_BEFORE_2_2
scm_gc_free (pt->write_buf, pt->write_buf_size, "port write buffer");
scm_gc_free (pt->read_buf, pt->read_buf_size, "port read buffer");
return 0;
#endif
}
