MINOR: buffer: replace bi_space_for_replace() with ci_space_for_replace()

This one computes the size that can be overwritten over the input part
of the buffer, so it's channel-specific.

diff --git a/include/common/buffer.h b/include/common/buffer.h
index c0fdab40847283c1e6cc9def119a4b6161545baf..648e7b635d1d0856d8777d3e61b78a55fc0e9af5 100644 (file)
--- a/include/common/buffer.h
+++ b/include/common/buffer.h
@@ -77,32 +77,6 @@ static inline char *buffer_wrap_add(const struct buffer *buf, char *ptr)
        return ptr;
 }
 
-/* Returns the amount of byte that can be written starting from <p> into the
- * input buffer at once, including reserved space which may be overwritten.
- * This is used by Lua to insert data in the input side just before the other
- * data using buffer_replace(). The goal is to transfer these new data in the
- * output buffer.
- */
-static inline int bi_space_for_replace(const struct buffer *buf)
-{
-       const char *end;
-
-       /* If the input side data overflows, we cannot insert data contiguously. */
-       if (buf->p + buf->i >= buf->data + buf->size)
-               return 0;
-
-       /* Check the last byte used in the buffer, it may be a byte of the output
-        * side if the buffer wraps, or its the end of the buffer.
-        */
-       end = buffer_wrap_sub(buf, buf->p - buf->o);
-       if (end <= buf->p)
-               end = buf->data + buf->size;
-
-       /* Compute the amount of bytes which can be written. */
-       return end - (buf->p + buf->i);
-}
-
-
 /* Normalizes a pointer which is supposed to be relative to the beginning of a
  * buffer, so that wrapping is correctly handled. The intent is to use this
  * when increasing a pointer. Note that the wrapping test is only performed

diff --git a/include/proto/channel.h b/include/proto/channel.h
index 18597e4feb9fb4f6699a255644f1640025ce9897..2cbbf96863422ac18dacd3e4ef0872bc18ad322a 100644 (file)
--- a/include/proto/channel.h
+++ b/include/proto/channel.h
@@ -670,6 +670,31 @@ static inline int channel_recv_max(const struct channel *chn)
        return ret;
 }
 
+/* Returns the amount of bytes that can be written over the input data at once,
+ * including reserved space which may be overwritten. This is used by Lua to
+ * insert data in the input side just before the other data using buffer_replace().
+ * The goal is to transfer these new data in the output buffer.
+ */
+static inline int ci_space_for_replace(const struct channel *chn)
+{
+       const struct buffer *buf = chn->buf;
+       const char *end;
+
+       /* If the input side data overflows, we cannot insert data contiguously. */
+       if (b_head(buf) + b_data(buf) >= b_wrap(buf))
+               return 0;
+
+       /* Check the last byte used in the buffer, it may be a byte of the output
+        * side if the buffer wraps, or its the end of the buffer.
+        */
+       end = b_head(buf);
+       if (end <= ci_head(chn))
+               end = b_wrap(buf);
+
+       /* Compute the amount of bytes which can be written. */
+       return end - ci_tail(chn);
+}
+
 /* Allocates a buffer for channel <chn>, but only if it's guaranteed that it's
  * not the last available buffer or it's the response buffer. Unless the buffer
  * is the response buffer, an extra control is made so that we always keep

diff --git a/src/hlua.c b/src/hlua.c
index e784682d2d1483eea4eda16082038ee94443e926..faa51edb8c39b7ddcf41277c2c5c2aef806566b9 100644 (file)
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -3040,7 +3040,7 @@ __LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext
        /* The buffer avalaible size may be not contiguous. This test
         * detects a non contiguous buffer and realign it.
         */
-       if (bi_space_for_replace(chn->buf) < max)
+       if (ci_space_for_replace(chn) < max)
                channel_slow_realign(chn, trash.str);
 
        /* Copy input data in the buffer. */