From 56cfb6a8e8b3b87bd2ff85c14a5635477141be4e Mon Sep 17 00:00:00 2001 From: Robin Watts Date: Tue, 15 Mar 2016 15:58:19 +0000 Subject: Memento: Rename memento 'globals' to 'memento'. Neatness. --- source/fitz/memento.c | 298 +++++++++++++++++++++++++------------------------- 1 file changed, 149 insertions(+), 149 deletions(-) (limited to 'source/fitz/memento.c') diff --git a/source/fitz/memento.c b/source/fitz/memento.c index 79a65454..27122488 100644 --- a/source/fitz/memento.c +++ b/source/fitz/memento.c @@ -301,7 +301,7 @@ static struct { size_t numMallocs; size_t numFrees; size_t numReallocs; -} globals; +} memento; #define MEMENTO_EXTRASIZE (sizeof(Memento_BlkHeader) + Memento_PostSize) @@ -694,7 +694,7 @@ static void Memento_storeDetails(Memento_BlkHeader *head, int type) details->type = type; details->count = count; - details->sequence = globals.sequence; + details->sequence = memento.sequence; details->next = NULL; *head->details_tail = details; head->details_tail = &details->next; @@ -834,7 +834,7 @@ post_corrupt: data->postCorrupt = 1; } if ((data->freeCorrupt | data->preCorrupt | data->postCorrupt) == 0) { - b->lastCheckedOK = globals.sequence; + b->lastCheckedOK = memento.sequence; } data->found |= 1; #endif @@ -921,19 +921,19 @@ static int Memento_Internal_makeSpace(size_t space) if (space > MEMENTO_FREELIST_MAX_SINGLE_BLOCK) return 0; /* Pretend we added it on. */ - globals.freeListSize += space; + memento.freeListSize += space; /* Ditch blocks until it fits within our limit */ - while (globals.freeListSize > MEMENTO_FREELIST_MAX) { - Memento_BlkHeader *head = globals.free.head; + while (memento.freeListSize > MEMENTO_FREELIST_MAX) { + Memento_BlkHeader *head = memento.free.head; VALGRIND_MAKE_MEM_DEFINED(head, sizeof(*head)); - globals.free.head = head->next; - globals.freeListSize -= MEMBLK_SIZE(head->rawsize); + memento.free.head = head->next; + memento.freeListSize -= MEMBLK_SIZE(head->rawsize); free_block(head); } /* Make sure we haven't just completely emptied the free list */ /* (This should never happen, but belt and braces... */ - if (globals.free.head == NULL) - globals.free.tail = NULL; + if (memento.free.head == NULL) + memento.free.tail = NULL; return 1; } @@ -1077,7 +1077,7 @@ int Memento_listBlocksNested(void) /* Count the blocks */ count = 0; size = 0; - for (b = globals.used.head; b; b = b->next) { + for (b = memento.used.head; b; b = b->next) { VALGRIND_MAKE_MEM_DEFINED(b, sizeof(*b)); size += b->rawsize; count++; @@ -1089,7 +1089,7 @@ int Memento_listBlocksNested(void) return 1; /* Populate our block list */ - b = globals.used.head; + b = memento.used.head; minptr = maxptr = MEMBLK_TOBLK(b); mask = (long)minptr; for (i = 0; b; b = b->next, i++) { @@ -1108,7 +1108,7 @@ int Memento_listBlocksNested(void) qsort(blocks, count, sizeof(void *), ptrcmp); /* Now, calculate tree */ - for (b = globals.used.head; b; b = b->next) { + for (b = memento.used.head; b; b = b->next) { char *p = MEMBLK_TOBLK(b); int end = (b->rawsize < MEMENTO_PTRSEARCH ? b->rawsize : MEMENTO_PTRSEARCH); for (i = MEMENTO_SEARCH_SKIP; i < end; i += sizeof(void *)) { @@ -1154,7 +1154,7 @@ int Memento_listBlocksNested(void) } /* Now display with nesting */ - for (b = globals.used.head; b; b = b->next) { + for (b = memento.used.head; b; b = b->next) { if ((b->flags & Memento_Flag_HasParent) == 0) doNestedDisplay(b, 0); } @@ -1166,7 +1166,7 @@ int Memento_listBlocksNested(void) /* Now put the blocks back for valgrind, and restore the prev * and magic values. */ prev = NULL; - for (b = globals.used.head; b;) { + for (b = memento.used.head; b;) { Memento_BlkHeader *next = b->next; b->prev = prev; b->child = MEMENTO_CHILD_MAGIC; @@ -1187,7 +1187,7 @@ void Memento_listBlocks(void) int counts[2]; counts[0] = 0; counts[1] = 0; - Memento_appBlocks(&globals.used, Memento_listBlock, &counts[0]); + Memento_appBlocks(&memento.used, Memento_listBlock, &counts[0]); fprintf(stderr, " Total number of blocks = %d\n", counts[0]); fprintf(stderr, " Total size of blocks = %d\n", counts[1]); } @@ -1208,24 +1208,24 @@ void Memento_listNewBlocks(void) counts[0] = 0; counts[1] = 0; fprintf(stderr, "Blocks allocated and still extant since last list:\n"); - Memento_appBlocks(&globals.used, Memento_listNewBlock, &counts[0]); + Memento_appBlocks(&memento.used, Memento_listNewBlock, &counts[0]); fprintf(stderr, " Total number of blocks = %d\n", counts[0]); fprintf(stderr, " Total size of blocks = %d\n", counts[1]); } static void Memento_endStats(void) { - fprintf(stderr, "Total memory malloced = %u bytes\n", (unsigned int)globals.totalAlloc); - fprintf(stderr, "Peak memory malloced = %u bytes\n", (unsigned int)globals.peakAlloc); - fprintf(stderr, "%u mallocs, %u frees, %u reallocs\n", (unsigned int)globals.numMallocs, - (unsigned int)globals.numFrees, (unsigned int)globals.numReallocs); + fprintf(stderr, "Total memory malloced = %u bytes\n", (unsigned int)memento.totalAlloc); + fprintf(stderr, "Peak memory malloced = %u bytes\n", (unsigned int)memento.peakAlloc); + fprintf(stderr, "%u mallocs, %u frees, %u reallocs\n", (unsigned int)memento.numMallocs, + (unsigned int)memento.numFrees, (unsigned int)memento.numReallocs); fprintf(stderr, "Average allocation size %u bytes\n", (unsigned int) - (globals.numMallocs != 0 ? globals.totalAlloc/globals.numMallocs: 0)); + (memento.numMallocs != 0 ? memento.totalAlloc/memento.numMallocs: 0)); } void Memento_stats(void) { - fprintf(stderr, "Current memory malloced = %u bytes\n", (unsigned int)globals.alloc); + fprintf(stderr, "Current memory malloced = %u bytes\n", (unsigned int)memento.alloc); Memento_endStats(); } @@ -1255,7 +1255,7 @@ void Memento_listBlockInfo(void) { #ifdef MEMENTO_DETAILS fprintf(stderr, "Details of allocated blocks:\n"); - Memento_appBlocks(&globals.used, showInfo, NULL); + Memento_appBlocks(&memento.used, showInfo, NULL); #endif } @@ -1263,7 +1263,7 @@ static void Memento_fin(void) { Memento_checkAllMemory(); Memento_endStats(); - if (globals.used.head != NULL) { + if (memento.used.head != NULL) { Memento_listBlocks(); #ifdef MEMENTO_DETAILS fprintf(stderr, "\n"); @@ -1271,23 +1271,23 @@ static void Memento_fin(void) #endif Memento_breakpoint(); } - if (globals.segv) { - fprintf(stderr, "Memory dumped on SEGV while squeezing @ %d\n", globals.failAt); - } else if (globals.squeezing) { - if (globals.pattern == 0) - fprintf(stderr, "Memory squeezing @ %d complete\n", globals.squeezeAt); + if (memento.segv) { + fprintf(stderr, "Memory dumped on SEGV while squeezing @ %d\n", memento.failAt); + } else if (memento.squeezing) { + if (memento.pattern == 0) + fprintf(stderr, "Memory squeezing @ %d complete\n", memento.squeezeAt); else - fprintf(stderr, "Memory squeezing @ %d (%d) complete\n", globals.squeezeAt, globals.pattern); + fprintf(stderr, "Memory squeezing @ %d (%d) complete\n", memento.squeezeAt, memento.pattern); } - if (globals.failing) + if (memento.failing) { - fprintf(stderr, "MEMENTO_FAILAT=%d\n", globals.failAt); - fprintf(stderr, "MEMENTO_PATTERN=%d\n", globals.pattern); + fprintf(stderr, "MEMENTO_FAILAT=%d\n", memento.failAt); + fprintf(stderr, "MEMENTO_PATTERN=%d\n", memento.pattern); } - if (globals.nextFailAt != 0) + if (memento.nextFailAt != 0) { - fprintf(stderr, "MEMENTO_NEXTFAILAT=%d\n", globals.nextFailAt); - fprintf(stderr, "MEMENTO_NEXTPATTERN=%d\n", globals.nextPattern); + fprintf(stderr, "MEMENTO_NEXTFAILAT=%d\n", memento.nextFailAt); + fprintf(stderr, "MEMENTO_NEXTPATTERN=%d\n", memento.nextPattern); } } @@ -1299,34 +1299,34 @@ static void Memento_inited(void) static void Memento_init(void) { char *env; - memset(&globals, 0, sizeof(globals)); - globals.inited = 1; - globals.used.head = NULL; - globals.used.tail = NULL; - globals.free.head = NULL; - globals.free.tail = NULL; - globals.sequence = 0; - globals.countdown = 1024; + memset(&memento, 0, sizeof(memento)); + memento.inited = 1; + memento.used.head = NULL; + memento.used.tail = NULL; + memento.free.head = NULL; + memento.free.tail = NULL; + memento.sequence = 0; + memento.countdown = 1024; env = getenv("MEMENTO_FAILAT"); - globals.failAt = (env ? atoi(env) : 0); + memento.failAt = (env ? atoi(env) : 0); env = getenv("MEMENTO_PARANOIA"); - globals.paranoia = (env ? atoi(env) : 0); - if (globals.paranoia == 0) - globals.paranoia = -1024; + memento.paranoia = (env ? atoi(env) : 0); + if (memento.paranoia == 0) + memento.paranoia = -1024; env = getenv("MEMENTO_PARANOIDAT"); - globals.paranoidAt = (env ? atoi(env) : 0); + memento.paranoidAt = (env ? atoi(env) : 0); env = getenv("MEMENTO_SQUEEZEAT"); - globals.squeezeAt = (env ? atoi(env) : 0); + memento.squeezeAt = (env ? atoi(env) : 0); env = getenv("MEMENTO_PATTERN"); - globals.pattern = (env ? atoi(env) : 0); + memento.pattern = (env ? atoi(env) : 0); env = getenv("MEMENTO_MAXMEMORY"); - globals.maxMemory = (env ? atoi(env) : 0); + memento.maxMemory = (env ? atoi(env) : 0); atexit(Memento_fin); @@ -1375,12 +1375,12 @@ void Memento_info(void *addr) data.addr = addr; data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.used, Memento_containsAddr, &data); + Memento_appBlocks(&memento.used, Memento_containsAddr, &data); if (data.blk != NULL) showInfo(data.blk, NULL); data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.free, Memento_containsAddr, &data); + Memento_appBlocks(&memento.free, Memento_containsAddr, &data); if (data.blk != NULL) showInfo(data.blk, NULL); #else @@ -1406,7 +1406,7 @@ int stashed_map[OPEN_MAX]; static void Memento_signal(void) { - fprintf(stderr, "SEGV after Memory squeezing @ %d\n", globals.squeezeAt); + fprintf(stderr, "SEGV after Memory squeezing @ %d\n", memento.squeezeAt); #ifdef MEMENTO_STACKTRACE_METHOD #if MEMENTO_STACKTRACE_METHOD == 1 @@ -1431,18 +1431,18 @@ static int squeeze(void) pid_t pid; int i, status; - if (globals.patternBit < 0) + if (memento.patternBit < 0) return 1; - if (globals.squeezing && globals.patternBit >= MEMENTO_MAXPATTERN) + if (memento.squeezing && memento.patternBit >= MEMENTO_MAXPATTERN) return 1; - if (globals.patternBit == 0) - globals.squeezeAt = globals.sequence; + if (memento.patternBit == 0) + memento.squeezeAt = memento.sequence; - if (!globals.squeezing) { - fprintf(stderr, "Memory squeezing @ %d\n", globals.squeezeAt); + if (!memento.squeezing) { + fprintf(stderr, "Memory squeezing @ %d\n", memento.squeezeAt); } else - fprintf(stderr, "Memory squeezing @ %d (%x,%x)\n", globals.squeezeAt, globals.pattern, globals.patternBit); + fprintf(stderr, "Memory squeezing @ %d (%x,%x)\n", memento.squeezeAt, memento.pattern, memento.patternBit); /* When we fork below, the child is going to snaffle all our file pointers * and potentially corrupt them. Let's make copies of all of them before @@ -1459,18 +1459,18 @@ static int squeeze(void) /* Child */ signal(SIGSEGV, Memento_signal); /* In the child, we always fail the next allocation. */ - if (globals.patternBit == 0) { - globals.patternBit = 1; + if (memento.patternBit == 0) { + memento.patternBit = 1; } else - globals.patternBit <<= 1; - globals.squeezing = 1; + memento.patternBit <<= 1; + memento.squeezing = 1; return 1; } /* In the parent if we hit another allocation, pass it (and record the * fact we passed it in the pattern. */ - globals.pattern |= globals.patternBit; - globals.patternBit <<= 1; + memento.pattern |= memento.patternBit; + memento.patternBit <<= 1; /* Wait for pid to finish */ waitpid(pid, &status, 0); @@ -1495,7 +1495,7 @@ static int squeeze(void) static void Memento_signal(void) { - globals.segv = 1; + memento.segv = 1; /* If we just return from this function the SEGV will be unhandled, and * we'll launch into whatever JIT debugging system the OS provides. At * least fprintf(stderr, something useful first. If MEMENTO_NOJIT is set, then @@ -1515,14 +1515,14 @@ int squeeze(void) static void Memento_startFailing(void) { - if (!globals.failing) { + if (!memento.failing) { fprintf(stderr, "Starting to fail...\n"); fflush(stderr); - globals.failing = 1; - globals.failAt = globals.sequence; - globals.nextFailAt = globals.sequence+1; - globals.pattern = 0; - globals.patternBit = 0; + memento.failing = 1; + memento.failAt = memento.sequence; + memento.nextFailAt = memento.sequence+1; + memento.pattern = 0; + memento.patternBit = 0; signal(SIGSEGV, Memento_signal); signal(SIGABRT, Memento_signal); Memento_breakpoint(); @@ -1531,32 +1531,32 @@ static void Memento_startFailing(void) static void Memento_event(void) { - globals.sequence++; - if ((globals.sequence >= globals.paranoidAt) && (globals.paranoidAt != 0)) { - globals.paranoia = 1; - globals.countdown = 1; + memento.sequence++; + if ((memento.sequence >= memento.paranoidAt) && (memento.paranoidAt != 0)) { + memento.paranoia = 1; + memento.countdown = 1; } - if (--globals.countdown == 0) { + if (--memento.countdown == 0) { Memento_checkAllMemory(); - if (globals.paranoia > 0) - globals.countdown = globals.paranoia; + if (memento.paranoia > 0) + memento.countdown = memento.paranoia; else { - globals.countdown = -globals.paranoia; - if (globals.paranoia > INT_MIN/2) - globals.paranoia *= 2; + memento.countdown = -memento.paranoia; + if (memento.paranoia > INT_MIN/2) + memento.paranoia *= 2; } } - if (globals.sequence == globals.breakAt) { - fprintf(stderr, "Breaking at event %d\n", globals.breakAt); + if (memento.sequence == memento.breakAt) { + fprintf(stderr, "Breaking at event %d\n", memento.breakAt); Memento_breakpoint(); } } int Memento_breakAt(int event) { - globals.breakAt = event; + memento.breakAt = event; return event; } @@ -1577,33 +1577,33 @@ int Memento_failThisEvent(void) { int failThisOne; - if (!globals.inited) + if (!memento.inited) Memento_init(); Memento_event(); - if ((globals.sequence >= globals.failAt) && (globals.failAt != 0)) + if ((memento.sequence >= memento.failAt) && (memento.failAt != 0)) Memento_startFailing(); - if ((globals.sequence >= globals.squeezeAt) && (globals.squeezeAt != 0)) { + if ((memento.sequence >= memento.squeezeAt) && (memento.squeezeAt != 0)) { return squeeze(); } - if (!globals.failing) + if (!memento.failing) return 0; - failThisOne = ((globals.patternBit & globals.pattern) == 0); + failThisOne = ((memento.patternBit & memento.pattern) == 0); /* If we are failing, and we've reached the end of the pattern and we've * still got bits available in the pattern word, and we haven't already * set a nextPattern, then extend the pattern. */ - if (globals.failing && - ((~(globals.patternBit-1) & globals.pattern) == 0) && - (globals.patternBit != 0) && - globals.nextPattern == 0) + if (memento.failing && + ((~(memento.patternBit-1) & memento.pattern) == 0) && + (memento.patternBit != 0) && + memento.nextPattern == 0) { /* We'll fail this one, and set the 'next' one to pass it. */ - globals.nextFailAt = globals.failAt; - globals.nextPattern = globals.pattern | globals.patternBit; + memento.nextFailAt = memento.failAt; + memento.nextPattern = memento.pattern | memento.patternBit; } - globals.patternBit = (globals.patternBit ? globals.patternBit << 1 : 1); + memento.patternBit = (memento.patternBit ? memento.patternBit << 1 : 1); return failThisOne; } @@ -1619,24 +1619,24 @@ static void *do_malloc(size_t s, int eventType) if (s == 0) return NULL; - globals.numMallocs++; + memento.numMallocs++; - if (globals.maxMemory != 0 && globals.alloc + s > globals.maxMemory) + if (memento.maxMemory != 0 && memento.alloc + s > memento.maxMemory) return NULL; memblk = MEMENTO_UNDERLYING_MALLOC(smem); if (memblk == NULL) return NULL; - globals.alloc += s; - globals.totalAlloc += s; - if (globals.peakAlloc < globals.alloc) - globals.peakAlloc = globals.alloc; + memento.alloc += s; + memento.totalAlloc += s; + if (memento.peakAlloc < memento.alloc) + memento.peakAlloc = memento.alloc; #ifndef MEMENTO_LEAKONLY memset(MEMBLK_TOBLK(memblk), MEMENTO_ALLOCFILL, s); #endif memblk->rawsize = s; - memblk->sequence = globals.sequence; + memblk->sequence = memento.sequence; memblk->lastCheckedOK = memblk->sequence; memblk->flags = 0; memblk->label = 0; @@ -1647,7 +1647,7 @@ static void *do_malloc(size_t s, int eventType) memblk->details_tail = &memblk->details; Memento_storeDetails(memblk, Memento_EventType_malloc); #endif /* MEMENTO_DETAILS */ - Memento_addBlockHead(&globals.used, memblk, 0); + Memento_addBlockHead(&memento.used, memblk, 0); return MEMBLK_TOBLK(memblk); } @@ -1701,7 +1701,7 @@ static int checkBlockUser(Memento_BlkHeader *memblk, const char *action) BlkCheckData data; memset(&data, 0, sizeof(data)); - Memento_appBlockUser(&globals.used, Memento_Internal_checkAllocedBlock, + Memento_appBlockUser(&memento.used, Memento_Internal_checkAllocedBlock, &data, memblk); if (!data.found) { /* Failure! */ @@ -1721,7 +1721,7 @@ static int checkBlockUser(Memento_BlkHeader *memblk, const char *action) fprintf(stderr, "Postguard corrupted\n"); } fprintf(stderr, "Block last checked OK at allocation %d. Now %d.\n", - memblk->lastCheckedOK, globals.sequence); + memblk->lastCheckedOK, memento.sequence); Memento_breakpoint(); return 1; } @@ -1748,7 +1748,7 @@ static int checkBlock(Memento_BlkHeader *memblk, const char *action) #ifndef MEMENTO_LEAKONLY memset(&data, 0, sizeof(data)); - Memento_appBlock(&globals.used, Memento_Internal_checkAllocedBlock, + Memento_appBlock(&memento.used, Memento_Internal_checkAllocedBlock, &data, memblk); if (!data.found) { /* Failure! */ @@ -1768,7 +1768,7 @@ static int checkBlock(Memento_BlkHeader *memblk, const char *action) fprintf(stderr, "Postguard corrupted\n"); } fprintf(stderr, "Block last checked OK at allocation %d. Now %d.\n", - memblk->lastCheckedOK, globals.sequence); + memblk->lastCheckedOK, memento.sequence); Memento_breakpoint(); return 1; } @@ -1780,7 +1780,7 @@ static void do_free(void *blk, int eventType) { Memento_BlkHeader *memblk; - if (!globals.inited) + if (!memento.inited) Memento_init(); Memento_event(); @@ -1801,10 +1801,10 @@ static void do_free(void *blk, int eventType) if (memblk->flags & Memento_Flag_BreakOnFree) Memento_breakpoint(); - globals.alloc -= memblk->rawsize; - globals.numFrees++; + memento.alloc -= memblk->rawsize; + memento.numFrees++; - Memento_removeBlock(&globals.used, memblk); + Memento_removeBlock(&memento.used, memblk); VALGRIND_MAKE_MEM_DEFINED(memblk, sizeof(*memblk)); if (Memento_Internal_makeSpace(MEMBLK_SIZE(memblk->rawsize))) { @@ -1815,7 +1815,7 @@ static void do_free(void *blk, int eventType) memset(MEMBLK_TOBLK(memblk), MEMENTO_FREEFILL, memblk->rawsize); #endif memblk->flags |= Memento_Flag_Freed; - Memento_addBlockTail(&globals.free, memblk, 1); + Memento_addBlockTail(&memento.free, memblk, 1); } else { free_block(memblk); } @@ -1849,25 +1849,25 @@ static void *do_realloc(void *blk, size_t newsize, int type) Memento_breakpoint(); VALGRIND_MAKE_MEM_DEFINED(memblk, sizeof(*memblk)); - if (globals.maxMemory != 0 && globals.alloc - memblk->rawsize + newsize > globals.maxMemory) + if (memento.maxMemory != 0 && memento.alloc - memblk->rawsize + newsize > memento.maxMemory) return NULL; newsizemem = MEMBLK_SIZE(newsize); - Memento_removeBlock(&globals.used, memblk); + Memento_removeBlock(&memento.used, memblk); VALGRIND_MAKE_MEM_DEFINED(memblk, sizeof(*memblk)); flags = memblk->flags; newmemblk = MEMENTO_UNDERLYING_REALLOC(memblk, newsizemem); if (newmemblk == NULL) { - Memento_addBlockHead(&globals.used, memblk, 2); + Memento_addBlockHead(&memento.used, memblk, 2); return NULL; } - globals.numReallocs++; - globals.totalAlloc += newsize; - globals.alloc -= newmemblk->rawsize; - globals.alloc += newsize; - if (globals.peakAlloc < globals.alloc) - globals.peakAlloc = globals.alloc; + memento.numReallocs++; + memento.totalAlloc += newsize; + memento.alloc -= newmemblk->rawsize; + memento.alloc += newsize; + if (memento.peakAlloc < memento.alloc) + memento.peakAlloc = memento.alloc; newmemblk->flags = flags; if (newmemblk->rawsize < newsize) { char *newbytes = ((char *)MEMBLK_TOBLK(newmemblk))+newmemblk->rawsize; @@ -1886,7 +1886,7 @@ static void *do_realloc(void *blk, size_t newsize, int type) memset(MEMBLK_POSTPTR(newmemblk), MEMENTO_POSTFILL, Memento_PostSize); VALGRIND_MAKE_MEM_UNDEFINED(MEMBLK_POSTPTR(newmemblk), Memento_PostSize); #endif - Memento_addBlockHead(&globals.used, newmemblk, 2); + Memento_addBlockHead(&memento.used, newmemblk, 2); return MEMBLK_TOBLK(newmemblk); } @@ -1933,13 +1933,13 @@ static int Memento_Internal_checkAllAlloced(Memento_BlkHeader *memblk, void *arg } fprintf(stderr, "corrupted.\n " "Block last checked OK at allocation %d. Now %d.\n", - memblk->lastCheckedOK, globals.sequence); + memblk->lastCheckedOK, memento.sequence); data->preCorrupt = 0; data->postCorrupt = 0; data->freeCorrupt = 0; } else - memblk->lastCheckedOK = globals.sequence; + memblk->lastCheckedOK = memento.sequence; return 0; } @@ -1975,13 +1975,13 @@ static int Memento_Internal_checkAllFreed(Memento_BlkHeader *memblk, void *arg) } fprintf(stderr, " corrupted.\n" " Block last checked OK at allocation %d. Now %d.\n", - memblk->lastCheckedOK, globals.sequence); + memblk->lastCheckedOK, memento.sequence); data->preCorrupt = 0; data->postCorrupt = 0; data->freeCorrupt = 0; } else - memblk->lastCheckedOK = globals.sequence; + memblk->lastCheckedOK = memento.sequence; return 0; } @@ -1991,8 +1991,8 @@ int Memento_checkAllMemory(void) BlkCheckData data; memset(&data, 0, sizeof(data)); - Memento_appBlocks(&globals.used, Memento_Internal_checkAllAlloced, &data); - Memento_appBlocks(&globals.free, Memento_Internal_checkAllFreed, &data); + Memento_appBlocks(&memento.used, Memento_Internal_checkAllAlloced, &data); + Memento_appBlocks(&memento.free, Memento_Internal_checkAllFreed, &data); if (data.found & 6) { Memento_breakpoint(); return 1; @@ -2003,17 +2003,17 @@ int Memento_checkAllMemory(void) int Memento_setParanoia(int i) { - globals.paranoia = i; - if (globals.paranoia > 0) - globals.countdown = globals.paranoia; + memento.paranoia = i; + if (memento.paranoia > 0) + memento.countdown = memento.paranoia; else - globals.countdown = -globals.paranoia; + memento.countdown = -memento.paranoia; return i; } int Memento_paranoidAt(int i) { - globals.paranoidAt = i; + memento.paranoidAt = i; return i; } @@ -2043,7 +2043,7 @@ int Memento_find(void *a) data.addr = a; data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.used, Memento_containsAddr, &data); + Memento_appBlocks(&memento.used, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Address 0x%p is in %sallocated block ", data.addr, @@ -2055,7 +2055,7 @@ int Memento_find(void *a) } data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.free, Memento_containsAddr, &data); + Memento_appBlocks(&memento.free, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Address 0x%p is in %sfreed block ", data.addr, @@ -2075,7 +2075,7 @@ void Memento_breakOnFree(void *a) data.addr = a; data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.used, Memento_containsAddr, &data); + Memento_appBlocks(&memento.used, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Will stop when address 0x%p (in %sallocated block ", data.addr, @@ -2088,7 +2088,7 @@ void Memento_breakOnFree(void *a) } data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.free, Memento_containsAddr, &data); + Memento_appBlocks(&memento.free, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Can't stop on free; address 0x%p is in %sfreed block ", data.addr, @@ -2108,7 +2108,7 @@ void Memento_breakOnRealloc(void *a) data.addr = a; data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.used, Memento_containsAddr, &data); + Memento_appBlocks(&memento.used, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Will stop when address 0x%p (in %sallocated block ", data.addr, @@ -2121,7 +2121,7 @@ void Memento_breakOnRealloc(void *a) } data.blk = NULL; data.flags = 0; - Memento_appBlocks(&globals.free, Memento_containsAddr, &data); + Memento_appBlocks(&memento.free, Memento_containsAddr, &data); if (data.blk != NULL) { fprintf(stderr, "Can't stop on free/realloc; address 0x%p is in %sfreed block ", data.addr, @@ -2136,16 +2136,16 @@ void Memento_breakOnRealloc(void *a) int Memento_failAt(int i) { - globals.failAt = i; - if ((globals.sequence > globals.failAt) && - (globals.failing != 0)) + memento.failAt = i; + if ((memento.sequence > memento.failAt) && + (memento.failing != 0)) Memento_startFailing(); return i; } size_t Memento_setMax(size_t max) { - globals.maxMemory = max; + memento.maxMemory = max; return max; } #endif /* MEMENTO_CPP_EXTRAS_ONLY */ -- cgit v1.2.3