Line data Source code
1 : /* xmalloc.c -- safe versions of malloc and realloc */
2 :
3 : /* Copyright (C) 1991-2016 Free Software Foundation, Inc.
4 :
5 : This file is part of GNU Bash, the GNU Bourne Again SHell.
6 :
7 : Bash 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 : Bash 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 Bash. If not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #if defined (HAVE_CONFIG_H)
22 : #include <config.h>
23 : #endif
24 :
25 : #include "bashtypes.h"
26 : #include <stdio.h>
27 :
28 : #if defined (HAVE_UNISTD_H)
29 : # include <unistd.h>
30 : #endif
31 :
32 : #if defined (HAVE_STDLIB_H)
33 : # include <stdlib.h>
34 : #else
35 : # include "ansi_stdlib.h"
36 : #endif /* HAVE_STDLIB_H */
37 :
38 : #include "error.h"
39 :
40 : #include "bashintl.h"
41 :
42 : #if !defined (PTR_T)
43 : # if defined (__STDC__)
44 : # define PTR_T void *
45 : # else
46 : # define PTR_T char *
47 : # endif /* !__STDC__ */
48 : #endif /* !PTR_T */
49 :
50 : #if defined (HAVE_SBRK) && !HAVE_DECL_SBRK
51 : extern char *sbrk();
52 :
53 : static PTR_T lbreak;
54 : static int brkfound;
55 : static size_t allocated;
56 : #endif
57 :
58 : /* **************************************************************** */
59 : /* */
60 : /* Memory Allocation and Deallocation. */
61 : /* */
62 : /* **************************************************************** */
63 :
64 : #if defined (HAVE_SBRK) && defined (USING_BASH_MALLOC)
65 : #define FINDBRK() \
66 : do { \
67 : if (brkfound == 0) \
68 : { \
69 : lbreak = (PTR_T)sbrk (0); \
70 : brkfound++; \
71 : } \
72 : } while (0)
73 :
74 : static size_t
75 : findbrk ()
76 : {
77 : FINDBRK();
78 : return (char *)sbrk (0) - (char *)lbreak;
79 : }
80 : #else
81 : #define FINDBRK()
82 : #endif
83 :
84 : static void
85 0 : allocerr (func, bytes)
86 : const char *func;
87 : size_t bytes;
88 : {
89 : #if defined (HAVE_SBRK) && defined (USING_BASH_MALLOC)
90 : allocated = findbrk ();
91 : fatal_error (_("%s: cannot allocate %lu bytes (%lu bytes allocated)"), func, (unsigned long)bytes, (unsigned long)allocated);
92 : #else
93 0 : fatal_error (_("%s: cannot allocate %lu bytes"), func, (unsigned long)bytes);
94 : #endif /* !HAVE_SBRK */
95 0 : }
96 :
97 : /* Return a pointer to free()able block of memory large enough
98 : to hold BYTES number of bytes. If the memory cannot be allocated,
99 : print an error message and abort. */
100 : PTR_T
101 13883673466 : xmalloc (bytes)
102 : size_t bytes;
103 : {
104 13883673466 : PTR_T temp;
105 :
106 : #if defined (DEBUG)
107 : if (bytes == 0)
108 : internal_warning("xmalloc: size argument is 0");
109 : #endif
110 :
111 13883673466 : FINDBRK();
112 13883673466 : temp = malloc (bytes);
113 :
114 13883673466 : if (temp == 0)
115 0 : allocerr ("xmalloc", bytes);
116 :
117 13883673466 : return (temp);
118 : }
119 :
120 : PTR_T
121 1634429757 : xrealloc (pointer, bytes)
122 : PTR_T pointer;
123 : size_t bytes;
124 : {
125 1634429757 : PTR_T temp;
126 :
127 : #if defined (DEBUG)
128 : if (bytes == 0)
129 : internal_warning("xrealloc: size argument is 0");
130 : #endif
131 :
132 1634429757 : FINDBRK();
133 1634429757 : temp = pointer ? realloc (pointer, bytes) : malloc (bytes);
134 :
135 1634429757 : if (temp == 0)
136 0 : allocerr ("xrealloc", bytes);
137 :
138 1634429757 : return (temp);
139 : }
140 :
141 : /* Use this as the function to call when adding unwind protects so we
142 : don't need to know what free() returns. */
143 : void
144 1919531843 : xfree (string)
145 : PTR_T string;
146 : {
147 1919531843 : if (string)
148 1919516810 : free (string);
149 1919531843 : }
150 :
151 : #ifdef USING_BASH_MALLOC
152 : #include <malloc/shmalloc.h>
153 :
154 : static void
155 : sh_allocerr (func, bytes, file, line)
156 : const char *func;
157 : size_t bytes;
158 : char *file;
159 : int line;
160 : {
161 : #if defined (HAVE_SBRK)
162 : allocated = findbrk ();
163 : fatal_error (_("%s: %s:%d: cannot allocate %lu bytes (%lu bytes allocated)"), func, file, line, (unsigned long)bytes, (unsigned long)allocated);
164 : #else
165 : fatal_error (_("%s: %s:%d: cannot allocate %lu bytes"), func, file, line, (unsigned long)bytes);
166 : #endif /* !HAVE_SBRK */
167 : }
168 :
169 : PTR_T
170 : sh_xmalloc (bytes, file, line)
171 : size_t bytes;
172 : char *file;
173 : int line;
174 : {
175 : PTR_T temp;
176 :
177 : #if defined (DEBUG)
178 : if (bytes == 0)
179 : internal_warning("xmalloc: %s:%d: size argument is 0", file, line);
180 : #endif
181 :
182 : FINDBRK();
183 : temp = sh_malloc (bytes, file, line);
184 :
185 : if (temp == 0)
186 : sh_allocerr ("xmalloc", bytes, file, line);
187 :
188 : return (temp);
189 : }
190 :
191 : PTR_T
192 : sh_xrealloc (pointer, bytes, file, line)
193 : PTR_T pointer;
194 : size_t bytes;
195 : char *file;
196 : int line;
197 : {
198 : PTR_T temp;
199 :
200 : #if defined (DEBUG)
201 : if (bytes == 0)
202 : internal_warning("xrealloc: %s:%d: size argument is 0", file, line);
203 : #endif
204 :
205 : FINDBRK();
206 : temp = pointer ? sh_realloc (pointer, bytes, file, line) : sh_malloc (bytes, file, line);
207 :
208 : if (temp == 0)
209 : sh_allocerr ("xrealloc", bytes, file, line);
210 :
211 : return (temp);
212 : }
213 :
214 : void
215 : sh_xfree (string, file, line)
216 : PTR_T string;
217 : char *file;
218 : int line;
219 : {
220 : if (string)
221 : sh_free (string, file, line);
222 : }
223 : #endif
|
