[mLib] / lbuf.c

/* -*-c-*-
 *
 * $Id: lbuf.c,v 1.1 1999/05/14 21:01:14 mdw Exp $
 *
 * Block-to-line buffering
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * mLib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with mLib; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: lbuf.c,v $
 * Revision 1.1  1999/05/14 21:01:14  mdw
 * Integrated `select' handling bits from the background resolver project.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lbuf.h"

/*----- Main code ---------------------------------------------------------*/

/* --- @lbuf_flush@ --- *
 *
 * Arguments:   @lbuf *b@ = pointer to buffer block
 *              @char *p@ = pointer to where to start searching
 *              @size_t len@ = length of new material added
 *
 * Returns:     ---
 *
 * Use:         Flushes any complete lines in a line buffer.  New material
 *              is assumed to have been added starting at @p@.  If @p@ is
 *              null, then the scan starts at the beginning of the buffer,
 *              and the size of data already in the buffer is used in place
 *              of @len@.
 *
 *              It is assumed that the buffer is initially enabled.  You
 *              shouldn't be contributing data to a disabled buffer anyway.
 *              However, the buffer handler may at some point disable itself,
 *              and @lbuf_flush@ can cope with this eventuality.  Any pending
 *              data is left at the start of the buffer and can be flushed
 *              out by calling @lbuf_flush(b, 0, 0)@ if the buffer is ever
 *              re-enabled.
 */

void lbuf_flush(lbuf *b, char *p, size_t len)
{
  char *l;                              /* Limit of data in buffer */
  char *q;                              /* Roving pointer through string */
  char *base;                           /* Base address of current line */
  int cr;                               /* Carriage return state */

  /* --- Initialize variables as necessary --- */

  if (!p) {
    p = b->buf;
    cr = 0;
    len = b->len;
  } else
    cr = b->f & lbuf_cr;

  l = p + len;

  /* --- Clear @base@ if I'm discarding an overlong line --- */

  if (b->len == sizeof(b->buf))
    base = 0;
  else
    base = b->buf;

  /* --- Now I march through the string --- */

  for (q = p; q < l; q++) {

    /* --- Quickly discard uninteresting characters --- */

    if (*q != '\r' && *q != '\n') {
      cr = 0;
      continue;
    }
    if (*q == '\r') {
      cr = 1;
      continue;
    }

    /* --- Two choices here --- *
     *
     * I can either be strict about CRLF line ends, or I can be shoddy
     * and allow bare LFs.  I'll do the latter, although I oughtn't,
     * because it makes testing interactively and with Unix text files
     * easier.
     */

#ifdef STRICT_CRLF
    if (!cr)
      continue;
#endif  

    /* --- I have a positive ID on a linefeed --- *
     *
     * If I'm interested in this string, report it to my owner.
     */

    if (base) {
      if (cr)
        q[-1] = 0;                      /* Exercise: why is this safe? */
      else
        *q = 0;
      b->func(base, b->p);
      if (!(b->f & lbuf_enable)) {
        base = q + 1;
        break;
      }
    }
    base = q + 1;
    cr = 0;
  }

  /* --- Sift through the aftermath --- */

  if (base) {
    size_t len = l - base;
    if (len == sizeof(b->buf)) {
      b->buf[len - 1] = 0;
      b->func(base, b->p);
    } else if (base != b->buf)
      memmove(b->buf, base, len);
    b->len = len;
    if (cr)
      b->f |= lbuf_cr;
    else
      b->f &= ~lbuf_cr;
  }
}

/* --- @lbuf_close@ --- *
 *
 * Arguments:   @lbuf *b@ = pointer to buffer block
 *
 * Returns:     ---
 *
 * Use:         Empties the buffer of any data currently lurking in it, and
 *              informs the client that this has happened.  It's assumed that
 *              the buffer is enabled: you shouldn't be reading close events
 *              on disabled buffers.
 */

void lbuf_close(lbuf *b)
{
  if (b->len && b->len != sizeof(b->buf)) {
    b->buf[b->len] = 0;
    b->func(b->buf, b->p);
  }
  if (b->f & lbuf_enable)
    b->func(0, b->p);
}

/* --- @lbuf_free@ --- *
 *
 * Arguments:   @lbuf *b@ = pointer to buffer block
 *              @char **p@ = output pointer to free space
 *
 * Returns:     Free buffer size.
 *
 * Use:         Returns the free portion of a line buffer.  Data can then be
 *              written to this portion, and split out into lines by calling
 *              @lbuf_flush@.
 */

size_t lbuf_free(lbuf *b, char **p)
{
  /* --- There's a special case to consider --- *
   *
   * If a line from the file wouldn't fit in the buffer, I truncate it and
   * return what would fit.  The rest of the line ought to be discarded.
   * This condition is signalled by @len = sizeof(buf)@, and means that the
   * entire buffer is OK to be trashed.  In other cases, @len@ is the amount
   * of space currently occupied in the buffer.  This special case is the
   * reason this routine exists.
   */

  if (b->len == 0 || b->len == sizeof(b->buf)) {
    *p = b->buf + b->len;
    return (sizeof(b->buf) - b->len);
  } else {
    *p = b->buf;
    return (sizeof(b->buf));
  }
}

/* --- @lbuf_snarf@ --- *
 *
 * Arguments:   @lbuf *b@ = pointer to buffer block
 *              @const void *p@ = pointer to input data buffer
 *              @size_t sz@ = size of data in input buffer
 *
 * Returns:     ---
 *
 * Use:         Snarfs the data from the input buffer and spits it out as
 *              lines.  This interface ignores the complexities of dealing
 *              with disablement: you should be using @lbuf_free@ to
 *              contribute data if you want to cope with that.
 */

void lbuf_snarf(lbuf *b, const void *p, size_t sz)
{
  const char *pp = p;
  while (sz) {
    size_t bsz;
    char *bp;

    bsz = lbuf_free(b, &bp);
    if (bsz > sz)
      bsz = sz;
    memcpy(bp, pp, bsz);
    lbuf_flush(b, bp, bsz);
    pp += bsz;
    sz -= bsz;
  }
}

/* --- @lbuf_init@ --- *
 *
 * Arguments:   @lbuf *b@ = pointer to buffer block
 *              @void (*func)(char *s, void *p)@ = handler function
 *              @void *p@ = argument pointer for @func@
 *
 * Returns:     ---
 *
 * Use:         Initializes a line buffer block.  Any recognized lines are
 *              passed to @func@ for processing.
 */

void lbuf_init(lbuf *b,
               void (*func)(char */*s*/, void */*p*/),
               void *p)
{
  b->func = func;
  b->p = p;
  b->len = 0;
  b->f = lbuf_enable;
}

/*----- That's all, folks -------------------------------------------------*/