chiark - git - mdw - mLib/blob - lbuf.c

   1 /* -*-c-*-
   2  *
   3  * $Id: lbuf.c,v 1.6 2002/01/13 13:32:52 mdw Exp $
   4  *
   5  * Block-to-line buffering
   6  *
   7  * (c) 1999 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of the mLib utilities library.
  13  *
  14  * mLib is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU Library General Public License as
  16  * published by the Free Software Foundation; either version 2 of the
  17  * License, or (at your option) any later version.
  18  *
  19  * mLib is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Library General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Library General Public
  25  * License along with mLib; if not, write to the Free
  26  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  27  * MA 02111-1307, USA.
  28  */
  29
  30 /*----- Revision history --------------------------------------------------*
  31  *
  32  * $Log: lbuf.c,v $
  33  * Revision 1.6  2002/01/13 13:32:52  mdw
  34  * Pass line length to line handler function.  Provide a @typedef@ for
  35  * handler functions.  Allow run-time configuration of line delimiters.
  36  *
  37  * Revision 1.5  2001/02/03 16:23:33  mdw
  38  * Bug fix: handle a disable during a close-induced flush without dumping
  39  * core.
  40  *
  41  * Revision 1.4  2000/06/17 10:38:14  mdw
  42  * Add support for variable buffer sizes.
  43  *
  44  * Revision 1.3  1999/05/22 13:38:50  mdw
  45  * Fix bug which discarded initial portions of incomplete lines.
  46  *
  47  * Revision 1.2  1999/05/17 20:36:08  mdw
  48  * Make the magical constants for the buffer flags uppercase.
  49  *
  50  * Revision 1.1  1999/05/14 21:01:14  mdw
  51  * Integrated `select' handling bits from the background resolver project.
  52  *
  53  */
  54
  55 /*----- Header files ------------------------------------------------------*/
  56
  57 #include <assert.h>
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61
  62 #include "alloc.h"
  63 #include "arena.h"
  64 #include "lbuf.h"
  65
  66 /*----- Main code ---------------------------------------------------------*/
  67
  68 /* --- @lbuf_flush@ --- *
  69  *
  70  * Arguments:   @lbuf *b@ = pointer to buffer block
  71  *              @char *p@ = pointer to where to start searching
  72  *              @size_t len@ = length of new material added
  73  *
  74  * Returns:     ---
  75  *
  76  * Use:         Flushes any complete lines in a line buffer.  New material
  77  *              is assumed to have been added starting at @p@.  If @p@ is
  78  *              null, then the scan starts at the beginning of the buffer,
  79  *              and the size of data already in the buffer is used in place
  80  *              of @len@.
  81  *
  82  *              It is assumed that the buffer is initially enabled.  You
  83  *              shouldn't be contributing data to a disabled buffer anyway.
  84  *              However, the buffer handler may at some point disable itself,
  85  *              and @lbuf_flush@ can cope with this eventuality.  Any pending
  86  *              data is left at the start of the buffer and can be flushed
  87  *              out by calling @lbuf_flush(b, 0, 0)@ if the buffer is ever
  88  *              re-enabled.
  89  */
  90
  91 void lbuf_flush(lbuf *b, char *p, size_t len)
  92 {
  93   char *l;                              /* Limit of data in buffer */
  94   char *q;                              /* Roving pointer through string */
  95   char *base;                           /* Base address of current line */
  96   int cr;                               /* Carriage return state */
  97
  98   if (b->f & LBUF_CLOSE) {
  99     b->func(0, 0, b->p);
 100     return;
 101   }
 102
 103   /* --- Initialize variables as necessary --- */
 104
 105   if (!p) {
 106     p = b->buf;
 107     cr = 0;
 108     len = b->len;
 109   } else
 110     cr = b->f & LBUF_CR;
 111
 112   l = p + len;
 113
 114   /* --- Clear @base@ if I'm discarding an overlong line --- */
 115
 116   if (b->len == b->sz)
 117     base = 0;
 118   else
 119     base = b->buf;
 120
 121   /* --- Now I march through the string --- */
 122
 123   for (q = p; q < l; q++) {
 124
 125     /* --- Quickly discard uninteresting characters --- */
 126
 127     switch (b->delim) {
 128       case LBUF_CRLF:
 129       case LBUF_STRICTCRLF:
 130         if (*q != '\r' && *q != '\n') {
 131           cr = 0;
 132           continue;
 133         }
 134         if (*q == '\r') {
 135           cr = 1;
 136           continue;
 137         }
 138         if (!cr && b->delim == LBUF_STRICTCRLF)
 139           continue;
 140         break;
 141       default:
 142         if (*q != b->delim)
 143           continue;
 144     }
 145
 146     /* --- I have a positive ID on a delimiter --- *
 147      *
 148      * If I'm interested in this string, report it to my owner.
 149      */
 150
 151     if (base) {
 152       len = q - base;
 153       if (cr)
 154         len--;                          /* Exercise: why is this safe? */
 155       base[len] = 0;
 156       b->func(base, len, b->p);
 157       if (!(b->f & LBUF_ENABLE)) {
 158         base = q + 1;
 159         break;
 160       }
 161     }
 162     base = q + 1;
 163     cr = 0;
 164   }
 165
 166   /* --- Sift through the aftermath --- */
 167
 168   if (base) {
 169     len = l - base;
 170     if (len == b->sz) {
 171       b->buf[len - 1] = 0;
 172       b->func(base, len - 1, b->p);
 173     } else if (base != b->buf)
 174       memmove(b->buf, base, len);
 175     b->len = len;
 176     if (cr)
 177       b->f |= LBUF_CR;
 178     else
 179       b->f &= ~LBUF_CR;
 180   }
 181 }
 182
 183 /* --- @lbuf_close@ --- *
 184  *
 185  * Arguments:   @lbuf *b@ = pointer to buffer block
 186  *
 187  * Returns:     ---
 188  *
 189  * Use:         Empties the buffer of any data currently lurking in it, and
 190  *              informs the client that this has happened.  It's assumed that
 191  *              the buffer is enabled: you shouldn't be reading close events
 192  *              on disabled buffers.  The buffer, if allocated, is freed.
 193  */
 194
 195 void lbuf_close(lbuf *b)
 196 {
 197   if (b->len && b->len != b->sz) {
 198     b->buf[b->len] = 0;
 199     b->func(b->buf, b->len, b->p);
 200   }
 201   if (b->buf) {
 202     x_free(b->a, b->buf);
 203     b->buf = 0;
 204   }
 205   b->f |= LBUF_CLOSE;
 206   if (b->f & LBUF_ENABLE)
 207     b->func(0, 0, b->p);
 208 }
 209
 210 /* --- @lbuf_free@ --- *
 211  *
 212  * Arguments:   @lbuf *b@ = pointer to buffer block
 213  *              @char **p@ = output pointer to free space
 214  *
 215  * Returns:     Free buffer size.
 216  *
 217  * Use:         Returns the free portion of a line buffer.  Data can then be
 218  *              written to this portion, and split out into lines by calling
 219  *              @lbuf_flush@.  A buffer is allocated if none currently
 220  *              exists.
 221  */
 222
 223 size_t lbuf_free(lbuf *b, char **p)
 224 {
 225   /* --- There's a special case to consider --- *
 226    *
 227    * If a line from the file wouldn't fit in the buffer, I truncate it and
 228    * return what would fit.  The rest of the line ought to be discarded.
 229    * This condition is signalled by @len = b->sz@, and means that the entire
 230    * buffer is OK to be trashed.  In other cases, @len@ is the amount of
 231    * space currently occupied in the buffer.  This special case is the reason
 232    * this routine exists.
 233    */
 234
 235   if (b->len != 0 && b->len != b->sz) {
 236     *p = b->buf + b->len;
 237     return (b->sz - b->len);
 238   } else {
 239     if (!b->buf)
 240       b->buf = x_alloc(b->a, b->sz);
 241     *p = b->buf;
 242     return (b->sz);
 243   }
 244 }
 245
 246 /* --- @lbuf_snarf@ --- *
 247  *
 248  * Arguments:   @lbuf *b@ = pointer to buffer block
 249  *              @const void *p@ = pointer to input data buffer
 250  *              @size_t sz@ = size of data in input buffer
 251  *
 252  * Returns:     ---
 253  *
 254  * Use:         Snarfs the data from the input buffer and spits it out as
 255  *              lines.  This interface ignores the complexities of dealing
 256  *              with disablement: you should be using @lbuf_free@ to
 257  *              contribute data if you want to cope with that.
 258  */
 259
 260 void lbuf_snarf(lbuf *b, const void *p, size_t sz)
 261 {
 262   const char *pp = p;
 263   while (sz && (b->f & LBUF_ENABLE)) {
 264     size_t bsz;
 265     char *bp;
 266
 267     bsz = lbuf_free(b, &bp);
 268     if (bsz > sz)
 269       bsz = sz;
 270     memcpy(bp, pp, bsz);
 271     lbuf_flush(b, bp, bsz);
 272     pp += bsz;
 273     sz -= bsz;
 274   }
 275 }
 276
 277 /* --- @lbuf_setsize@ --- *
 278  *
 279  * Arguments:   @lbuf *b@ = pointer to buffer block
 280  *              @size_t sz@ = requested maximum line size
 281  *
 282  * Returns:     ---
 283  *
 284  * Use:         Modifies the size of the buffer associated with the block.
 285  *              It is an error to resize a buffer while it contains data.
 286  */
 287
 288 void lbuf_setsize(lbuf *b, size_t sz)
 289 {
 290   if (b->buf)
 291   assert(((void)"Buffer in use in lbuf_setsize",
 292          b->len == 0 || b->len == b->sz));
 293   if (b->buf)
 294     x_free(b->a, b->buf);
 295   b->sz = sz;
 296   b->buf = 0;
 297 }
 298
 299 /* --- @lbuf_init@ --- *
 300  *
 301  * Arguments:   @lbuf *b@ = pointer to buffer block
 302  *              @lbuf_func *func@ = handler function
 303  *              @void *p@ = argument pointer for @func@
 304  *
 305  * Returns:     ---
 306  *
 307  * Use:         Initializes a line buffer block.  Any recognized lines are
 308  *              passed to @func@ for processing.  No buffer is initially
 309  *              allocated; this is done when the buffer is actually required
 310  *              for the first time.
 311  */
 312
 313 void lbuf_init(lbuf *b, lbuf_func *func, void *p)
 314 {
 315   b->func = func;
 316   b->p = p;
 317   b->len = 0;
 318   b->f = LBUF_ENABLE;
 319   b->delim = LBUF_CRLF;
 320   b->buf = 0;
 321   b->a = arena_global;
 322   lbuf_setsize(b, 256);
 323 }
 324
 325 /* --- @lbuf_destroy@ --- *
 326  *
 327  * Arguments:   @lbuf *b@ = pointer to buffer block
 328  *
 329  * Returns:     ---
 330  *
 331  * Use:         Deallocates a line buffer and frees any resources it owned.
 332  */
 333
 334 void lbuf_destroy(lbuf *b)
 335 {
 336   if (b->buf) {
 337     x_free(b->a, b->buf);
 338     b->buf = 0;
 339   }
 340 }
 341
 342 /*----- That's all, folks -------------------------------------------------*/