/* PSPP - computes sample statistics.
Copyright (C) 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
#include "pool.h"
#include <stdlib.h>
#include "alloc.h"
+#include <libpspp/assertion.h>
#include "message.h"
#include "size_max.h"
#include "str.h"
/* DISCRETE_BLOCKS may be declared as nonzero to prevent
suballocation of blocks. This is useful under memory
- debuggers like Checker or valgrind because it allows the
- source location of bugs to be more accurately pinpointed.
+ debuggers like valgrind because it allows the source location
+ of bugs to be more accurately pinpointed.
On the other hand, if we're testing the library, then we want to
test the library's real functionality, not its crippled, slow,
return pool_malloc (pool, n * s);
}
+/* Allocates AMT bytes using malloc(), to be managed by POOL,
+ zeros the block, and returns a pointer to the beginning of the
+ block.
+ If POOL is a null pointer, then allocates a normal memory block
+ with xmalloc(). */
+void *
+pool_zalloc (struct pool *pool, size_t amt)
+{
+ void *p = pool_malloc (pool, amt);
+ memset (p, 0, amt);
+ return p;
+}
+
+/* Allocates and returns N elements of S bytes each, to be
+ managed by POOL, and zeros the block.
+ If POOL is a null pointer, then allocates a normal memory block
+ with malloc().
+ N must be nonnegative, S must be positive.
+ Terminates the program if the memory cannot be obtained,
+ including the case where N * S overflows the range of size_t. */
+void *
+pool_calloc (struct pool *pool, size_t n, size_t s)
+{
+ void *p = pool_nmalloc (pool, n, s);
+ memset (p, 0, n * s);
+ return p;
+}
+
/* Changes the allocation size of the specified memory block P managed
by POOL to AMT bytes and returns a pointer to the beginning of the
block.
assert (pool && file_name && mode);
f = fopen (file_name, mode);
- if (f == NULL)
- return NULL;
+ if (f != NULL)
+ pool_attach_file (pool, f);
return f;
}
}
/* Unregisters previously registered P from POOL.
- Returns nonzero only if P was found to be registered in POOL. */
-int
+ Returns true only if P was found to be registered in POOL. */
+bool
pool_unregister (struct pool *pool, void *p)
{
assert (pool && p);
if (g->type == POOL_GIZMO_REGISTERED && g->p.registered.p == p)
{
delete_gizmo (pool, g);
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
\f
/* Partial freeing. */
gizmo->p.registered.free (gizmo->p.registered.p);
break;
default:
- assert (0);
+ NOT_REACHED ();
}
}