@@@ fltfmt mess

[mLib] / mem / alloc.c

/* -*-c-*-
 *
 * Memory allocation functions
 *
 * (c) 1998 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 ------------------------------------------------------*/

/* --- ANSI headers --- */

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

/* --- Local headers --- */

#include "alloc.h"
#include "arena.h"
#include "exc.h"

/*----- Functions and macros ----------------------------------------------*/

/* --- @x_alloc@, @x_allocn@ --- *
 *
 * Arguments:	@arena *a@ = pointer to underlying arena
 *		@size_t n@ = number of elements to allocate (for @x_allocv@)
 *		@size_t sz@ = size of elements to allocate
 *
 * Returns:	Pointer to allocated block.
 *
 * Use:		The @x_allocn@ function allocates memory for @n@ elements of
 *		@sz@ bytes each (or, perhaps, %%\emph{vice versa}).  The
 *		@x_alloc@ function is the same, but with @n@ fixed equal
 *		to 1.  If there's not enough memory, the exception
 *		@EXC_NOMEM@ is thrown.
 */

void *x_alloc(arena *a, size_t sz)
{
  void *p;

  p = A_ALLOC(a, sz);
    if (!p) THROW(EXC_NOMEM);
    else return (p);
}

void *x_allocv(arena *a, size_t n, size_t sz)
{
  void *p;

  p = A_ALLOCV(a, n, sz);
    if (!p) THROW(EXC_NOMEM);
    else return (p);
}

/* --- @x_strdup@ --- *
 *
 * Arguments:	@arena *a@ = pointer to underlying arena
 *		@const char *s@ = pointer to a string
 *
 * Returns:	Pointer to a copy of the string.
 *
 * Use:		Copies a string (like @strdup@ would, if it existed).  If
 *		there's not enough memory, the exception @EXC_NOMEM@ is
 *		thrown.
 */

char *x_strdup(arena *a, const char *s)
{
  char *p; size_t sz;

  sz = strlen(s) + 1; p = x_alloc(a, sz); memcpy(p, s, sz);
  return (p);
}

/* --- @x_realloc@, @x_reallocv@ --- *
 *
 * Arguments:	@arena *a@ = pointer to underlying arena
 *		@void *p@ = pointer to a block of memory
 *		@size_t n@ = new number of elements (for @x_reallocv@)
 *		@size_t on@ = old  number of elements (for @x_reallocv@)
 *		@size_t sz@ = size of elements (for @x_reallocv@) or new
 *			block size (for @x_realloc@)
 *		@size_t osz@ = size of the old block (for @x_realloc@)
 *
 * Returns:	Pointer to the resized memory block (which is almost
 *		certainly not in the same place any more).
 *
 * Use:		Resizes a memory block.  If there's not enough memory, the
 *		exception @EXC_NOMEM@ is thrown.
 *
 *		The @x_reallocv@ function adjusts a block which currently has
 *		space for @on@ elements each of size @sz@, so that it now has
 *		enough space for @n@ elements, preserving the initial @min(n,
 *		on)@ elements.  The @x_realloc@ function is the same, but
 *		with @sz@ fixed equal to 1, and @n@ and @on@ renamed to @sz@
 *		and @osz@ for historical reasons.
 */

void *x_realloc(arena *a, void *p, size_t sz, size_t osz)
{
  p = A_REALLOC(a, p, sz, osz);
    if (!p) THROW(EXC_NOMEM);
    else return (p);
}

void *x_reallocv(arena *a, void *p, size_t n, size_t on, size_t sz)
{
  p = A_REALLOCV(a, p, n, on, sz);
    if (!p) THROW(EXC_NOMEM);
    else return (p);
}

/* --- @x_free@ --- *
 *
 * Arguments:	@arena *a@ = pointer to underlying arena
 *		@void *p@ = pointer to a block of memory.
 *
 * Returns:	---
 *
 * Use:		Frees a block of memory.
 */

void (x_free)(arena *a, void *p) { x_free(a, p); }

/*----- Old functions for the standard arena ------------------------------*/

/* --- @xmalloc@, @xmallocv@ --- *
 *
 * Arguments:	@size_t n@ = number of elements to allocate (for @xmallocv@)
 *		@size_t sz@ = size of block to allocate
 *
 * Returns:	Pointer to allocated block.
 *
 * Use:		Allocates memory for @n@ elements each of size @sz@.  For
 *		@xmalloc@, @n@ is fixed equal to 1.  If there's not enough
 *		memory, the exception @EXC_NOMEM@ is thrown.
 */

void *(xmalloc)(size_t sz) { return xmalloc(sz); }
void *(xmallocv)(size_t n, size_t sz) { return xmallocv(n, sz); }

/* --- @xstrdup@ --- *
 *
 * Arguments:	@const char *s@ = pointer to a string
 *
 * Returns:	Pointer to a copy of the string.
 *
 * Use:		Copies a string (like @strdup@ would, if it existed).  If
 *		there's not enough memory, the exception @EXC_NOMEM@ is
 *		thrown.
 */

char *(xstrdup)(const char *s) { return xstrdup(s); }

/* --- @xrealloc@, @xreallocv@ --- *
 *
 * Arguments:	@void *p@ = pointer to a block of memory
 *		@size_t n@ = new number of elements (for @xreallocv@)
 *		@size_t on@ = old  number of elements (for @xreallocv@)
 *		@size_t sz@ = size of elements (for @xreallocv@) or new
 *			block size (for @xrealloc@)
 *		@size_t osz@ = size of the old block (for @xrealloc@)
 *
 * Returns:	Pointer to the resized memory block (which is almost
 *		certainly not in the same place any more).
 *
 * Use:		Resizes a memory block.  If there's not enough memory, the
 *		exception @EXC_NOMEM@ is thrown.
 *
 *		The @xreallocv@ function adjusts a block which currently has
 *		space for @on@ elements each of size @sz@, so that it now has
 *		enough space for @n@ elements, preserving the initial @min(n,
 *		on)@ elements.  The @xrealloc@ function is the same, but
 *		with @sz@ fixed equal to 1, and @n@ and @on@ renamed to @sz@
 *		and @osz@ for historical reasons.
 */

void *(xrealloc)(void *p, size_t sz, size_t osz)
  { return xrealloc(p, sz, osz); }
void *(xreallocv)(void *p, size_t n, size_t on, size_t sz)
  { return xreallocv(p, n, on, sz); }

/* --- @xfree@ --- *
 *
 * Arguments:	@void *p@ = pointer to a block of memory.
 *
 * Returns:	---
 *
 * Use:		Frees a block of memory.
 */

void (xfree)(void *p) { xfree(p); }

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