Annotation of OpenXM_contrib/gnuplot/alloc.c, Revision 1.1.1.2
1.1 maekawa 1: #ifndef lint
1.1.1.2 ! maekawa 2: static char *RCSid = "$Id: alloc.c,v 1.1.1.2 1998/04/15 19:21:56 lhecking Exp $";
1.1 maekawa 3: #endif
4:
5: /* GNUPLOT - alloc.c */
6:
7: /*[
8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
9: *
10: * Permission to use, copy, and distribute this software and its
11: * documentation for any purpose with or without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and
13: * that both that copyright notice and this permission notice appear
14: * in supporting documentation.
15: *
16: * Permission to modify the software is granted, but not the right to
17: * distribute the complete modified source code. Modifications are to
18: * be distributed as patches to the released version. Permission to
19: * distribute binaries produced by compiling modified sources is granted,
20: * provided you
21: * 1. distribute the corresponding source modifications from the
22: * released version in the form of a patch file along with the binaries,
23: * 2. add special version identification to distinguish your version
24: * in addition to the base release version number,
25: * 3. provide your name and address as the primary contact for the
26: * support of your modified version, and
27: * 4. retain our contact information in regard to use of the base
28: * software.
29: * Permission to distribute the released version of the source code along
30: * with corresponding source modifications in the form of a patch file is
31: * granted with same provisions 2 through 4 for binary distributions.
32: *
33: * This software is provided "as is" without express or implied warranty
34: * to the extent permitted by applicable law.
35: ]*/
36:
37: /*
38: * AUTHORS
39: *
40: * Alexander Lehmann (collected functions from misc.c and binary.c)
41: *
42: */
43:
44: #include "plot.h" /* includes "alloc.h" */
45:
46: #if defined(MSDOS) && defined(__TURBOC__) && !defined(DOSX286)
47: #include <alloc.h> /* for farmalloc, farrealloc */
48: #endif
49:
50: #if defined(_Windows) && !defined(WIN32)
51: #include <windows.h>
52: #include <windowsx.h>
53: #define farmalloc(s) GlobalAllocPtr(GHND,s)
54: #define farrealloc(p,s) GlobalReAllocPtr(p,s,GHND)
55: #endif
56:
57: #ifndef NO_GIH
58: #include "help.h"
59: #endif
60:
61: #ifndef GP_FARMALLOC
62: # ifdef FARALLOC
63: # define GP_FARMALLOC(size) farmalloc ((size))
64: # define GP_FARREALLOC(p,size) farrealloc ((p), (size))
65: # else
66: # define GP_FARMALLOC(size) malloc ((size_t)(size))
67: # define GP_FARREALLOC(p,size) realloc ((p), (size_t)(size))
68: # endif
69: #endif
70:
71: /* uncomment if you want to trace all allocs */
72: #define TRACE_ALLOC(x) /*printf x*/
73:
74:
75: #ifdef CHECK_HEAP_USE
76:
77: /* This is in no way supported, and in particular it breaks the
78: * online help. But it is useful to leave it in in case any
79: * heap-corruption bugs turn up. Wont work with FARALLOC
80: */
81:
82: struct frame_struct {
83: char *use;
84: int requested_size;
85: int pad; /* preserve 8-byte alignment */
86: int checksum;
87: };
88:
89: struct leak_struct {
90: char *file;
91: int line;
92: int allocated;
93: };
94:
95: static struct leak_struct leak_stack[40]; /* up to 40 nested leak checks */
96: static struct leak_struct *leak_frame = leak_stack;
97:
98: static long bytes_allocated = 0;
99:
100: #define RESERVED_SIZE sizeof(struct frame_struct)
101: #define CHECKSUM_INT 0xcaac5e1f
102: #define CHECKSUM_FREE 0xf3eed222
103: #define CHECKSUM_CHAR 0xc5
104:
105: static void mark(p, size, usage)
106: struct frame_struct *p;
107: unsigned long size;
108: char *usage;
109: {
110: p->use = usage;
111: p->requested_size = size;
112: p->checksum = (CHECKSUM_INT ^ (int)(p->use) ^ size);
113: ((unsigned char *)(p+1))[size] = CHECKSUM_CHAR;
114: }
115:
116: #define mark_free(p) ( ((struct frame_struct *)p)[-1].checksum = CHECKSUM_FREE)
117:
118: static void validate(x)
119: void *x;
120: {
121: struct frame_struct *p = (struct frame_struct *)x - 1;
122: if (p->checksum != (CHECKSUM_INT ^ (int)(p->use) ^ p->requested_size))
123: {
124: fprintf(stderr, "Heap corruption at start of block for %s\n", p->use);
125: if (p->checksum == CHECKSUM_FREE)
126: fprintf(stderr, "Looks like it has already been freed ?\n");
127: abort();
128: }
129:
130: if ( ((unsigned char *)(p+1))[p->requested_size] != CHECKSUM_CHAR)
131: {
132: fprintf(stderr, "Heap corruption at end of block for %-60s\n", p->use);
133: int_error("Argh !", NO_CARET);
134: }
135: }
136:
137: /* used to confirm that a pointer is inside an allocated region via
138: * macro CHECK_POINTER. Nowhere near as good as using a bounds-checking
139: * compiler (such as gcc-with-bounds-checking), but when we do
140: * come across problems, we can add these guards to the code until
141: * we find the problem, and then leave the guards in (as CHECK_POINTER
142: * macros which expand to nothing, until we need to re-enable them)
143: */
144:
145: void check_pointer_in_block(void *block, void *p, int size, char *file, int line)
146: {
147: struct frame_struct *f = (struct frame_struct *)block - 1;
148: validate(block);
149: if (p < block || p >= (block + f->requested_size))
150: {
151: fprintf(stderr, "argh - pointer %p outside block %p->%p for %s at %s:%d\n",
152: p, block, (char *)block + f->requested_size, f->use, file, line);
153: int_error("argh - pointer misuse !", NO_CARET);
154: }
155: }
156:
157: char *gp_alloc(size, usage)
158: unsigned long size;
159: char *usage;
160: {
161: struct frame_struct *p;
162: unsigned long total_size = size + RESERVED_SIZE + 1;
163:
164: TRACE_ALLOC(("gp_alloc %d for %s\n", (int) size, usage?usage:"<unknown>"));
165:
166: p=malloc(total_size);
167: if (!p) int_error("Out of memory", NO_CARET);
168:
169: bytes_allocated += size;
170:
171: mark(p,size,usage);
172:
173: return (char *)(p+1);
174: }
175:
176: generic *gp_realloc(old, size, usage)
177: generic *old;
178: unsigned long size;
179: char *usage;
180: {
181: if (!old) return gp_alloc(size, usage);
182: validate(old);
183: mark_free(old); /* if block gets moved, old block is marked free */
184: /* if not, we'll remark it later */
185:
186:
187: {
188: struct frame_struct *p = (struct frame_struct *)old - 1;
189: unsigned long total = size + RESERVED_SIZE + 1;
190:
191: p = realloc(p, total);
192:
193: if (!p) int_error("Out of memory", NO_CARET);
194:
195: TRACE_ALLOC(("gp_realloc %d for %s (was %d)\n",
196: (int)size, usage?usage:"<unknown>", p->requested_size));
197:
198: bytes_allocated += size - p->requested_size;
199:
200: mark(p,size,usage);
201:
202: return (generic *)(p+1);
203: }
204: }
205:
206: #undef free
207:
208: void checked_free(p)
209: void *p;
210: {
211: validate(p);
212: mark_free(p); /* trap attempts to free twice */
213: TRACE_ALLOC(("free %d for %s\n",
214: ((struct frame_struct *)p - 1)->requested_size,
215: ((struct frame_struct *)p - 1)->use));
216: bytes_allocated -= ((struct frame_struct *)p - 1) -> requested_size;
217: free( (struct frame_struct *) p - 1);
218: }
219:
220:
221: /* this leak checking stuff will be broken by first int_error or interrupt */
222:
223: void start_leak_check(char *file, int line)
224: {
225: if (leak_frame >= leak_stack+40)
226: {
227: fprintf(stderr, "too many nested memory-leak checks - %s:%d\n", file, line);
228: return;
229: }
230:
231: leak_frame->file = file;
232: leak_frame->line = line;
233: leak_frame->allocated = bytes_allocated;
234:
235: ++leak_frame;
236: }
237:
238: void end_leak_check(char *file, int line)
239: {
240: if (--leak_frame < leak_stack)
241: {
242: fprintf(stderr, "memory-leak stack underflow at %s:%d\n", file, line);
243: return;
244: }
245:
246: if (leak_frame->allocated != bytes_allocated)
247: {
248: fprintf(stderr, "net change of %+d heap bytes between %s:%d and %s:%d\n",
249: (int)(bytes_allocated - leak_frame->allocated),
250: leak_frame->file, leak_frame->line, file, line);
251: }
252: }
253:
254: #else /* CHECK_HEAP_USE */
255:
256: /* gp_alloc:
257: * allocate memory
258: * This is a protected version of malloc. It causes an int_error
259: * if there is not enough memory, but first it tries FreeHelp()
260: * to make some room, and tries again. If message is NULL, we
261: * allow NULL return. Otherwise, we handle the error, using the
262: * message to create the int_error string. Note cp/sp_extend uses realloc,
263: * so it depends on this using malloc().
264: */
265:
266: char *
267: gp_alloc(size, message)
268: unsigned long size; /* # of bytes */
269: char *message; /* description of what is being allocated */
270: {
271: char *p; /* the new allocation */
272: char errbuf[100]; /* error message string */
273:
274: #ifndef NO_GIH
275: p = GP_FARMALLOC(size);
276: if (p == (char *)NULL) {
277: FreeHelp(); /* out of memory, try to make some room */
278: #endif /* NO_GIH */
279: p = GP_FARMALLOC(size); /* try again */
280: if (p == (char *)NULL) {
281: /* really out of memory */
282: if (message != NULL) {
283: (void) sprintf(errbuf, "out of memory for %s", message);
284: int_error(errbuf, NO_CARET);
285: /* NOTREACHED */
286: }
287: /* else we return NULL */
288: }
289: #ifndef NO_GIH
290: }
291: #endif
292: return(p);
293: }
294:
295: /*
296: * note gp_realloc assumes that failed realloc calls leave the original mem block
297: * allocated. If this is not the case with any C compiler, a substitue
298: * realloc function has to be used.
299: */
300:
301: generic *
302: gp_realloc(p, size, message)
303: generic *p; /* old mem block */
304: unsigned long size; /* # of bytes */
305: char *message; /* description of what is being allocated */
306: {
307: char *res; /* the new allocation */
308: char errbuf[100]; /* error message string */
309:
310: /* realloc(NULL,x) is meant to do malloc(x), but doesn't always */
311: if (!p)
312: return gp_alloc(size,message);
313:
314: #ifndef NO_GIH
315: res = GP_FARREALLOC(p,size);
316: if (res == (char *)NULL) {
317: FreeHelp(); /* out of memory, try to make some room */
318: #endif /* NO_GIH */
319: res = GP_FARREALLOC(p,size); /* try again */
320: if (res == (char *)NULL) {
321: /* really out of memory */
322: if (message != NULL) {
323: (void) sprintf(errbuf, "out of memory for %s", message);
324: int_error(errbuf, NO_CARET);
325: /* NOTREACHED */
326: }
327: /* else we return NULL */
328: }
329: #ifndef NO_GIH
330: }
331: #endif
332: return(res);
333: }
334:
335: #endif /* CHECK_HEAP_USE */
336:
337: #ifdef FARALLOC
338: void gpfree(p)
339: generic *p;
340: {
341: #ifdef _Windows
342: HGLOBAL hGlobal = GlobalHandle(SELECTOROF(p));
343: GlobalUnlock(hGlobal);
344: GlobalFree(hGlobal);
345: #else
346: farfree(p);
347: #endif
348: }
349: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to alloc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot