]>
Commit | Line | Data |
---|---|---|
885824d3 | 1 | /* |
2 | * defines for the dmalloc library | |
3 | * | |
4 | * Copyright 1995 by Gray Watson | |
5 | * | |
6 | * This file is part of the dmalloc package. | |
7 | * | |
8 | * Permission to use, copy, modify, and distribute this software for any | |
9 | * NON-COMMERCIAL purpose and without fee is hereby granted, provided | |
10 | * that the above copyright notice and this permission notice appear | |
11 | * in all copies, and that the name of Gray Watson not be used in | |
12 | * advertising or publicity pertaining to distribution of the document | |
13 | * or software without specific, written prior permission. | |
14 | * | |
15 | * Gray Watson makes no representations about the suitability of the | |
16 | * software described herein for any purpose. It is provided "as is" | |
17 | * without express or implied warranty. | |
18 | * | |
19 | * The author may be contacted at gray.watson@letters.com | |
20 | * | |
21 | * $Id$ | |
22 | */ | |
23 | ||
24 | #ifndef __DMALLOC_H__ | |
25 | #define __DMALLOC_H__ | |
26 | ||
27 | /* this is inserted into dmalloc.h */ | |
28 | /* used to handle the const operator */ | |
29 | /* const is available */ | |
30 | ||
31 | /* NOTE: start of $Id$ */ | |
32 | ||
33 | /* | |
34 | * NOTE: some archetectures have malloc, realloc, etc. using size_t or | |
35 | * an unsigned long instead of the traditional unsigned int. You may | |
36 | * have to edit this by hand due to the difficulties I am having | |
37 | * getting it to auto configure. Finding the definition of size_t in | |
38 | * the /usr/include files may be a good guess. YEACH!! | |
39 | * | |
40 | * Uncomment the include file and set to the correct file which | |
41 | * defines the size type, if necessary. | |
42 | */ | |
43 | #define DMALLOC_SIZE unsigned long | |
44 | /* #include <sys/types.h> */ | |
45 | ||
46 | /* this defines what type the standard void memory-pointer is */ | |
47 | #if defined(__STDC__) && __STDC__ == 1 | |
48 | #define DMALLOC_PNT void * | |
49 | #define DMALLOC_FREE_RET void | |
50 | #else | |
51 | #define DMALLOC_PNT void * | |
52 | #define DMALLOC_FREE_RET void | |
53 | #endif | |
54 | ||
55 | /* | |
56 | * malloc function return codes | |
57 | */ | |
58 | #define CALLOC_ERROR 0L /* error from calloc */ | |
59 | #define MALLOC_ERROR 0L /* error from malloc */ | |
60 | #define REALLOC_ERROR 0L /* error from realloc */ | |
61 | ||
62 | /* NOTE: this if for non- __STDC__ systems only */ | |
63 | #define FREE_ERROR 0 /* error from free */ | |
64 | #define FREE_NOERROR 1 /* no error from free */ | |
65 | ||
66 | #define DMALLOC_VERIFY_ERROR 0 /* checks failed, error */ | |
67 | #define DMALLOC_VERIFY_NOERROR 1 /* checks passed, no error */ | |
68 | ||
69 | /* | |
70 | * default values if _malloc_file and _malloc_line are not set | |
71 | */ | |
72 | #define DMALLOC_DEFAULT_FILE 0L | |
73 | #define DMALLOC_DEFAULT_LINE 0 | |
74 | #define DMALLOC_UNKNOWN_FILE "unknown" | |
75 | ||
76 | /* | |
77 | * alloc macros to improve memory usage readibility... | |
78 | */ | |
79 | #undef ALLOC | |
80 | #define ALLOC(type, count) \ | |
81 | (type *)malloc((DMALLOC_SIZE)(sizeof(type) * (count))) | |
82 | ||
83 | #undef MALLOC | |
84 | #define MALLOC(size) \ | |
85 | (char *)malloc((DMALLOC_SIZE)(size)) | |
86 | ||
87 | /* NOTICE: the arguments are REVERSED from normal calloc() */ | |
88 | #undef CALLOC | |
89 | #define CALLOC(type, count) \ | |
90 | (type *)calloc((DMALLOC_SIZE)(count), (DMALLOC_SIZE)sizeof(type)) | |
91 | ||
92 | #undef REALLOC | |
93 | #define REALLOC(ptr, type, count) \ | |
94 | (type *)realloc((char *)(ptr), (DMALLOC_SIZE)(sizeof(type) * (count))) | |
95 | ||
96 | #undef REMALLOC | |
97 | #define REMALLOC(ptr, size) \ | |
98 | (char *)realloc((char *)(ptr), (DMALLOC_SIZE)(size)) | |
99 | ||
100 | #undef FREE | |
101 | #define FREE(ptr) \ | |
102 | free((char *)(ptr)) | |
103 | ||
104 | /*<<<<<<<<<< The below prototypes are auto-generated by fillproto */ | |
105 | ||
106 | #ifdef __cplusplus | |
107 | extern "C" { | |
108 | #endif | |
109 | ||
110 | /* logfile for dumping dmalloc info, DMALLOC_LOGFILE env var overrides this */ | |
111 | extern char *dmalloc_logpath; | |
112 | ||
113 | /* internal dmalloc error number for reference purposes only */ | |
114 | extern int dmalloc_errno; | |
115 | ||
116 | /* address to look for. when discovered call dmalloc_error() */ | |
117 | extern DMALLOC_PNT dmalloc_address; | |
118 | ||
119 | /* | |
120 | * argument to dmalloc_address, if 0 then never call dmalloc_error() | |
121 | * else call it after seeing dmalloc_address for this many times. | |
122 | */ | |
123 | extern int dmalloc_address_count; | |
124 | ||
125 | /* | |
126 | * shutdown memory-allocation module, provide statistics if necessary | |
127 | */ | |
128 | extern void dmalloc_shutdown(void); | |
129 | ||
130 | /* | |
131 | * allocate and return a SIZE block of bytes. returns 0L on error. | |
132 | */ | |
133 | extern DMALLOC_PNT malloc(DMALLOC_SIZE size); | |
134 | ||
135 | /* | |
136 | * allocate and return a block of bytes able to hold NUM_ELEMENTS of elements | |
137 | * of SIZE bytes and zero the block. returns 0L on error. | |
138 | */ | |
139 | extern DMALLOC_PNT calloc(DMALLOC_SIZE num_elements, DMALLOC_SIZE size); | |
140 | ||
141 | /* | |
142 | * resizes OLD_PNT to SIZE bytes and return the new space after either copying | |
143 | * all of OLD_PNT to the new area or truncating. returns 0L on error. | |
144 | */ | |
145 | extern DMALLOC_PNT realloc(DMALLOC_PNT old_pnt, DMALLOC_SIZE new_size); | |
146 | ||
147 | /* | |
148 | * release PNT in the heap, returning FREE_ERROR, FREE_NOERROR or void | |
149 | * depending on whether STDC is defined by your compiler. | |
150 | */ | |
151 | extern DMALLOC_FREE_RET free(DMALLOC_PNT pnt); | |
152 | ||
153 | /* | |
154 | * same as free(PNT) | |
155 | */ | |
156 | extern DMALLOC_FREE_RET cfree(DMALLOC_PNT pnt); | |
157 | ||
158 | /* | |
159 | * log the heap structure plus information on the blocks if necessary. | |
160 | */ | |
161 | extern void dmalloc_log_heap_map(void); | |
162 | ||
163 | /* | |
164 | * dump dmalloc statistics to logfile | |
165 | */ | |
166 | extern void dmalloc_log_stats(void); | |
167 | ||
168 | /* | |
169 | * dump unfreed-memory info to logfile | |
170 | */ | |
171 | extern void dmalloc_log_unfreed(void); | |
172 | ||
173 | /* | |
174 | * verify pointer PNT, if PNT is 0 then check the entire heap. | |
175 | * returns MALLOC_VERIFY_ERROR or MALLOC_VERIFY_NOERROR | |
176 | */ | |
177 | extern int dmalloc_verify(const DMALLOC_PNT pnt); | |
178 | ||
179 | /* | |
180 | * same as dmalloc_verify | |
181 | */ | |
182 | extern int _malloc_verify(const DMALLOC_PNT pnt); | |
183 | ||
184 | /* | |
185 | * set the global debug functionality flags to DEBUG (0 to disable). | |
186 | * NOTE: after this module has started up, you cannot set certain flags | |
187 | * such as fence-post or free-space checking. | |
188 | */ | |
189 | extern void dmalloc_debug(const int debug); | |
190 | ||
191 | /* | |
192 | * returns the current debug functionality flags. this allows you to | |
193 | * save a dmalloc library state to be restored later. | |
194 | */ | |
195 | extern int dmalloc_debug_current(void); | |
196 | ||
197 | /* | |
198 | * examine pointer PNT and returns SIZE, and FILE / LINE info on it, | |
199 | * or return-address RET_ADDR if any of the pointers are not 0L. | |
200 | * if FILE returns 0L then RET_ATTR may have a value and vice versa. | |
201 | * returns NOERROR or ERROR depending on whether PNT is good or not | |
202 | */ | |
203 | extern int dmalloc_examine(const DMALLOC_PNT pnt, DMALLOC_SIZE * size, | |
204 | char ** file, unsigned int * line, | |
205 | DMALLOC_PNT * ret_attr); | |
206 | ||
207 | /* | |
208 | * dmalloc version of strerror to return the string version of ERRNUM | |
209 | * returns the string for MALLOC_BAD_ERRNO if ERRNUM is out-of-range. | |
210 | */ | |
211 | extern char *dmalloc_strerror(const int errnum); | |
212 | ||
213 | #ifdef __cplusplus | |
214 | } | |
215 | #endif | |
216 | ||
217 | /*<<<<<<<<<< This is end of the auto-generated output from fillproto. */ | |
218 | ||
219 | /* | |
220 | * alloc macros to provide for memory FILE/LINE debugging information. | |
221 | */ | |
222 | ||
223 | #ifndef DMALLOC_DISABLE | |
224 | ||
225 | #undef calloc | |
226 | #define calloc(count, size) \ | |
227 | _calloc_leap(__FILE__, __LINE__, count, size) | |
228 | #undef free | |
229 | #define free(ptr) \ | |
230 | _free_leap(__FILE__, __LINE__, ptr) | |
231 | #undef malloc | |
232 | #define malloc(size) \ | |
233 | _malloc_leap(__FILE__, __LINE__, size) | |
234 | #undef realloc | |
235 | #define realloc(ptr, size) \ | |
236 | _realloc_leap(__FILE__, __LINE__, ptr, size) | |
237 | ||
238 | #undef xcalloc | |
239 | #define xcalloc(count, size) \ | |
240 | _xcalloc_leap(__FILE__, __LINE__, count, size) | |
241 | #undef xfree | |
242 | #define xfree(ptr) \ | |
243 | _xfree_leap(__FILE__, __LINE__, ptr) | |
244 | #undef xmalloc | |
245 | #define xmalloc(size) \ | |
246 | _xmalloc_leap(__FILE__, __LINE__, size) | |
247 | #undef xrealloc | |
248 | #define xrealloc(ptr, size) \ | |
249 | _xrealloc_leap(__FILE__, __LINE__, ptr, size) | |
250 | #undef xstrdup | |
251 | #define xstrdup(str) \ | |
252 | _xstrdup_leap(__FILE__, __LINE__, str) | |
253 | ||
254 | #ifdef DMALLOC_FUNC_CHECK | |
255 | ||
256 | /* | |
257 | * do debugging on the following functions. this may cause compilation or | |
258 | * other problems depending on your architecture. | |
259 | */ | |
260 | #undef bcmp | |
261 | #define bcmp(b1, b2, len) _dmalloc_bcmp(b1, b2, len) | |
262 | #undef bcopy | |
263 | #define bcopy(from, to, len) _dmalloc_bcopy(from, to, len) | |
264 | ||
265 | #undef memcmp | |
266 | #define memcmp(b1, b2, len) _dmalloc_memcmp(b1, b2, len) | |
267 | #undef memcpy | |
268 | #define memcpy(to, from, len) _dmalloc_memcpy(to, from, len) | |
269 | #undef memset | |
270 | #define memset(buf, ch, len) _dmalloc_memset(buf, ch, len) | |
271 | ||
272 | #undef index | |
273 | #define index(str, ch) _dmalloc_index(str, ch) | |
274 | #undef rindex | |
275 | #define rindex(str, ch) _dmalloc_rindex(str, ch) | |
276 | ||
277 | #undef strcat | |
278 | #define strcat(to, from) _dmalloc_strcat(to, from) | |
279 | #undef strcmp | |
280 | #define strcmp(s1, s2) _dmalloc_strcmp(s1, s2) | |
281 | #undef strlen | |
282 | #define strlen(str) _dmalloc_strlen(str) | |
283 | #undef strtok | |
284 | #define strtok(str, sep) _dmalloc_strtok(str, sep) | |
285 | ||
286 | #undef bzero | |
287 | #define bzero(buf, len) _dmalloc_bzero(buf, len) | |
288 | ||
289 | #undef memccpy | |
290 | #define memccpy(s1, s2, ch, len) _dmalloc_memccpy(s1, s2, ch, len) | |
291 | #undef memchr | |
292 | #define memchr(s1, ch, len) _dmalloc_memchr(s1, ch, len) | |
293 | ||
294 | #undef strchr | |
295 | #define strchr(str, ch) _dmalloc_strchr(str, ch) | |
296 | #undef strrchr | |
297 | #define strrchr(str, ch) _dmalloc_strrchr(str, ch) | |
298 | ||
299 | #undef strcpy | |
300 | #define strcpy(to, from) _dmalloc_strcpy(to, from) | |
301 | #undef strncpy | |
302 | #define strncpy(to, from, len) _dmalloc_strncpy(to, from, len) | |
303 | #undef strcasecmp | |
304 | #define strcasecmp(s1, s2) _dmalloc_strcasecmp(s1, s2) | |
305 | #undef strncasecmp | |
306 | #define strncasecmp(s1, s2, len) _dmalloc_strncasecmp(s1, s2, len) | |
307 | #undef strspn | |
308 | #define strspn(str, list) _dmalloc_strspn(str, list) | |
309 | #undef strcspn | |
310 | #define strcspn(str, list) _dmalloc_strcspn(str, list) | |
311 | #undef strncat | |
312 | #define strncat(to, from, len) _dmalloc_strncat(to, from, len) | |
313 | #undef strncmp | |
314 | #define strncmp(s1, s2, len) _dmalloc_strncmp(s1, s2, len) | |
315 | #undef strpbrk | |
316 | #define strpbrk(str, list) _dmalloc_strpbrk(str, list) | |
317 | #undef strstr | |
318 | #define strstr(str, pat) _dmalloc_strstr(str, pat) | |
319 | ||
320 | /* | |
321 | * feel free to add your favorite functions here and to arg_check.[ch] | |
322 | */ | |
323 | ||
324 | #ifdef __cplusplus | |
325 | extern "C" { | |
326 | #endif | |
327 | ||
328 | /* | |
329 | * copied in from arg_check.h with IMPORT -> extern, all comments removed | |
330 | */ | |
331 | extern int _dmalloc_bcmp(const void * b1, const void * b2, | |
332 | const DMALLOC_SIZE len); | |
333 | extern void _dmalloc_bcopy(const char * from, char * to, | |
334 | const DMALLOC_SIZE len); | |
335 | extern int _dmalloc_memcmp(const void * b1, const void * b2, | |
336 | const DMALLOC_SIZE len); | |
337 | extern char *_dmalloc_memcpy(char * to, const char * from, | |
338 | const DMALLOC_SIZE len); | |
339 | extern char *_dmalloc_memset(void * buf, const char ch, | |
340 | const DMALLOC_SIZE len); | |
341 | extern char *_dmalloc_index(const char * str, const char ch); | |
342 | extern char *_dmalloc_rindex(const char * str, const char ch); | |
343 | extern char *_dmalloc_strcat(char * to, const char * from); | |
344 | extern int _dmalloc_strcmp(const char * s1, const char * s2); | |
345 | extern DMALLOC_SIZE _dmalloc_strlen(const char * str); | |
346 | extern char *_dmalloc_strtok(char * str, const char * sep); | |
347 | extern void _dmalloc_bzero(void * buf, const DMALLOC_SIZE len); | |
348 | extern char *_dmalloc_memccpy(char * s1, const char * s2, const char ch, | |
349 | const DMALLOC_SIZE len); | |
350 | extern char *_dmalloc_memchr(const char * s1, const char ch, | |
351 | const DMALLOC_SIZE len); | |
352 | extern char *_dmalloc_strchr(const char * str, const char ch); | |
353 | extern char *_dmalloc_strrchr(const char * str, const char ch); | |
354 | extern char *_dmalloc_strcpy(char * to, const char * from); | |
355 | extern char *_dmalloc_strncpy(char * to, const char * from, | |
356 | const DMALLOC_SIZE len); | |
357 | extern int _dmalloc_strcasecmp(const char * s1, const char * s2); | |
358 | extern int _dmalloc_strncasecmp(const char * s1, const char * s2, | |
359 | const DMALLOC_SIZE len); | |
360 | extern int _dmalloc_strspn(const char * str, const char * list); | |
361 | extern int _dmalloc_strcspn(const char * str, const char * list); | |
362 | extern char *_dmalloc_strncat(char * to, const char * from, | |
363 | const DMALLOC_SIZE len); | |
364 | extern int _dmalloc_strncmp(const char * s1, const char * s2, | |
365 | const DMALLOC_SIZE len); | |
366 | extern char *_dmalloc_strpbrk(const char * str, const char * list); | |
367 | extern char *_dmalloc_strstr(const char * str, const char * pat); | |
368 | ||
369 | #ifdef __cplusplus | |
370 | } | |
371 | #endif | |
372 | ||
373 | #endif /* DMALLOC_FUNC_CHECK */ | |
374 | ||
375 | #ifdef __cplusplus | |
376 | extern "C" { | |
377 | #endif | |
378 | ||
379 | /* | |
380 | * copied directly from malloc_lp.h with IMPORT -> extern, routines trimmed | |
381 | */ | |
382 | /* to inform the dmalloc library from which file the call comes from */ | |
383 | extern char *_dmalloc_file; | |
384 | ||
385 | /* to inform the library from which line-number the call comes from */ | |
386 | extern unsigned int _dmalloc_line; | |
387 | ||
388 | /* | |
389 | * leap routine to calloc | |
390 | */ | |
391 | extern DMALLOC_PNT _calloc_leap(const char * file, const int line, | |
392 | DMALLOC_SIZE elen, DMALLOC_SIZE size); | |
393 | ||
394 | /* | |
395 | * leap routine to free | |
396 | */ | |
397 | extern DMALLOC_FREE_RET _free_leap(const char * file, const int line, | |
398 | DMALLOC_PNT pnt); | |
399 | ||
400 | /* | |
401 | * leap routine to malloc | |
402 | */ | |
403 | extern DMALLOC_PNT _malloc_leap(const char * file, const int line, | |
404 | DMALLOC_SIZE size); | |
405 | ||
406 | /* | |
407 | * leap routine to realloc | |
408 | */ | |
409 | extern DMALLOC_PNT _realloc_leap(const char * file, const int line, | |
410 | DMALLOC_PNT oldp, DMALLOC_SIZE new_size); | |
411 | ||
412 | /* | |
413 | * leap routine to calloc with error checking | |
414 | */ | |
415 | extern DMALLOC_PNT _xcalloc_leap(const char * file, const int line, | |
416 | DMALLOC_SIZE elen, DMALLOC_SIZE size); | |
417 | ||
418 | /* | |
419 | * leap routine to free | |
420 | */ | |
421 | extern DMALLOC_FREE_RET _xfree_leap(const char * file, const int line, | |
422 | DMALLOC_PNT pnt); | |
423 | ||
424 | /* | |
425 | * leap routine to malloc with error checking | |
426 | */ | |
427 | extern DMALLOC_PNT _xmalloc_leap(const char * file, const int line, | |
428 | DMALLOC_SIZE size); | |
429 | ||
430 | /* | |
431 | * leap routine to realloc with error checking | |
432 | */ | |
433 | extern DMALLOC_PNT _xrealloc_leap(const char * file, const int line, | |
434 | DMALLOC_PNT oldp, DMALLOC_SIZE new_size); | |
435 | ||
436 | /* | |
437 | * leap routine for strdup with error checking | |
438 | */ | |
439 | extern char *_xstrdup_leap(const char * file, const int line, | |
440 | const char * str); | |
441 | ||
442 | #ifdef __cplusplus | |
443 | } | |
444 | #endif | |
445 | ||
446 | #endif /* ! DMALLOC_DISABLE */ | |
447 | ||
448 | #endif /* ! __DMALLOC_H__ */ |