← Back to branch summary

~ubuntu-branches/ubuntu/raring/luatex/raring

« back to all changes in this revision

Viewing changes to source/libs/xpdf/xpdf-3.02/goo/gmem.cc

  • Committer: Package Import Robot
  • Author(s): Norbert Preining
  • Date: 2011-05-20 09:40:39 UTC
  • mfrom: (0.8.1) (1.8.1) (19.2.3 oneiric)
  • Revision ID: package-import@ubuntu.com-20110520094039-7sezr4kqonjqxqz6
Tags: 0.70.1-1
* new upstream release (probably) matching TeX Live 2011
* deactivate fix-luatex-build-with-old-libpng patch, included upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/xpdf/xpdf-3.02/goo/gmem.cc
1
 
/*
2
 
 * gmem.c
3
 
 *
4
 
 * Memory routines with out-of-memory checking.
5
 
 *
6
 
 * Copyright 1996-2003 Glyph & Cog, LLC
7
 
 */
8
 
 
9
 
#include <aconf.h>
10
 
#include <stdio.h>
11
 
#include <stdlib.h>
12
 
#include <stddef.h>
13
 
#include <string.h>
14
 
#include <limits.h>
15
 
#include "gmem.h"
16
 
 
17
 
#ifdef DEBUG_MEM
18
 
 
19
 
typedef struct _GMemHdr {
20
 
  unsigned int magic;
21
 
  int size;
22
 
  int index;
23
 
  struct _GMemHdr *next, *prev;
24
 
} GMemHdr;
25
 
 
26
 
#define gMemHdrSize ((sizeof(GMemHdr) + 7) & ~7)
27
 
#define gMemTrlSize (sizeof(long))
28
 
 
29
 
#define gMemMagic 0xabcd9999
30
 
 
31
 
#if gmemTrlSize==8
32
 
#define gMemDeadVal 0xdeadbeefdeadbeefUL
33
 
#else
34
 
#define gMemDeadVal 0xdeadbeefUL
35
 
#endif
36
 
 
37
 
/* round data size so trailer will be aligned */
38
 
#define gMemDataSize(size) \
39
 
  ((((size) + gMemTrlSize - 1) / gMemTrlSize) * gMemTrlSize)
40
 
 
41
 
static GMemHdr *gMemHead = NULL;
42
 
static GMemHdr *gMemTail = NULL;
43
 
 
44
 
static int gMemIndex = 0;
45
 
static int gMemAlloc = 0;
46
 
static int gMemInUse = 0;
47
 
 
48
 
#endif /* DEBUG_MEM */
49
 
 
50
 
void *gmalloc(int size) GMEM_EXCEP {
51
 
#ifdef DEBUG_MEM
52
 
  int size1;
53
 
  char *mem;
54
 
  GMemHdr *hdr;
55
 
  void *data;
56
 
  unsigned long *trl, *p;
57
 
 
58
 
  if (size < 0) {
59
 
#if USE_EXCEPTIONS
60
 
    throw GMemException();
61
 
#else
62
 
    fprintf(stderr, "Invalid memory allocation size\n");
63
 
    exit(1);
64
 
#endif
65
 
  }
66
 
  if (size == 0) {
67
 
    return NULL;
68
 
  }
69
 
  size1 = gMemDataSize(size);
70
 
  if (!(mem = (char *)malloc(size1 + gMemHdrSize + gMemTrlSize))) {
71
 
#if USE_EXCEPTIONS
72
 
    throw GMemException();
73
 
#else
74
 
    fprintf(stderr, "Out of memory\n");
75
 
    exit(1);
76
 
#endif
77
 
  }
78
 
  hdr = (GMemHdr *)mem;
79
 
  data = (void *)(mem + gMemHdrSize);
80
 
  trl = (unsigned long *)(mem + gMemHdrSize + size1);
81
 
  hdr->magic = gMemMagic;
82
 
  hdr->size = size;
83
 
  hdr->index = gMemIndex++;
84
 
  if (gMemTail) {
85
 
    gMemTail->next = hdr;
86
 
    hdr->prev = gMemTail;
87
 
    gMemTail = hdr;
88
 
  } else {
89
 
    hdr->prev = NULL;
90
 
    gMemHead = gMemTail = hdr;
91
 
  }
92
 
  hdr->next = NULL;
93
 
  ++gMemAlloc;
94
 
  gMemInUse += size;
95
 
  for (p = (unsigned long *)data; p <= trl; ++p) {
96
 
    *p = gMemDeadVal;
97
 
  }
98
 
  return data;
99
 
#else
100
 
  void *p;
101
 
 
102
 
  if (size < 0) {
103
 
#if USE_EXCEPTIONS
104
 
    throw GMemException();
105
 
#else
106
 
    fprintf(stderr, "Invalid memory allocation size\n");
107
 
    exit(1);
108
 
#endif
109
 
  }
110
 
  if (size == 0) {
111
 
    return NULL;
112
 
  }
113
 
  if (!(p = malloc(size))) {
114
 
#if USE_EXCEPTIONS
115
 
    throw GMemException();
116
 
#else
117
 
    fprintf(stderr, "Out of memory\n");
118
 
    exit(1);
119
 
#endif
120
 
  }
121
 
  return p;
122
 
#endif
123
 
}
124
 
 
125
 
void *grealloc(void *p, int size) GMEM_EXCEP {
126
 
#ifdef DEBUG_MEM
127
 
  GMemHdr *hdr;
128
 
  void *q;
129
 
  int oldSize;
130
 
 
131
 
  if (size < 0) {
132
 
#if USE_EXCEPTIONS
133
 
    throw GMemException();
134
 
#else
135
 
    fprintf(stderr, "Invalid memory allocation size\n");
136
 
    exit(1);
137
 
#endif
138
 
  }
139
 
  if (size == 0) {
140
 
    if (p) {
141
 
      gfree(p);
142
 
    }
143
 
    return NULL;
144
 
  }
145
 
  if (p) {
146
 
    hdr = (GMemHdr *)((char *)p - gMemHdrSize);
147
 
    oldSize = hdr->size;
148
 
    q = gmalloc(size);
149
 
    memcpy(q, p, size < oldSize ? size : oldSize);
150
 
    gfree(p);
151
 
  } else {
152
 
    q = gmalloc(size);
153
 
  }
154
 
  return q;
155
 
#else
156
 
  void *q;
157
 
 
158
 
  if (size < 0) {
159
 
#if USE_EXCEPTIONS
160
 
    throw GMemException();
161
 
#else
162
 
    fprintf(stderr, "Invalid memory allocation size\n");
163
 
    exit(1);
164
 
#endif
165
 
  }
166
 
  if (size == 0) {
167
 
    if (p) {
168
 
      free(p);
169
 
    }
170
 
    return NULL;
171
 
  }
172
 
  if (p) {
173
 
    q = realloc(p, size);
174
 
  } else {
175
 
    q = malloc(size);
176
 
  }
177
 
  if (!q) {
178
 
#if USE_EXCEPTIONS
179
 
    throw GMemException();
180
 
#else
181
 
    fprintf(stderr, "Out of memory\n");
182
 
    exit(1);
183
 
#endif
184
 
  }
185
 
  return q;
186
 
#endif
187
 
}
188
 
 
189
 
void *gmallocn(int nObjs, int objSize) GMEM_EXCEP {
190
 
  int n;
191
 
 
192
 
  if (nObjs == 0) {
193
 
    return NULL;
194
 
  }
195
 
  n = nObjs * objSize;
196
 
  if (objSize <= 0 || nObjs < 0 || nObjs >= INT_MAX / objSize) {
197
 
#if USE_EXCEPTIONS
198
 
    throw GMemException();
199
 
#else
200
 
    fprintf(stderr, "Bogus memory allocation size\n");
201
 
    exit(1);
202
 
#endif
203
 
  }
204
 
  return gmalloc(n);
205
 
}
206
 
 
207
 
void *greallocn(void *p, int nObjs, int objSize) GMEM_EXCEP {
208
 
  int n;
209
 
 
210
 
  if (nObjs == 0) {
211
 
    if (p) {
212
 
      gfree(p);
213
 
    }
214
 
    return NULL;
215
 
  }
216
 
  n = nObjs * objSize;
217
 
  if (objSize <= 0 || nObjs < 0 || nObjs >= INT_MAX / objSize) {
218
 
#if USE_EXCEPTIONS
219
 
    throw GMemException();
220
 
#else
221
 
    fprintf(stderr, "Bogus memory allocation size\n");
222
 
    exit(1);
223
 
#endif
224
 
  }
225
 
  return grealloc(p, n);
226
 
}
227
 
 
228
 
void gfree(void *p) {
229
 
#ifdef DEBUG_MEM
230
 
  int size;
231
 
  GMemHdr *hdr;
232
 
  unsigned long *trl, *clr;
233
 
 
234
 
  if (p) {
235
 
    hdr = (GMemHdr *)((char *)p - gMemHdrSize);
236
 
    if (hdr->magic == gMemMagic &&
237
 
        ((hdr->prev == NULL) == (hdr == gMemHead)) &&
238
 
        ((hdr->next == NULL) == (hdr == gMemTail))) {
239
 
      if (hdr->prev) {
240
 
        hdr->prev->next = hdr->next;
241
 
      } else {
242
 
        gMemHead = hdr->next;
243
 
      }
244
 
      if (hdr->next) {
245
 
        hdr->next->prev = hdr->prev;
246
 
      } else {
247
 
        gMemTail = hdr->prev;
248
 
      }
249
 
      --gMemAlloc;
250
 
      gMemInUse -= hdr->size;
251
 
      size = gMemDataSize(hdr->size);
252
 
      trl = (unsigned long *)((char *)hdr + gMemHdrSize + size);
253
 
      if (*trl != gMemDeadVal) {
254
 
        fprintf(stderr, "Overwrite past end of block %d at address %p\n",
255
 
                hdr->index, p);
256
 
      }
257
 
      for (clr = (unsigned long *)hdr; clr <= trl; ++clr) {
258
 
        *clr = gMemDeadVal;
259
 
      }
260
 
      free(hdr);
261
 
    } else {
262
 
      fprintf(stderr, "Attempted to free bad address %p\n", p);
263
 
    }
264
 
  }
265
 
#else
266
 
  if (p) {
267
 
    free(p);
268
 
  }
269
 
#endif
270
 
}
271
 
 
272
 
#ifdef DEBUG_MEM
273
 
void gMemReport(FILE *f) {
274
 
  GMemHdr *p;
275
 
 
276
 
  fprintf(f, "%d memory allocations in all\n", gMemIndex);
277
 
  if (gMemAlloc > 0) {
278
 
    fprintf(f, "%d memory blocks left allocated:\n", gMemAlloc);
279
 
    fprintf(f, " index     size\n");
280
 
    fprintf(f, "-------- --------\n");
281
 
    for (p = gMemHead; p; p = p->next) {
282
 
      fprintf(f, "%8d %8d\n", p->index, p->size);
283
 
    }
284
 
  } else {
285
 
    fprintf(f, "No memory blocks left allocated\n");
286
 
  }
287
 
}
288
 
#endif
289
 
 
290
 
char *copyString(char *s) {
291
 
  char *s1;
292
 
 
293
 
  s1 = (char *)gmalloc(strlen(s) + 1);
294
 
  strcpy(s1, s);
295
 
  return s1;
296
 
}