[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 05/07: Port buffer cur/next pointers are Scheme values
From: |
Andy Wingo |
Subject: |
[Guile-commits] 05/07: Port buffer cur/next pointers are Scheme values |
Date: |
Thu, 21 Apr 2016 08:28:11 +0000 |
wingo pushed a commit to branch wip-port-refactor
in repository guile.
commit ffb4347d5330fbd2b3e78d761613955f83aeef3d
Author: Andy Wingo <address@hidden>
Date: Tue Apr 19 19:50:21 2016 +0200
Port buffer cur/next pointers are Scheme values
* libguile/ports.h (scm_t_port_buffer): Change "cur" and "end" members
to be SCM values, in preparation for changing port buffers to be
Scheme vectors.
(scm_get_byte_or_eof_unlocked, scm_peek_byte_or_eof_unlocked): Adapt.
* libguile/ports.c (scm_c_make_port_buffer): Initialize cur and end
members.
(looking_at_bytes): Use helper instead of incrementing cur.
(scm_i_read_unlocked): Adapt to end type change.
(CONSUME_PEEKED_BYTE): Use helper instead of incrementing cur.
(scm_i_unget_bytes_unlocked): Use helper instead of comparing cur.
(scm_i_write_unlocked): Fix for changing end/cur types.
* libguile/read.c (scm_i_scan_for_encoding): Use helpers instead of
addressing cursors directly.
* libguile/rw.c (scm_write_string_partial): Likewise.
* libguile/ports-internal.h (scm_port_buffer_reset):
(scm_port_buffer_reset_end, scm_port_buffer_can_take):
(scm_port_buffer_can_put, scm_port_buffer_can_putback):
(scm_port_buffer_did_take, scm_port_buffer_did_put):
(scm_port_buffer_take_pointer, scm_port_buffer_put_pointer):
(scm_port_buffer_putback): Adapt to data types.
---
libguile/ports-internal.h | 29 ++++++++++++++++++-----------
libguile/ports.c | 18 ++++++++++--------
libguile/ports.h | 44 ++++++++++++++++++++++++++++++--------------
libguile/read.c | 4 ++--
libguile/rw.c | 2 +-
5 files changed, 61 insertions(+), 36 deletions(-)
diff --git a/libguile/ports-internal.h b/libguile/ports-internal.h
index 14d00c2..862d858 100644
--- a/libguile/ports-internal.h
+++ b/libguile/ports-internal.h
@@ -36,51 +36,57 @@ scm_port_buffer_size (scm_t_port_buffer *buf)
static inline void
scm_port_buffer_reset (scm_t_port_buffer *buf)
{
- buf->cur = buf->end = 0;
+ buf->cur = buf->end = SCM_INUM0;
}
static inline void
scm_port_buffer_reset_end (scm_t_port_buffer *buf)
{
- buf->cur = buf->end = scm_port_buffer_size (buf);
+ buf->cur = buf->end = scm_from_size_t (scm_port_buffer_size (buf));
}
static inline size_t
scm_port_buffer_can_take (scm_t_port_buffer *buf)
{
- return buf->end - buf->cur;
+ return scm_to_size_t (buf->end) - scm_to_size_t (buf->cur);
}
static inline size_t
scm_port_buffer_can_put (scm_t_port_buffer *buf)
{
- return scm_port_buffer_size (buf) - buf->end;
+ return scm_port_buffer_size (buf) - scm_to_size_t (buf->end);
+}
+
+static inline size_t
+scm_port_buffer_can_putback (scm_t_port_buffer *buf)
+{
+ return scm_to_size_t (buf->cur);
}
static inline void
scm_port_buffer_did_take (scm_t_port_buffer *buf, size_t count)
{
- buf->cur += count;
+ buf->cur = scm_from_size_t (scm_to_size_t (buf->cur) + count);
}
static inline void
scm_port_buffer_did_put (scm_t_port_buffer *buf, size_t count)
{
- buf->end += count;
+ buf->end = scm_from_size_t (scm_to_size_t (buf->end) + count);
}
static inline const scm_t_uint8 *
scm_port_buffer_take_pointer (scm_t_port_buffer *buf)
{
signed char *ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector);
- return ((scm_t_uint8 *) ret) + buf->cur;
+ return ((scm_t_uint8 *) ret) + scm_to_size_t (buf->cur);
}
static inline scm_t_uint8 *
scm_port_buffer_put_pointer (scm_t_port_buffer *buf)
{
signed char *ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector);
- return ((scm_t_uint8 *) ret) + buf->end;
+ return ((scm_t_uint8 *) ret) + scm_to_size_t (buf->end);
}
static inline size_t
@@ -108,12 +114,13 @@ static inline void
scm_port_buffer_putback (scm_t_port_buffer *buf, const scm_t_uint8 *src,
size_t count)
{
- assert (count <= buf->cur);
+ assert (count <= scm_to_size_t (buf->cur));
/* Sometimes used to move around data within a buffer, so we must use
memmove. */
- buf->cur -= count;
- memmove (SCM_BYTEVECTOR_CONTENTS (buf->bytevector) + buf->cur, src, count);
+ buf->cur = scm_from_size_t (scm_to_size_t (buf->cur) - count);
+ memmove (SCM_BYTEVECTOR_CONTENTS (buf->bytevector) + scm_to_size_t
(buf->cur),
+ src, count);
}
enum scm_port_encoding_mode {
diff --git a/libguile/ports.c b/libguile/ports.c
index a433e28..b8b6dbf 100644
--- a/libguile/ports.c
+++ b/libguile/ports.c
@@ -518,6 +518,7 @@ scm_c_make_port_buffer (size_t size)
scm_t_port_buffer *ret = scm_gc_typed_calloc (scm_t_port_buffer);
ret->bytevector = scm_c_make_bytevector (size);
+ ret->cur = ret->end = SCM_INUM0;
ret->has_eof_p = SCM_BOOL_F;
return ret;
@@ -1000,7 +1001,7 @@ looking_at_bytes (SCM port, const unsigned char *bytes,
int len)
while (i < len && scm_peek_byte_or_eof_unlocked (port) == bytes[i])
{
- pt->read_buf->cur++;
+ scm_port_buffer_did_take (pt->read_buf, 1);
i++;
}
scm_i_unget_bytes_unlocked (bytes, i, port);
@@ -1413,7 +1414,8 @@ scm_i_read_unlocked (SCM port, scm_t_port_buffer *buf)
{
size_t count;
- count = scm_i_read_bytes_unlocked (port, buf->bytevector, buf->end,
+ count = scm_i_read_bytes_unlocked (port, buf->bytevector,
+ scm_to_size_t (buf->end),
scm_port_buffer_can_put (buf));
scm_port_buffer_did_put (buf, count);
buf->has_eof_p = scm_from_bool (count == 0);
@@ -1636,7 +1638,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint,
if (SCM_UNLIKELY ((b) == EOF)) \
goto invalid_seq
#define CONSUME_PEEKED_BYTE() \
- pt->read_buf->cur++
+ scm_port_buffer_did_take (pt->read_buf, 1)
int byte;
scm_t_port *pt;
@@ -1985,7 +1987,7 @@ scm_i_unget_bytes_unlocked (const scm_t_uint8 *buf,
size_t len, SCM port)
pt->rw_active = SCM_PORT_READ;
}
- if (read_buf->cur < len)
+ if (scm_port_buffer_can_putback (read_buf) < len)
{
/* The bytes don't fit directly in the read_buf. */
size_t buffered, size;
@@ -2562,8 +2564,8 @@ scm_i_write_unlocked (SCM port, scm_t_port_buffer *src)
{
size_t start, count;
- assert (src->cur < src->end);
- assert (src->end <= scm_port_buffer_size (src));
+ assert (scm_to_size_t (src->cur) < scm_to_size_t (src->end));
+ assert (scm_to_size_t (src->end) <= scm_port_buffer_size (src));
/* Update cursors before attempting to write, assuming that I/O errors
are sticky. That way if the write throws an error, causing the
@@ -2571,8 +2573,8 @@ scm_i_write_unlocked (SCM port, scm_t_port_buffer *src)
by GC when it's open, any subsequent close-port / force-output
won't signal *another* error. */
- start = src->cur;
- count = src->end - src->cur;
+ start = scm_to_size_t (src->cur);
+ count = scm_port_buffer_can_take (src);
scm_port_buffer_reset (src);
scm_i_write_bytes_unlocked (port, src->bytevector, start, count);
}
diff --git a/libguile/ports.h b/libguile/ports.h
index 12a67ec..1735623 100644
--- a/libguile/ports.h
+++ b/libguile/ports.h
@@ -78,8 +78,8 @@ typedef struct
SCM bytevector;
/* Offsets into the buffer. Invariant: cur <= end <= size(buf). */
- size_t cur;
- size_t end;
+ SCM cur;
+ SCM end;
/* For read buffers, flag indicating whether the last read() returned
zero bytes. Note that in the case of pushback, there could still
@@ -429,16 +429,24 @@ SCM_INLINE_IMPLEMENTATION int
scm_get_byte_or_eof_unlocked (SCM port)
{
scm_t_port_buffer *buf = SCM_PTAB_ENTRY (port)->read_buf;
- scm_t_uint8 *ptr;
+ size_t cur;
- ptr = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (buf->bytevector);
- if (SCM_LIKELY (buf->cur < buf->end))
- return ptr[buf->cur++];
+ cur = scm_to_size_t (buf->cur);
+ if (SCM_LIKELY (cur < scm_to_size_t (buf->end)))
+ {
+ scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector)[cur];
+ buf->cur = scm_from_size_t (cur + 1);
+ return ret;
+ }
buf = scm_fill_input_unlocked (port);
- ptr = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (buf->bytevector);
- if (buf->cur < buf->end)
- return ptr[buf->cur++];
+ cur = scm_to_size_t (buf->cur);
+ if (cur < scm_to_size_t (buf->end))
+ {
+ scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector)[cur];
+ buf->cur = scm_from_size_t (cur + 1);
+ return ret;
+ }
/* The next peek or get should cause the read() function to be called
to see if we still have EOF. */
@@ -451,14 +459,22 @@ SCM_INLINE_IMPLEMENTATION int
scm_peek_byte_or_eof_unlocked (SCM port)
{
scm_t_port_buffer *buf = SCM_PTAB_ENTRY (port)->read_buf;
- scm_t_uint8 *ptr = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (buf->bytevector);
+ size_t cur;
- if (SCM_LIKELY (buf->cur < buf->end))
- return ptr[buf->cur];
+ cur = scm_to_size_t (buf->cur);
+ if (SCM_LIKELY (cur < scm_to_size_t (buf->end)))
+ {
+ scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector)[cur];
+ return ret;
+ }
buf = scm_fill_input_unlocked (port);
- if (buf->cur < buf->end)
- return ptr[buf->cur];
+ cur = scm_to_size_t (buf->cur);
+ if (cur < scm_to_size_t (buf->end))
+ {
+ scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf->bytevector)[cur];
+ return ret;
+ }
return EOF;
}
diff --git a/libguile/read.c b/libguile/read.c
index a4357d1..bc5c3c1 100644
--- a/libguile/read.c
+++ b/libguile/read.c
@@ -2074,11 +2074,11 @@ scm_i_scan_for_encoding (SCM port)
pt->rw_active = SCM_PORT_READ;
}
- if (buf->cur == buf->end)
+ if (scm_port_buffer_can_take (buf) == 0)
{
/* We can use the read buffer, and thus avoid a seek. */
buf = scm_fill_input_unlocked (port);
- bytes_read = buf->end - buf->cur;
+ bytes_read = scm_port_buffer_can_take (buf);
if (bytes_read > SCM_ENCODING_SEARCH_SIZE)
bytes_read = SCM_ENCODING_SEARCH_SIZE;
diff --git a/libguile/rw.c b/libguile/rw.c
index 76467a9..d6437e9 100644
--- a/libguile/rw.c
+++ b/libguile/rw.c
@@ -240,7 +240,7 @@ SCM_DEFINE (scm_write_string_partial,
"write-string/partial", 1, 3, 0,
/* Filling the last character in the buffer would require a
flush. */
- if (write_len < scm_port_buffer_size (write_buf) - write_buf->end)
+ if (write_len < scm_port_buffer_can_put (write_buf))
{
scm_c_write_unlocked (port, src, write_len);
return scm_from_long (write_len);
- [Guile-commits] branch wip-port-refactor updated (44b3342 -> 5a342f6), Andy Wingo, 2016/04/21
- [Guile-commits] 02/07: Port buffer has-eof? field is SCM value, Andy Wingo, 2016/04/21
- [Guile-commits] 06/07: peek-u8 correctness and speed refactor, Andy Wingo, 2016/04/21
- [Guile-commits] 05/07: Port buffer cur/next pointers are Scheme values,
Andy Wingo <=
- [Guile-commits] 01/07: Remove unrelated scm_t_port_buffer use in vports, Andy Wingo, 2016/04/21
- [Guile-commits] 04/07: Remove "buf" field from port buffers, Andy Wingo, 2016/04/21
- [Guile-commits] 03/07: Remove size field from port buffers, Andy Wingo, 2016/04/21
- [Guile-commits] 07/07: Port buffers are Scheme values, Andy Wingo, 2016/04/21