lib/ff-string.c

   1 /*
   2  *      UCW Library -- Fast Buffered I/O: Strings
   3  *
   4  *      (c) 1997--2006 Martin Mares <mj@ucw.cz>
   5  *      (c) 2006 Pavel Charvat <pchar@ucw.cz>
   6  *
   7  *      This software may be freely distributed and used according to the terms
   8  *      of the GNU Lesser General Public License.
   9  */
  10
  11 #include "lib/lib.h"
  12 #include "lib/fastbuf.h"
  13 #include "lib/mempool.h"
  14 #include "lib/bbuf.h"
  15
  16 byte *                                  /* Non-standard */
  17 bgets(struct fastbuf *f, byte *b, uns l)
  18 {
  19   ASSERT(l);
  20   byte *src;
  21   uns src_len = bdirect_read_prepare(f, &src);
  22   if (!src_len)
  23     return NULL;
  24   do
  25     {
  26       uns cnt = MIN(l, src_len);
  27       for (uns i = cnt; i--;)
  28         {
  29           byte v = *src++;
  30           if (v == '\n')
  31             {
  32               bdirect_read_commit(f, src);
  33               goto exit;
  34             }
  35           *b++ = v;
  36         }
  37       if (unlikely(cnt == l))
  38         die("%s: Line too long", f->name);
  39       l -= cnt;
  40       bdirect_read_commit(f, src);
  41       src_len = bdirect_read_prepare(f, &src);
  42     }
  43   while (src_len);
  44 exit:
  45   *b = 0;
  46   return b;
  47 }
  48
  49 int
  50 bgets_nodie(struct fastbuf *f, byte *b, uns l)
  51 {
  52   ASSERT(l);
  53   byte *src, *start = b;
  54   uns src_len = bdirect_read_prepare(f, &src);
  55   if (!src_len)
  56     return 0;
  57   do
  58     {
  59       uns cnt = MIN(l, src_len);
  60       for (uns i = cnt; i--;)
  61         {
  62           byte v = *src++;
  63           if (v == '\n')
  64             {
  65               bdirect_read_commit(f, src);
  66               goto exit;
  67             }
  68           *b++ = v;
  69         }
  70       bdirect_read_commit(f, src);
  71       if (cnt == l)
  72         return -1;
  73       l -= cnt;
  74       src_len = bdirect_read_prepare(f, &src);
  75     }
  76   while (src_len);
  77 exit:
  78   *b++ = 0;
  79   return b - start;
  80 }
  81
  82 uns
  83 bgets_bb(struct fastbuf *f, struct bb_t *bb, uns limit)
  84 {
  85   ASSERT(limit);
  86   byte *src;
  87   uns src_len = bdirect_read_prepare(f, &src);
  88   if (!src_len)
  89     return 0;
  90   bb_grow(bb, 1);
  91   byte *buf = bb->ptr;
  92   uns len = 0, buf_len = MIN(bb->len, limit);
  93   do
  94     {
  95       uns cnt = MIN(src_len, buf_len);
  96       for (uns i = cnt; i--;)
  97         {
  98           byte v = *src++;
  99           if (v == '\n')
 100             {
 101               bdirect_read_commit(f, src);
 102               goto exit;
 103             }
 104           *buf++ = v;
 105         }
 106       len += cnt;
 107       if (cnt == src_len)
 108         {
 109           bdirect_read_commit(f, src);
 110           src_len = bdirect_read_prepare(f, &src);
 111         }
 112       else
 113         src_len -= cnt;
 114       if (cnt == buf_len)
 115         {
 116           if (unlikely(len == limit))
 117             die("%s: Line too long", f->name);
 118           bb_do_grow(bb, len + 1);
 119           buf = bb->ptr + len;
 120           buf_len = MIN(bb->len, limit) - len;
 121         }
 122       else
 123         buf_len -= cnt;
 124     }
 125   while (src_len);
 126 exit:
 127   *buf++ = 0;
 128   return buf - bb->ptr;
 129 }
 130
 131 byte *
 132 bgets_mp(struct fastbuf *f, struct mempool *mp)
 133 {
 134   byte *src;
 135   uns src_len = bdirect_read_prepare(f, &src);
 136   if (!src_len)
 137     return NULL;
 138 #define BLOCK_SIZE (4096 - sizeof(void *))
 139   struct block {
 140     struct block *prev;
 141     byte data[BLOCK_SIZE];
 142   } *blocks = NULL;
 143   uns sum = 0, buf_len = BLOCK_SIZE, cnt;
 144   struct block first_block, *new_block = &first_block;
 145   byte *buf = new_block->data;
 146   do
 147     {
 148       cnt = MIN(src_len, buf_len);
 149       for (uns i = cnt; i--;)
 150         {
 151           byte v = *src++;
 152           if (v == '\n')
 153             {
 154               bdirect_read_commit(f, src);
 155               goto exit;
 156             }
 157           *buf++ = v;
 158         }
 159       if (cnt == src_len)
 160         {
 161           bdirect_read_commit(f, src);
 162           src_len = bdirect_read_prepare(f, &src);
 163         }
 164       else
 165         src_len -= cnt;
 166       if (cnt == buf_len)
 167         {
 168           new_block->prev = blocks;
 169           blocks = new_block;
 170           sum += buf_len = BLOCK_SIZE;
 171           new_block = alloca(sizeof(struct block));
 172           buf = new_block->data;
 173         }
 174       else
 175         buf_len -= cnt;
 176     }
 177   while (src_len);
 178 exit: ;
 179   uns len = buf - new_block->data;
 180   byte *result = mp_alloc(mp, sum + len + 1) + sum;
 181   result[len] = 0;
 182   memcpy(result, new_block->data, len);
 183   while (blocks)
 184     {
 185       result -= BLOCK_SIZE;
 186       memcpy(result, blocks->data, BLOCK_SIZE);
 187       blocks = blocks->prev;
 188     }
 189   return result;
 190 #undef BLOCK_SIZE
 191 }
 192
 193 void
 194 bgets_stk_init(struct bgets_stk_struct *s)
 195 {
 196   s->src_len = bdirect_read_prepare(s->f, &s->src);
 197   if (!s->src_len)
 198     {
 199       s->cur_buf = NULL;
 200       s->cur_len = 0;
 201     }
 202   else
 203     {
 204       s->old_buf = NULL;
 205       s->cur_len = 256;
 206     }
 207 }
 208
 209 void
 210 bgets_stk_step(struct bgets_stk_struct *s)
 211 {
 212   byte *buf = s->cur_buf;
 213   uns buf_len = s->cur_len;
 214   if (s->old_buf)
 215     {
 216       memcpy( s->cur_buf, s->old_buf, s->old_len);
 217       buf += s->old_len;
 218       buf_len -= s->old_len;
 219     }
 220   do
 221     {
 222       uns cnt = MIN(s->src_len, buf_len);
 223       for (uns i = cnt; i--;)
 224         {
 225           byte v = *s->src++;
 226           if (v == '\n')
 227             {
 228               bdirect_read_commit(s->f, s->src);
 229               goto exit;
 230             }
 231           *buf++ = v;
 232         }
 233       if (cnt == s->src_len)
 234         {
 235           bdirect_read_commit(s->f, s->src);
 236           s->src_len = bdirect_read_prepare(s->f, &s->src);
 237         }
 238       else
 239         s->src_len -= cnt;
 240       if (cnt == buf_len)
 241         {
 242           s->old_len = s->cur_len;
 243           s->old_buf = s->cur_buf;
 244           s->cur_len *= 2;
 245           return;
 246         }
 247       else
 248         buf_len -= cnt;
 249     }
 250   while (s->src_len);
 251 exit:
 252   *buf = 0;
 253   s->cur_len = 0;
 254 }
 255
 256 byte *
 257 bgets0(struct fastbuf *f, byte *b, uns l)
 258 {
 259   ASSERT(l);
 260   byte *src;
 261   uns src_len = bdirect_read_prepare(f, &src);
 262   if (!src_len)
 263     return NULL;
 264   do
 265     {
 266       uns cnt = MIN(l, src_len);
 267       for (uns i = cnt; i--;)
 268         {
 269           *b = *src++;
 270           if (!*b)
 271             {
 272               bdirect_read_commit(f, src);
 273               return b;
 274             }
 275           b++;
 276         }
 277       if (unlikely(cnt == l))
 278         die("%s: Line too long", f->name);
 279       l -= cnt;
 280       bdirect_read_commit(f, src);
 281       src_len = bdirect_read_prepare(f, &src);
 282     }
 283   while (src_len);
 284   *b = 0;
 285   return b;
 286 }