Infrastructure: Strip away crufty CVS $Id$ tags.

[mLib] / lbuf.c

/* -*-c-*-
 *
 * 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.
 */

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

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

#include "alloc.h"
#include "arena.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 */

  if (b->f & LBUF_CLOSE) {
    b->func(0, 0, b->p);
    return;
  }

  /* --- 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 == b->sz)
    base = 0;
  else
    base = b->buf;

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

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

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

    switch (b->delim) {
      case LBUF_CRLF:
      case LBUF_STRICTCRLF:
	if (*q != '\r' && *q != '\n') {
	  cr = 0;
	  continue;
	}
	if (*q == '\r') {
	  cr = 1;
	  continue;
	}
	if (!cr && b->delim == LBUF_STRICTCRLF)
	  continue;
	break;
      default:
	if (*q != b->delim)
	  continue;
    }

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

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

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

  if (base) {
    len = l - base;
    if (len == b->sz) {
      b->buf[len - 1] = 0;
      b->func(base, len - 1, 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.  The buffer, if allocated, is freed.
 */

void lbuf_close(lbuf *b)
{
  if (b->len && b->len != b->sz) {
    b->buf[b->len] = 0;
    b->func(b->buf, b->len, b->p);
  }
  if (b->buf) {
    x_free(b->a, b->buf);
    b->buf = 0;
  }
  b->f |= LBUF_CLOSE;
  if (b->f & LBUF_ENABLE)
    b->func(0, 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@.  A buffer is allocated if none currently
 *		exists.
 */

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 = b->sz@, 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 != b->sz) {
    *p = b->buf + b->len;
    return (b->sz - b->len);
  } else {
    if (!b->buf)
      b->buf = x_alloc(b->a, b->sz);
    *p = b->buf;
    return (b->sz);
  }
}

/* --- @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 && (b->f & LBUF_ENABLE)) {
    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_setsize@ --- *
 *
 * Arguments:	@lbuf *b@ = pointer to buffer block
 *		@size_t sz@ = requested maximum line size
 *
 * Returns:	---
 *
 * Use:		Modifies the size of the buffer associated with the block.
 *		It is an error to resize a buffer while it contains data.
 */

void lbuf_setsize(lbuf *b, size_t sz)
{
  if (b->buf)
  assert(((void)"Buffer in use in lbuf_setsize",
	 b->len == 0 || b->len == b->sz));
  if (b->buf)
    x_free(b->a, b->buf);
  b->sz = sz;
  b->buf = 0;
}

/* --- @lbuf_init@ --- *
 *
 * Arguments:	@lbuf *b@ = pointer to buffer block
 *		@lbuf_func *func@ = handler function
 *		@void *p@ = argument pointer for @func@
 *
 * Returns:	---
 *
 * Use:		Initializes a line buffer block.  Any recognized lines are
 *		passed to @func@ for processing.  No buffer is initially
 *		allocated; this is done when the buffer is actually required
 *		for the first time.
 */

void lbuf_init(lbuf *b, lbuf_func *func, void *p)
{
  b->func = func;
  b->p = p;
  b->len = 0;
  b->f = LBUF_ENABLE;
  b->delim = LBUF_CRLF;
  b->buf = 0;
  b->a = arena_global;
  lbuf_setsize(b, 256);
}

/* --- @lbuf_destroy@ --- *
 *
 * Arguments:	@lbuf *b@ = pointer to buffer block
 *
 * Returns:	---
 *
 * Use:		Deallocates a line buffer and frees any resources it owned.
 */

void lbuf_destroy(lbuf *b)
{
  if (b->buf) {
    x_free(b->a, b->buf);
    b->buf = 0;
  }
}

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