Mercurial > hg-old > index.cgi

comparison lib/xmalloc.c @ 265:68fbca173508 2.6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added generated files for release
author lost
date Tue, 22 Dec 2009 05:31:23 +0000
parents
children
comparison
equal deleted inserted replaced
264:61d1db1dfe2a 265:68fbca173508
1 /* xmalloc.c -- malloc with out of memory checking
2
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2008-2009 Free Software Foundation,
5 Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include <config.h>
21
22 #if ! HAVE_INLINE
23 # define static_inline
24 #endif
25 #include "xalloc.h"
26 #undef static_inline
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 /* 1 if calloc is known to be compatible with GNU calloc. This
32 matters if we are not also using the calloc module, which defines
33 HAVE_CALLOC and supports the GNU API even on non-GNU platforms. */
34 #if defined HAVE_CALLOC || defined __GLIBC__
35 enum { HAVE_GNU_CALLOC = 1 };
36 #else
37 enum { HAVE_GNU_CALLOC = 0 };
38 #endif
39
40 /* Allocate N bytes of memory dynamically, with error checking. */
41
42 void *
43 xmalloc (size_t n)
44 {
45 void *p = malloc (n);
46 if (!p && n != 0)
47 xalloc_die ();
48 return p;
49 }
50
51 /* Change the size of an allocated block of memory P to N bytes,
52 with error checking. */
53
54 void *
55 xrealloc (void *p, size_t n)
56 {
57 p = realloc (p, n);
58 if (!p && n != 0)
59 xalloc_die ();
60 return p;
61 }
62
63 /* If P is null, allocate a block of at least *PN bytes; otherwise,
64 reallocate P so that it contains more than *PN bytes. *PN must be
65 nonzero unless P is null. Set *PN to the new block's size, and
66 return the pointer to the new block. *PN is never set to zero, and
67 the returned pointer is never null. */
68
69 void *
70 x2realloc (void *p, size_t *pn)
71 {
72 return x2nrealloc (p, pn, 1);
73 }
74
75 /* Allocate S bytes of zeroed memory dynamically, with error checking.
76 There's no need for xnzalloc (N, S), since it would be equivalent
77 to xcalloc (N, S). */
78
79 void *
80 xzalloc (size_t s)
81 {
82 return memset (xmalloc (s), 0, s);
83 }
84
85 /* Allocate zeroed memory for N elements of S bytes, with error
86 checking. S must be nonzero. */
87
88 void *
89 xcalloc (size_t n, size_t s)
90 {
91 void *p;
92 /* Test for overflow, since some calloc implementations don't have
93 proper overflow checks. But omit overflow and size-zero tests if
94 HAVE_GNU_CALLOC, since GNU calloc catches overflow and never
95 returns NULL if successful. */
96 if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s))
97 || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))
98 xalloc_die ();
99 return p;
100 }
101
102 /* Clone an object P of size S, with error checking. There's no need
103 for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any
104 need for an arithmetic overflow check. */
105
106 void *
107 xmemdup (void const *p, size_t s)
108 {
109 return memcpy (xmalloc (s), p, s);
110 }
111
112 /* Clone STRING. */
113
114 char *
115 xstrdup (char const *string)
116 {
117 return xmemdup (string, strlen (string) + 1);
118 }