mbuf.c

Go to the documentation of this file.

/*****************************************************************************\
 *  Copyright  1994  The Board of Trustees of the University of Illinois.
 *  All rights reserved.
 *
 *  mbuf.c, part of the IMPACT in-memory file interface
 *  John C. Gyllenhaal, Wen-mei Hwu, and The IMPACT Research Group
 *  Coordinated Science Laboratory
 *  University of Illinois at Urbana-Champaign
 *
 *  The IMPACT Research Group may be contacted at impact@crhc.uiuc.edu.
 *
 *  mbuf.c (part of the IMPACT in-memory file interface),
 *  including both binary and source (hereafter, Software) is copyrighted by
 *  The Board of Trustees of the University of Illinois (UI),
 *  and ownership remains with the UI.
 *
 *  The UI grants you (hereafter, Licensee) a license to use the Software for
 *  academic, research and internal business purposes only, without a fee.
 *  Licensee may distribute the Software to third parties provided that the
 *  copyright notice and this statement appears on all copies and that no
 *  charge is associated with such copies.
 *
 *  Licensee may make derivative works.  However, if Licensee distributes
 *  any derivative work based on or derived from the Software, then Licensee
 *  will clearly notify users that such derivative work is a modified
 *  version and not the original Software distributed by the UI.
 *
 *  Any Licensee wishing to make commercial use of the Software should contact
 *  the UI, c/o the Research and Technology Management Office [rtmo@uiuc.edu],
 *  to negotiate an appropriate license for such commercial use.  Commercial
 *  use includes (1) integration of all or part of the source code into a
 *  product for sale or license by or on behalf of Licensee to third parties,
 *  or (2) distribution of the Software to third parties that need it to
 *  utilize a commercial product sold or licensed by or on behalf of Licensee.
 *
 *  UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
 *  ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
 *  THE UI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE USERS OF THIS
 *  SOFTWARE.
 *
 *  By using or copying this Software, Licensee agrees to abide by the
 *  copyright law and all other applicable laws of the U.S. including, but
 *  not limited to, export control laws, and the terms of this license.
 *  UI shall have the right to terminate this license immediately by written
 *  notice upon Licensee's breach of, or non-compliance with, any of its terms.
 *  Licensee may be held legally responsible for any copyright infringement
 *  that is caused or encouraged by Licensee's failure to abide by the terms
 *  of this license.
 *
 *  Form approved by University Counsel, M.A.R., 05/10/93
\*****************************************************************************/
/*****************************************************************************\
 *
 *  File:  mbuf.c
 *
 *  Description:  Self-resizing buffer useful for reading in files
 *
 *  Creation Date :  October 1994
 *
 *  Authors:  John C. Gyllenhaal, Wen-mei Hwu
 *
 *  Revisions:
 *
\*****************************************************************************/

#ifndef lint
#define lint
static char copyright[] =
"@(#) Copyright (c) 1994 The Board of Trustees of the University of Illinois.\
\nAll rights reserved.\n";
#endif

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

#include "mbuf.h"
#include "l_punt.h"

/* Declare external functions that must be defined by user */
void L_punt (char *msg, ...);

L_Alloc_Pool *Mbuf_pool = NULL;

Mbuf *create_Mbuf()
{
    Mbuf *mbuf;

    /* Get memory for mbuf, alloc pool on first use */
    if (Mbuf_pool == NULL)
    {
        Mbuf_pool = L_create_alloc_pool ("Mbuf", sizeof (Mbuf), 16);
    }
    mbuf = (Mbuf *) L_alloc (Mbuf_pool);

    /* Initialize fields */
    mbuf->buf = NULL;

    clear_Mbuf (mbuf);

    /* Return mbuf ready to go */
    return (mbuf);
}

void free_Mbuf(Mbuf *mbuf)
{
    /* Free buffer, then mbuf */
    free (mbuf->buf);
    L_free (Mbuf_pool, mbuf);
}


void clear_Mbuf(Mbuf *mbuf)
{
    /* If never initialized before, malloc initial buffer */
    if (mbuf->buf == NULL)
    {
        mbuf->max_len = 2;
        if ((mbuf->buf = (char *) malloc (mbuf->max_len)) == NULL)
            L_punt ("Out of memory in clear_Mbuf");
    }

    /* Clear out buffer */
    mbuf->cur_len = 0;
    mbuf->buf[0] = 0;
}

void addc_to_Mbuf(Mbuf *mbuf, char ch)
{
    char *old_buf;

    /* If at end of current buffer, malloc new one and copy over
     * contents.
     */
    if ((mbuf->cur_len + 1) >= mbuf->max_len)
    {
        old_buf = mbuf->buf;

        /* Double size of buffer */
        mbuf->max_len = mbuf->max_len * 2;

        /* Malloc new buffer */
        if ((mbuf->buf = (char *) malloc (mbuf->max_len)) == NULL)
            L_punt ("Out of memory in addc_to_Mbuf");

        /* Copy over old buffer */
        strcpy (mbuf->buf, old_buf);

        /* Free old buffer */
        free (old_buf);
   }

    /* Add character to buf (and terminate) */
    mbuf->buf[mbuf->cur_len] = ch;
    mbuf->buf[mbuf->cur_len + 1] = 0;
    mbuf->cur_len++;
}

void adds_to_Mbuf (Mbuf *mbuf, char *str)
{
    char *ptr;

    for (ptr = str; *ptr != 0; ptr++)
        addc_to_Mbuf (mbuf, *ptr);
}

/* Pads buffer until length specified.  Does nothing if aleady longer 
 * than desired length
 */
void pad_Mbuf_to_len (Mbuf *mbuf, int desired_len, char pad_ch)
{
    while (desired_len > mbuf->cur_len)
        addc_to_Mbuf (mbuf, pad_ch);
}

/* Strips trailing whitespace from mbuf */
void strip_Mbuf (Mbuf *mbuf)
{
    int i;

    /* Find last non-whitespace */
    for (i=mbuf->cur_len - 1; i>= 0; i--)
    {
        if (!isspace(mbuf->buf[i]))
            break;
    }

    /* Adjust length and terminator */
    mbuf->cur_len = i + 1;
    mbuf->buf[i+1] = 0;
}

/* return's a pointer to the actual mbuf (must not write to or free) */
char *get_Mbuf_buf (Mbuf *mbuf)
{
    return (mbuf->buf);
}

/* Copy mbuf's contents, may have NULLs in string so use len info */
char *copy_Mbuf_buf(Mbuf *mbuf)
{
    char *buf, *src_buf;
    int i, len;

    len = mbuf->cur_len;

    if ((buf = (char *) malloc (len + 1)) == NULL)
        L_punt ("copy_Mbuf_buf: Out of memory");

    src_buf = mbuf->buf;
    for (i=0; i < len; i++)
        buf[i] = src_buf[i];

    /* Terminate string */
    buf[len] = 0;

    return (buf);
}


/* Returns length of mbuf */
int len_of_Mbuf (Mbuf *mbuf)
{
    return (mbuf->cur_len);
}

/* Returns 1 if string matches mbuf, 0 otherwise */
int match_Mbuf (Mbuf *mbuf, char *string)
{
    if (strcmp (mbuf->buf, string) == 0)
        return (1);
    else
        return (0);
}

---