CLEANUP: ncbuf: remove ncb_blk args by value
ncb_blk structure is used to represent a block of data or a gap in a
non-contiguous buffer. This is used in several functions for ncbuf
implementation. Before this patch, ncb_blk was passed by value, which is
sub-optimal. Replace this by const pointer arguments.
This has the side-effect of suppressing a compiler warning reported in
older GCC version :
CC src/http_conv.o
src/ncbuf.c: In function 'ncb_blk_next':
src/ncbuf.c:170: warning: 'blk.end' may be used uninitialized in this function
This should be backported up to 2.6.
diff --git a/src/ncbuf.c b/src/ncbuf.c
index ed1878b..dab9196 100644
--- a/src/ncbuf.c
+++ b/src/ncbuf.c
@@ -110,16 +110,16 @@
}
/* Returns true if <blk> is the special NULL block. */
-static int ncb_blk_is_null(const struct ncb_blk blk)
+static int ncb_blk_is_null(const struct ncb_blk *blk)
{
- return !blk.st;
+ return !blk->st;
}
/* Returns true if <blk> is the last block of <buf>. */
-static int ncb_blk_is_last(const struct ncbuf *buf, const struct ncb_blk blk)
+static int ncb_blk_is_last(const struct ncbuf *buf, const struct ncb_blk *blk)
{
- BUG_ON_HOT(blk.off + blk.sz > ncb_size(buf));
- return blk.off + blk.sz == ncb_size(buf);
+ BUG_ON_HOT(blk->off + blk->sz > ncb_size(buf));
+ return blk->off + blk->sz == ncb_size(buf);
}
/* Returns the first block of <buf> which is always a DATA. */
@@ -146,7 +146,7 @@
/* Returns the block following <prev> in the buffer <buf>. */
static struct ncb_blk ncb_blk_next(const struct ncbuf *buf,
- const struct ncb_blk prev)
+ const struct ncb_blk *prev)
{
struct ncb_blk blk;
@@ -155,9 +155,9 @@
if (ncb_blk_is_last(buf, prev))
return NCB_BLK_NULL;
- blk.st = prev.end;
- blk.off = prev.off + prev.sz;
- blk.flag = ~prev.flag & NCB_BK_F_GAP;
+ blk.st = prev->end;
+ blk.off = prev->off + prev->sz;
+ blk.flag = ~prev->flag & NCB_BK_F_GAP;
if (blk.flag & NCB_BK_F_GAP) {
if (ncb_off_reduced(buf, blk.off)) {
@@ -167,7 +167,7 @@
blk.sz_data = 0;
/* A reduced gap can only be the last block. */
- BUG_ON_HOT(!ncb_blk_is_last(buf, blk));
+ BUG_ON_HOT(!ncb_blk_is_last(buf, &blk));
}
else {
blk.sz_ptr = ncb_peek(buf, blk.off + NCB_GAP_SZ_OFF);
@@ -177,8 +177,8 @@
}
}
else {
- blk.sz_ptr = ncb_peek(buf, prev.off + NCB_GAP_SZ_DATA_OFF);
- blk.sz = prev.sz_data;
+ blk.sz_ptr = ncb_peek(buf, prev->off + NCB_GAP_SZ_DATA_OFF);
+ blk.sz = prev->sz_data;
blk.sz_data = 0;
/* only first DATA block can be empty. If this happens, a GAP
@@ -207,18 +207,18 @@
BUG_ON_HOT(off >= ncb_size(buf));
for (blk = ncb_blk_first(buf); off > blk.off + blk.sz;
- blk = ncb_blk_next(buf, blk)) {
+ blk = ncb_blk_next(buf, &blk)) {
}
return blk;
}
/* Transform absolute offset <off> to a relative one from <blk> start. */
-static ncb_sz_t ncb_blk_off(const struct ncb_blk blk, ncb_sz_t off)
+static ncb_sz_t ncb_blk_off(const struct ncb_blk *blk, ncb_sz_t off)
{
- BUG_ON_HOT(off < blk.off || off > blk.off + blk.sz);
- BUG_ON_HOT(off - blk.off > blk.sz);
- return off - blk.off;
+ BUG_ON_HOT(off < blk->off || off > blk->off + blk->sz);
+ BUG_ON_HOT(off - blk->off > blk->sz);
+ return off - blk->off;
}
/* Simulate insertion in <buf> of <data> of length <len> at offset <off>. This
@@ -230,10 +230,11 @@
* Returns NCB_RET_OK if insertion can proceed.
*/
static enum ncb_ret ncb_check_insert(const struct ncbuf *buf,
- struct ncb_blk blk, ncb_sz_t off,
+ const struct ncb_blk *blk, ncb_sz_t off,
const char *data, ncb_sz_t len,
enum ncb_add_mode mode)
{
+ struct ncb_blk next;
ncb_sz_t off_blk = ncb_blk_off(blk, off);
ncb_sz_t to_copy;
ncb_sz_t left = len;
@@ -241,29 +242,30 @@
/* If insertion starts in a gap, it must leave enough space to keep the
* gap header.
*/
- if (left && (blk.flag & NCB_BK_F_GAP)) {
+ if (left && (blk->flag & NCB_BK_F_GAP)) {
if (off_blk < NCB_GAP_MIN_SZ)
return NCB_RET_GAP_SIZE;
}
+ next = *blk;
while (left) {
- off_blk = ncb_blk_off(blk, off);
- to_copy = MIN(left, blk.sz - off_blk);
+ off_blk = ncb_blk_off(&next, off);
+ to_copy = MIN(left, next.sz - off_blk);
- if (blk.flag & NCB_BK_F_GAP && off_blk + to_copy < blk.sz) {
+ if (next.flag & NCB_BK_F_GAP && off_blk + to_copy < next.sz) {
/* Insertion must leave enough space for a new gap
* header if stopped in a middle of a gap.
*/
- const ncb_sz_t gap_sz = blk.sz - (off_blk + to_copy);
- if (gap_sz < NCB_GAP_MIN_SZ && !ncb_blk_is_last(buf, blk))
+ const ncb_sz_t gap_sz = next.sz - (off_blk + to_copy);
+ if (gap_sz < NCB_GAP_MIN_SZ && !ncb_blk_is_last(buf, &next))
return NCB_RET_GAP_SIZE;
}
- else if (!(blk.flag & NCB_BK_F_GAP) && mode == NCB_ADD_COMPARE) {
+ else if (!(next.flag & NCB_BK_F_GAP) && mode == NCB_ADD_COMPARE) {
/* Compare memory of data block in NCB_ADD_COMPARE mode. */
- const ncb_sz_t off_blk = ncb_blk_off(blk, off);
+ const ncb_sz_t off_blk = ncb_blk_off(&next, off);
char *st = ncb_peek(buf, off);
- to_copy = MIN(left, blk.sz - off_blk);
+ to_copy = MIN(left, next.sz - off_blk);
if (st + to_copy > ncb_wrap(buf)) {
const ncb_sz_t sz1 = ncb_wrap(buf) - st;
if (memcmp(st, data, sz1))
@@ -281,7 +283,7 @@
data += to_copy;
off += to_copy;
- blk = ncb_blk_next(buf, blk);
+ next = ncb_blk_next(buf, &next);
}
return NCB_RET_OK;
@@ -292,22 +294,22 @@
* block size. <mode> specifies if old data are preserved or overwritten.
*/
static ncb_sz_t ncb_fill_data_blk(const struct ncbuf *buf,
- struct ncb_blk blk, ncb_sz_t off,
+ const struct ncb_blk *blk, ncb_sz_t off,
const char *data, ncb_sz_t len,
enum ncb_add_mode mode)
{
- const ncb_sz_t to_copy = MIN(len, blk.sz - off);
+ const ncb_sz_t to_copy = MIN(len, blk->sz - off);
char *ptr = NULL;
- BUG_ON_HOT(off > blk.sz);
+ BUG_ON_HOT(off > blk->sz);
/* This can happens due to previous ncb_blk_find() usage. In this
* case the current fill is a noop.
*/
- if (off == blk.sz)
+ if (off == blk->sz)
return 0;
if (mode == NCB_ADD_OVERWRT) {
- ptr = ncb_peek(buf, blk.off + off);
+ ptr = ncb_peek(buf, blk->off + off);
if (ptr + to_copy >= ncb_wrap(buf)) {
const ncb_sz_t sz1 = ncb_wrap(buf) - ptr;
@@ -326,26 +328,26 @@
* is relative to <blk> so it cannot be greater than the block size.
*/
static ncb_sz_t ncb_fill_gap_blk(const struct ncbuf *buf,
- struct ncb_blk blk, ncb_sz_t off,
+ const struct ncb_blk *blk, ncb_sz_t off,
const char *data, ncb_sz_t len)
{
- const ncb_sz_t to_copy = MIN(len, blk.sz - off);
+ const ncb_sz_t to_copy = MIN(len, blk->sz - off);
char *ptr;
- BUG_ON_HOT(off > blk.sz);
+ BUG_ON_HOT(off > blk->sz);
/* This can happens due to previous ncb_blk_find() usage. In this
* case the current fill is a noop.
*/
- if (off == blk.sz)
+ if (off == blk->sz)
return 0;
/* A new gap must be created if insertion stopped before gap end. */
- if (off + to_copy < blk.sz) {
- const ncb_sz_t gap_off = blk.off + off + to_copy;
- const ncb_sz_t gap_sz = blk.sz - off - to_copy;
+ if (off + to_copy < blk->sz) {
+ const ncb_sz_t gap_off = blk->off + off + to_copy;
+ const ncb_sz_t gap_sz = blk->sz - off - to_copy;
BUG_ON_HOT(!ncb_off_reduced(buf, gap_off) &&
- blk.off + blk.sz - gap_off < NCB_GAP_MIN_SZ);
+ blk->off + blk->sz - gap_off < NCB_GAP_MIN_SZ);
/* write the new gap header unless this is a reduced gap. */
if (!ncb_off_reduced(buf, gap_off)) {
@@ -353,12 +355,12 @@
char *gap_data_ptr = ncb_peek(buf, gap_off + NCB_GAP_SZ_DATA_OFF);
ncb_write_off(buf, gap_ptr, gap_sz);
- ncb_write_off(buf, gap_data_ptr, blk.sz_data);
+ ncb_write_off(buf, gap_data_ptr, blk->sz_data);
}
}
/* fill the gap with new data */
- ptr = ncb_peek(buf, blk.off + off);
+ ptr = ncb_peek(buf, blk->off + off);
if (ptr + to_copy >= ncb_wrap(buf)) {
ncb_sz_t sz1 = ncb_wrap(buf) - ptr;
memcpy(ptr, data, sz1);
@@ -446,7 +448,7 @@
struct ncb_blk blk;
int total = 0;
- for (blk = ncb_blk_first(buf); !ncb_blk_is_null(blk); blk = ncb_blk_next(buf, blk)) {
+ for (blk = ncb_blk_first(buf); !ncb_blk_is_null(&blk); blk = ncb_blk_next(buf, &blk)) {
if (!(blk.flag & NCB_BK_F_GAP))
total += blk.sz;
}
@@ -502,8 +504,8 @@
/* check that following gap is the last block */
data = ncb_blk_first(buf);
- gap = ncb_blk_next(buf, data);
- return !ncb_blk_is_last(buf, gap);
+ gap = ncb_blk_next(buf, &data);
+ return !ncb_blk_is_last(buf, &gap);
}
/* Returns the number of bytes of data available in <buf> starting at offset
@@ -519,15 +521,15 @@
return 0;
blk = ncb_blk_find(buf, off);
- off_blk = ncb_blk_off(blk, off);
+ off_blk = ncb_blk_off(&blk, off);
/* if <off> at the frontier between two and <blk> is gap, retrieve the
* next data block.
*/
if (blk.flag & NCB_BK_F_GAP && off_blk == blk.sz &&
- !ncb_blk_is_last(buf, blk)) {
- blk = ncb_blk_next(buf, blk);
- off_blk = ncb_blk_off(blk, off);
+ !ncb_blk_is_last(buf, &blk)) {
+ blk = ncb_blk_next(buf, &blk);
+ off_blk = ncb_blk_off(&blk, off);
}
if (blk.flag & NCB_BK_F_GAP)
@@ -560,7 +562,7 @@
blk = ncb_blk_find(buf, off);
/* Check if insertion is possible. */
- ret = ncb_check_insert(buf, blk, off, data, len, mode);
+ ret = ncb_check_insert(buf, &blk, off, data, len, mode);
if (ret != NCB_RET_OK)
return ret;
@@ -585,16 +587,16 @@
/* insert data */
while (left) {
struct ncb_blk next;
- const ncb_sz_t off_blk = ncb_blk_off(blk, off);
+ const ncb_sz_t off_blk = ncb_blk_off(&blk, off);
ncb_sz_t done;
/* retrieve the next block. This is necessary to do this
* before overwriting a gap.
*/
- next = ncb_blk_next(buf, blk);
+ next = ncb_blk_next(buf, &blk);
if (blk.flag & NCB_BK_F_GAP) {
- done = ncb_fill_gap_blk(buf, blk, off_blk, data, left);
+ done = ncb_fill_gap_blk(buf, &blk, off_blk, data, left);
/* update the inserted data block size */
if (off + done == blk.off + blk.sz) {
@@ -607,7 +609,7 @@
}
}
else {
- done = ncb_fill_data_blk(buf, blk, off_blk, data, left, mode);
+ done = ncb_fill_data_blk(buf, &blk, off_blk, data, left, mode);
}
BUG_ON_HOT(done > blk.sz || done > left);
@@ -650,7 +652,7 @@
/* Special case if advance until the last block which is a GAP. The
* buffer will be left empty and is thus equivalent to a reset.
*/
- if (ncb_blk_is_last(buf, start) && (start.flag & NCB_BK_F_GAP)) {
+ if (ncb_blk_is_last(buf, &start) && (start.flag & NCB_BK_F_GAP)) {
ncb_sz_t new_head = buf->head + adv;
if (new_head >= buf->size)
new_head -= buf->size;
@@ -660,10 +662,10 @@
}
last = start;
- while (!ncb_blk_is_last(buf, last))
- last = ncb_blk_next(buf, last);
+ while (!ncb_blk_is_last(buf, &last))
+ last = ncb_blk_next(buf, &last);
- off_blk = ncb_blk_off(start, adv);
+ off_blk = ncb_blk_off(&start, adv);
if (start.flag & NCB_BK_F_GAP) {
/* If advance in a GAP, its new size must be big enough. */
@@ -758,18 +760,18 @@
return roff;
}
-static void ncb_print_blk(const struct ncb_blk blk)
+static void ncb_print_blk(const struct ncb_blk *blk)
{
if (ncb_print) {
fprintf(stderr, "%s(%s): %2u/%u.\n",
- blk.flag & NCB_BK_F_GAP ? "GAP " : "DATA",
- blk.flag & NCB_BK_F_FIN ? "F" : "-", blk.off, blk.sz);
+ blk->flag & NCB_BK_F_GAP ? "GAP " : "DATA",
+ blk->flag & NCB_BK_F_FIN ? "F" : "-", blk->off, blk->sz);
}
}
-static inline int ncb_is_null_blk(const struct ncb_blk blk)
+static int ncb_is_null_blk(const struct ncb_blk *blk)
{
- return !blk.st;
+ return !blk->st;
}
static void ncb_loop(const struct ncbuf *buf)
@@ -778,9 +780,9 @@
blk = ncb_blk_first(buf);
do {
- ncb_print_blk(blk);
- blk = ncb_blk_next(buf, blk);
- } while (!ncb_is_null_blk(blk));
+ ncb_print_blk(&blk);
+ blk = ncb_blk_next(buf, &blk);
+ } while (!ncb_is_null_blk(&blk));
ncbuf_printf("\n");
}