/* error.c
 * (c) 2002 Mikulas Patocka
 * This file is a part of the Links program, released under GPL.
 */

#include "links.h"

#if DEBUGLEVEL >= 2
#define RED_ZONE	'R'
#endif
#if DEBUGLEVEL >= 3
#define FREE_FILL	0xfe
#define REALLOC_FILL	0xfd
#define ALLOC_FILL	0xfc
#endif

#if DEBUGLEVEL < 0
#define FREE_FILL	0xfe
#endif

#ifdef RED_ZONE
#define RED_ZONE_INC	1
#else
#define RED_ZONE_INC	0
#endif

volatile char dummy_val;
volatile char * volatile dummy_ptr = &dummy_val;
volatile char * volatile x_ptr;

void *do_not_optimize_here(void *p)
{
	/* break ANSI aliasing */
	x_ptr = p;
	*dummy_ptr = 0;
	return p;
}


#if defined(USE_WIN32_HEAP)

#include <windows.h>

/*#define NEW_HEAP*/

static HANDLE heap;

#define heap_malloc(s)		HeapAlloc(heap, 0, (s))
#define heap_calloc(s)		HeapAlloc(heap, HEAP_ZERO_MEMORY, (s))
#define heap_free(p)		HeapFree(heap, 0, (p))
#define heap_realloc(p, s)	HeapReAlloc(heap, 0, (p), (s))

void init_heap(void)
{
#ifndef NEW_HEAP
	heap = GetProcessHeap();
#else
	if (!(heap = HeapCreate(0, 0, 0)))
		fatal_exit("HeapCreate failed: %x", (unsigned)GetLastError());
#endif
	{
		ULONG heap_frag = 2;
		if (!HeapSetInformation(heap, HeapCompatibilityInformation, &heap_frag, sizeof(heap_frag))) {
			/*fatal_exit("HeapSetInformation failed: %x", (unsigned)GetLastError());*/
		}
	}
}

static void exit_heap(void)
{
#if DEBUGLEVEL >= 1
	if (!HeapValidate(heap, 0, NULL))
		internal_error("HeapValidate failed: %x", (unsigned)GetLastError());
#endif
#ifdef NEW_HEAP
	if (!HeapDestroy(heap))
		internal_error("HeapDestroy failed: %x", (unsigned)GetLastError());
#endif
}

#elif defined(OS2_ADVANCED_HEAP) || defined(VMS_ADVANCED_HEAP)

#define SIZE_THRESHOLD		65536
#define REALLOC_PART		32

struct heap_entry {
	void *ptr;
	size_t len;
};

static struct heap_entry *heap_entries;
unsigned long mem_bigalloc;
unsigned long blocks_bigalloc;
unsigned long blocks_bigalloc_allocated;
static my_uintptr_t heap_mask;

static void *big_calloc(size_t size, int re_al)
{
	void *ptr;
	my_uintptr_t mask;
	size_t padding;
	if (blocks_bigalloc == blocks_bigalloc_allocated) {
		struct heap_entry *he;
		if (blocks_bigalloc_allocated > MAXINT / 2 / sizeof(struct heap_entry) - 1)
			return NULL;
		he = realloc(heap_entries, (blocks_bigalloc_allocated + 1) * sizeof(struct heap_entry));
		if (!he)
			return NULL;
		heap_entries = he;
		blocks_bigalloc_allocated++;
	}
	padding = page_size;
	if (re_al) {
		while (padding < size / REALLOC_PART && (size_t)(padding * 2) != 0)
			padding *= 2;
	}
	size = (size + padding - 1) & ~(padding - 1);
	if (!size)
		return NULL;
	ptr = virtual_alloc(size);
	if (!ptr)
		return NULL;
	heap_entries[blocks_bigalloc].ptr = ptr;
	heap_entries[blocks_bigalloc].len = size;
	blocks_bigalloc++;
	mem_bigalloc += size;
	mask = (my_uintptr_t)ptr;
	mask ^= (mask - 1);
	mask >>= 1;
	heap_mask &= mask;
	/*fprintf(stderr, "mask: %p -> %x -> %x\n", ptr, mask, heap_mask);*/
	return ptr;
}

static void *heap_malloc(size_t size)
{
	if (size >= SIZE_THRESHOLD) {
		void *ptr = big_calloc(size, 0);
		if (ptr)
			return ptr;
	}
#ifdef OPENVMS_64BIT
	if (size > 0x77fffff0)
		return NULL;
#endif
	return malloc(size);
}

static void *heap_calloc(size_t size)
{
	if (size >= SIZE_THRESHOLD) {
		void *ptr = big_calloc(size, 0);
		if (ptr)
			return ptr;
	}
#ifdef OPENVMS_64BIT
	if (size > 0x77fffff0)
		return NULL;
#endif
	return calloc(1, size);
}

static void heap_free(void *ptr)
{
	unsigned i;
	if (!((my_uintptr_t)ptr & heap_mask)) {
		for (i = 0; i < blocks_bigalloc; i++) {
			if (heap_entries[i].ptr == ptr) {
				virtual_free(ptr, heap_entries[i].len);
				mem_bigalloc -= heap_entries[i].len;
				blocks_bigalloc--;
				heap_entries[i] = heap_entries[blocks_bigalloc];
				return;
			}
		}
	}
	free(ptr);
}

static void *heap_realloc(void *ptr, size_t size)
{
	void *new_ptr;
	if (!((my_uintptr_t)ptr & heap_mask)) {
		unsigned i;
		for (i = 0; i < blocks_bigalloc; i++) {
			if (heap_entries[i].ptr == ptr) {
				if (size <= heap_entries[i].len)
					return ptr;
				new_ptr = big_calloc(size, 1);
				if (!new_ptr)
					new_ptr = heap_malloc(size);
				if (!new_ptr)
					return NULL;
				memcpy(new_ptr, ptr, heap_entries[i].len);
				heap_free(ptr);
				return new_ptr;
			}
		}
	}
#ifdef OPENVMS_64BIT
	if (size > 0x77fffff0)
		return NULL;
#endif
	if (size >= SIZE_THRESHOLD) {
		new_ptr = big_calloc(size, 1);
		if (new_ptr) {
#ifdef HAVE__MSIZE
			size_t to_copy = _msize(ptr);
			if (to_copy > size) to_copy = size;
			memcpy(new_ptr, ptr, to_copy);
#else
			ptr = realloc(ptr, size);
			if (!ptr) {
				heap_free(new_ptr);
				return NULL;
			}
			memcpy(new_ptr, ptr, size);
#endif
			free(ptr);
			return new_ptr;
		}
	}
	return realloc(ptr, size);
}

void init_heap(void)
{
	mem_bigalloc = 0;
	blocks_bigalloc = 0;
	blocks_bigalloc_allocated = 0;
	heap_entries = NULL;
	heap_mask = -1;
}

static void exit_heap(void)
{
	free(heap_entries);
	heap_entries = NULL;
}

#else

#define heap_malloc	malloc
#define heap_realloc	realloc
#define heap_free	free
#ifdef HAVE_CALLOC
#define heap_calloc(x) calloc(1, (x))
#else
static inline void *heap_calloc(size_t x)
{
	void *p;
	if ((p = heap_malloc(x))) memset(p, 0, x);
	return p;
}
#endif
void init_heap(void)
{
}
#define exit_heap()	do { } while (0)

#endif


#ifdef LEAK_DEBUG

my_uintptr_t mem_amount = 0;
my_uintptr_t mem_blocks = 0;

#define ALLOC_MAGIC		0xa110c
#define ALLOC_FREE_MAGIC	0xf4ee
#define ALLOC_REALLOC_MAGIC	0x4ea110c

#ifndef LEAK_DEBUG_LIST
struct alloc_header {
	int magic;
	size_t size;
};
#else
struct alloc_header {
	list_entry_1st
	size_t size;
	unsigned char *file;
	unsigned char *comment;
	list_entry_last
	int line;
	int magic;
};
static struct list_head memory_list = { &memory_list, &memory_list };
#endif

#define L_D_S ((sizeof(struct alloc_header) + 15) & ~15)

unsigned alloc_overhead = L_D_S + RED_ZONE_INC;

#endif

static inline void force_dump(void)
{
#if defined(DOS)
	fprintf(stderr, "\n"ANSI_SET_BOLD"Exiting"ANSI_CLEAR_BOLD"\n");
	fflush(stdout);
	fflush(stderr);
	exit(RET_INTERNAL);
#else
	int rs;
	fprintf(stderr, "\n"ANSI_SET_BOLD"Forcing core dump"ANSI_CLEAR_BOLD"\n");
	fflush(stdout);
	fflush(stderr);
	EINTRLOOP(rs, raise(SIGSEGV));
#endif
}

void check_memory_leaks(void)
{
#if defined(LEAK_DEBUG) && !defined(NO_IE)
	if (mem_amount || mem_blocks) {
		char rb[OS_REPORT_ERROR_BUFFER];
		char *rp = rb;

		fatal_tty_exit();

		fprintf(stderr, "\n"ANSI_SET_BOLD"Memory leak by %lu bytes (%lu blocks)"ANSI_CLEAR_BOLD"\n", (unsigned long)mem_amount, (unsigned long)mem_blocks);
		snprintf(rp, sizeof rb - (rp - rb), "Memory leak by %lu bytes (%lu blocks)", (unsigned long)mem_amount, (unsigned long)mem_blocks);
		rp = strchr(rp, 0);

#ifdef LEAK_DEBUG_LIST
		fprintf(stderr, "\nList of blocks: ");
		snprintf(rp, sizeof rb - (rp - rb), ":\r\n");
		rp = strchr(rp, 0);

		{
			int r = 0;
			struct alloc_header *ah;
			struct list_head *lah;
			foreach(struct alloc_header, ah, lah, memory_list) {
				fprintf(stderr, "%s%p:%lu @ %s:%d", r ? ", ": "", (unsigned char *)ah + L_D_S, (unsigned long)ah->size, ah->file, ah->line);
				snprintf(rp, sizeof rb - (rp - rb), "%s%p:%lu @ %s:%d", r ? ", ": "", (unsigned char *)ah + L_D_S, (unsigned long)ah->size, ah->file, ah->line);
				rp = strchr(rp, 0);

				if (ah->comment) {
					fprintf(stderr, ":\"%s\"", ah->comment);
					snprintf(rb, sizeof rb - (rp - rb), ":\"%s\"", ah->comment);
					rp = strchr(rp, 0);
				}
				r = 1;
			}
			fprintf(stderr, "\n");
		}
#endif
		os_report_error("Memory leak", rb, NULL);
		force_dump();
	}
#endif
	exit_heap();
}

static void er(int b, const char *m, va_list l)
{
#ifdef HAVE_VPRINTF
	vfprintf(stderr, cast_const_char m, l);
#else
	fprintf(stderr, "%s", m);
#endif
	if (b) fprintf(stderr, ANSI_BELL);
	fprintf(stderr, "\n");
	fflush(stderr);
	portable_sleep(1000);
}

void error(const char *m, ...)
{
	va_list l;

	va_start(l, m);
	os_report_error_va("Error", m, l);
	va_end(l);

	va_start(l, m);
	fprintf(stderr, "\n");
	er(1, m, l);
	va_end(l);
}

void fatal_exit(const char *m, ...)
{
	va_list l;

	va_start(l, m);
	os_report_error_va("Fatal error", m, l);
	va_end(l);

	fatal_tty_exit();

	va_start(l, m);
	fprintf(stderr, "\n");
	er(1, m, l);
	va_end(l);
	fflush(stdout);
	fflush(stderr);
	exit(RET_FATAL);
}

int errline;
unsigned char *errfile;

static unsigned char errbuf[4096];

void int_error(const char *m, ...)
{
#ifdef NO_IE
	return;
#else
	va_list l;

	sprintf(cast_char errbuf, "Internal error at %s:%d\r\n%s", errfile, errline, m);
	va_start(l, m);
	os_report_error_va("Internal error", cast_const_char errbuf, l);
	va_end(l);

	fatal_tty_exit();

	sprintf(cast_char errbuf, "\n"ANSI_SET_BOLD"INTERNAL ERROR"ANSI_CLEAR_BOLD" at %s:%d: %s", errfile, errline, m);
	va_start(l, m);
	er(1, cast_char errbuf, l);
	va_end(l);

	force_dump();
	exit(RET_INTERNAL);
#endif
}

void debug_msg(const char *m, ...)
{
	va_list l;
	va_start(l, m);
	sprintf(cast_char errbuf, "\nDEBUG MESSAGE at %s:%d: %s", errfile, errline, m);
	er(0, cast_char errbuf, l);
	va_end(l);
}

#ifdef LEAK_DEBUG

void *debug_mem_alloc(unsigned char *file, int line, size_t size, int mayfail)
{
	void *p;
#ifdef LEAK_DEBUG
	struct alloc_header *ah;
#endif
	dos_poll_break();
	debug_test_free(file, line);
	if (!size) return DUMMY;
	if (size > MAX_SIZE_T - L_D_S - RED_ZONE_INC) {
		if (mayfail) return NULL;
		overalloc_at(file, line);
	}
	size += L_D_S;
	retry:
#ifdef LEAK_DEBUG
	mem_amount += size - L_D_S;
	mem_blocks++;
#endif
	if (!(p = heap_malloc(size + RED_ZONE_INC))) {
#ifdef LEAK_DEBUG
		mem_amount -= size - L_D_S;
		mem_blocks--;
#endif
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "malloc" : NULL, size + RED_ZONE_INC, file, line)) goto retry;
		return NULL;
	}
#ifdef RED_ZONE
	*((unsigned char *)p + size + RED_ZONE_INC - 1) = RED_ZONE;
#endif
#ifdef LEAK_DEBUG
	ah = p;
	p = (unsigned char *)p + L_D_S;
	ah->size = size - L_D_S;
	ah->magic = ALLOC_MAGIC;
#ifdef LEAK_DEBUG_LIST
	ah->file = file;
	ah->line = line;
	ah->comment = NULL;
	add_to_list(memory_list, ah);
#endif
#endif
#ifdef ALLOC_FILL
	memset(p, ALLOC_FILL, size - L_D_S);
#endif
	return p;
}

void *debug_mem_calloc(unsigned char *file, int line, size_t size, int mayfail)
{
	void *p;
#ifdef LEAK_DEBUG
	struct alloc_header *ah;
#endif
	dos_poll_break();
	debug_test_free(file, line);
	if (!size) return DUMMY;
	if (size > MAX_SIZE_T - L_D_S - RED_ZONE_INC) {
		if (mayfail) return NULL;
		overalloc_at(file, line);
	}
	size += L_D_S;
	retry:
#ifdef LEAK_DEBUG
	mem_amount += size - L_D_S;
	mem_blocks++;
#endif
	if (!(p = heap_calloc(size + RED_ZONE_INC))) {
#ifdef LEAK_DEBUG
		mem_amount -= size - L_D_S;
		mem_blocks--;
#endif
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "calloc" : NULL, size + RED_ZONE_INC, file, line)) goto retry;
		return NULL;
	}
#ifdef RED_ZONE
	*((unsigned char *)p + size + RED_ZONE_INC - 1) = RED_ZONE;
#endif
#ifdef LEAK_DEBUG
	ah = p;
	p = (unsigned char *)p + L_D_S;
	ah->size = size - L_D_S;
	ah->magic = ALLOC_MAGIC;
#ifdef LEAK_DEBUG_LIST
	ah->file = file;
	ah->line = line;
	ah->comment = NULL;
	add_to_list(memory_list, ah);
#endif
#endif
	return p;
}

void debug_mem_free(unsigned char *file, int line, void *p)
{
#ifdef LEAK_DEBUG
	struct alloc_header *ah;
#endif
	dos_poll_break();
	if (p == DUMMY) return;
	if (!p) {
		errfile = file, errline = line, int_error("mem_free(NULL)");
		return;
	}
#ifdef LEAK_DEBUG
	p = (unsigned char *)p - L_D_S;
	ah = p;
	if (ah->magic != ALLOC_MAGIC) {
		errfile = file, errline = line, int_error("mem_free: magic doesn't match: %08x", ah->magic);
		return;
	}
#ifdef FREE_FILL
	memset((unsigned char *)p + L_D_S, FREE_FILL, ah->size);
#endif
	ah->magic = ALLOC_FREE_MAGIC;
#ifdef LEAK_DEBUG_LIST
	del_from_list(ah);
#endif
	mem_amount -= ah->size;
	mem_blocks--;
#endif
#ifdef RED_ZONE
	if (*((unsigned char *)p + L_D_S + ah->size + RED_ZONE_INC - 1) != RED_ZONE) {
		errfile = file, errline = line, int_error("mem_free: red zone damaged: %02x (block allocated at %s:%d%s%s)", *((unsigned char *)p + L_D_S + ah->size + RED_ZONE_INC - 1),
#ifdef LEAK_DEBUG_LIST
		ah->file, ah->line, ah->comment ? ":" : "", ah->comment ? ah->comment : (unsigned char *)"");
#else
		"-", 0, "-");
#endif
		return;
	}
#endif
#ifdef LEAK_DEBUG_LIST
	if (ah->comment) heap_free(ah->comment);
#endif
	heap_free(p);
}

void *debug_mem_realloc(unsigned char *file, int line, void *p, size_t size, int mayfail)
{
#ifdef LEAK_DEBUG
	struct alloc_header *ah;
#endif
	void *np;
	if (p == DUMMY) return debug_mem_alloc(file, line, size, mayfail);
	dos_poll_break();
	debug_test_free(file, line);
	if (!p) {
		errfile = file, errline = line, int_error("mem_realloc(NULL, %lu)", (unsigned long)size);
		return NULL;
	}
	if (!size) {
		debug_mem_free(file, line, p);
		return DUMMY;
	}
	if (size > MAX_SIZE_T - L_D_S - RED_ZONE_INC) {
		if (mayfail) return NULL;
		overalloc_at(file, line);
	}
#ifdef LEAK_DEBUG
	p = (unsigned char *)p - L_D_S;
	ah = p;
	if (ah->magic != ALLOC_MAGIC) {
		errfile = file, errline = line, int_error("mem_realloc: magic doesn't match: %08x", ah->magic);
		return NULL;
	}
	ah->magic = ALLOC_REALLOC_MAGIC;
#ifdef REALLOC_FILL
	if (!mayfail && size < (size_t)ah->size) memset((unsigned char *)p + L_D_S + size, REALLOC_FILL, ah->size - size);
#endif
#endif
#ifdef RED_ZONE
	if (*((unsigned char *)p + L_D_S + ah->size + RED_ZONE_INC - 1) != RED_ZONE) {
		errfile = file, errline = line, int_error("mem_realloc: red zone damaged: %02x (block allocated at %s:%d%s%s)", *((unsigned char *)p + L_D_S + ah->size + RED_ZONE_INC - 1),
#ifdef LEAK_DEBUG_LIST
		ah->file, ah->line, ah->comment ? ":" : "", ah->comment ? ah->comment : (unsigned char *)"");
#else
		"-", 0, "-");
#endif
		return (unsigned char *)p + L_D_S;
	}
#endif
	retry:
	if (!(np = heap_realloc(p, size + L_D_S + RED_ZONE_INC))) {
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "realloc" : NULL, size + L_D_S + RED_ZONE_INC, file, line)) goto retry;
		ah->magic = ALLOC_MAGIC;
		return NULL;
	}
	p = np;
#ifdef RED_ZONE
	*((unsigned char *)p + size + L_D_S + RED_ZONE_INC - 1) = RED_ZONE;
#endif
#ifdef LEAK_DEBUG
	ah = p;
	/* OpenVMS Alpha C miscompiles this: mem_amount += size - ah->size; */
	mem_amount += size;
	mem_amount -= ah->size;
	ah->size = size;
	ah->magic = ALLOC_MAGIC;
#ifdef LEAK_DEBUG_LIST
	fix_list_after_realloc(ah);
#endif
#endif
	return (unsigned char *)p + L_D_S;
}

void set_mem_comment(void *p, unsigned char *c, int l)
{
#ifdef LEAK_DEBUG_LIST
	struct alloc_header *ah = (struct alloc_header *)((unsigned char *)p - L_D_S);
	if (ah->comment) heap_free(ah->comment);
	if ((ah->comment = heap_malloc(l + 1))) memcpy(ah->comment, c, l), ah->comment[l] = 0;
#endif
}

#ifdef JS
unsigned char *get_mem_comment(void *p)
{
#ifdef LEAK_DEBUG_LIST
	/* perm je prase: return ((struct alloc_header*)((unsigned char*)((void*)((unsigned char*)p-sizeof(int))) - L_D_S))->comment;*/
	struct alloc_header *ah = (struct alloc_header *)((unsigned char *)p - L_D_S);
	if (!ah->comment) return cast_uchar "";
	else return ah->comment;
#else
	return cast_uchar "";
#endif
}
#endif

#else

void *mem_alloc_(size_t size, int mayfail)
{
	void *p;
	dos_poll_break();
	debug_test_free(NULL, 0);
	if (!size) return DUMMY;
	if (size > MAX_SIZE_T) {
		if (mayfail) return NULL;
		overalloc();
	}
	retry:
	if (!(p = heap_malloc(size))) {
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "malloc" : NULL, size, NULL, 0)) goto retry;
		return NULL;
	}
	return p;
}

void *mem_calloc_(size_t size, int mayfail)
{
	void *p;
	dos_poll_break();
	debug_test_free(NULL, 0);
	if (!size) return DUMMY;
	if (size > MAX_SIZE_T) {
		if (mayfail) return NULL;
		overalloc();
	}
	retry:
	if (!(p = heap_calloc(size))) {
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "calloc" : NULL, size, NULL, 0)) goto retry;
		return NULL;
	}
	return p;
}

void mem_free(void *p)
{
	dos_poll_break();
	if (p == DUMMY) return;
	if (!p) {
		internal_error("mem_free(NULL)");
		return;
	}
	heap_free(p);
}

void *mem_realloc_(void *p, size_t size, int mayfail)
{
	void *np;
	if (p == DUMMY) return mem_alloc_(size, mayfail);
	dos_poll_break();
	debug_test_free(NULL, 0);
	if (!p) {
		internal_error("mem_realloc(NULL, %lu)", (unsigned long)size);
		return NULL;
	}
	if (!size) {
		mem_free(p);
		return DUMMY;
	}
	if (size > MAX_SIZE_T) {
		if (mayfail) return NULL;
		overalloc();
	}
	retry:
	if (!(np = heap_realloc(p, size))) {
		if (out_of_memory_fl(0, !mayfail ? cast_uchar "realloc" : NULL, size, NULL, 0)) goto retry;
		return NULL;
	}
	return np;
}

#endif

#if !(defined(LEAK_DEBUG) && defined(LEAK_DEBUG_LIST))

unsigned char *memacpy(const unsigned char *src, size_t len)
{
	unsigned char *m;
	if (!(len + 1)) overalloc();
	m = (unsigned char *)mem_alloc(len + 1);
	if (len)
		memcpy(m, src, len);
	m[len] = 0;
	return m;
}

unsigned char *stracpy(const unsigned char *src)
{
	return src ? memacpy(src, src != DUMMY ? strlen(cast_const_char src) : 0) : NULL;
}

#else

unsigned char *debug_memacpy(unsigned char *f, int l, const unsigned char *src, size_t len)
{
	unsigned char *m;
	m = (unsigned char *)debug_mem_alloc(f, l, len + 1, 0);
	if (len)
		memcpy(m, src, len);
	m[len] = 0;
	return m;
}

unsigned char *debug_stracpy(unsigned char *f, int l, const unsigned char *src)
{
	return src ? (unsigned char *)debug_memacpy(f, l, src, src != DUMMY ? strlen(cast_const_char src) : 0L) : NULL;
}

#endif

#if defined(LEAK_DEBUG) && defined(LEAK_DEBUG_LIST)

struct memory_entry {
	struct alloc_header *ah;
	my_uintptr_t cumulative_size;
	my_uintptr_t n_blocks;
};

LIBC_CALLBACK static int memory_sort_file_line(const void *l1_, const void *l2_)
{
	const struct memory_entry *l1 = (const struct memory_entry *)l1_;
	const struct memory_entry *l2 = (const struct memory_entry *)l2_;
	int c;
	c = strcmp(cast_const_char l1->ah->file, cast_const_char l2->ah->file);
	if (c)
		return c;
	if (l1->ah->line != l2->ah->line)
		return l1->ah->line - l2->ah->line;
	return 0;
}

LIBC_CALLBACK static int memory_sort_cumulative_size(const void *l1_, const void *l2_)
{
	const struct memory_entry *l1 = (const struct memory_entry *)l1_;
	const struct memory_entry *l2 = (const struct memory_entry *)l2_;
	int c;
	if (l1->cumulative_size < l2->cumulative_size)
		return 1;
	if (l1->cumulative_size > l2->cumulative_size)
		return -1;
	if (l1->n_blocks < l2->n_blocks)
		return 1;
	if (l1->n_blocks > l2->n_blocks)
		return -1;
	c = strcmp(cast_const_char l1->ah->file, cast_const_char l2->ah->file);
	if (c)
		return c;
	if (l1->ah->line != l2->ah->line)
		return l1->ah->line - l2->ah->line;
	return 0;
}

static int num_digits(my_uintptr_t num)
{
	int n = 0;
	do {
		n++;
		num /= 10;
	} while (num);
	return n;
}

unsigned char *get_top_memory(int mode, unsigned n)
{
	struct memory_entry *entries;
	struct alloc_header *ah;
	struct list_head *lah;
	my_uintptr_t offs, offs2, mr, ln;
	unsigned char *r;
	int rl;
	int nd = 0;	/* against warning */

	entries = malloc(sizeof(struct memory_entry) * mem_blocks);
	if (!entries)
		return stracpy(cast_uchar "Not enough memory");

	offs = 0;
	foreach(struct alloc_header, ah, lah, memory_list) {
		entries[offs].ah = ah;
		entries[offs].cumulative_size = ah->size;
		entries[offs].n_blocks = 1;
		offs++;
	}
	if (offs) qsort(entries, offs, sizeof(struct memory_entry), (int (*)(const void *, const void *))memory_sort_file_line);
	if (mode == GTM_MOST_ALLOCATED) {
		offs2 = 0;
		for (mr = 0; mr < offs; mr++) {
			entries[offs2] = entries[mr];
			while (mr + 1 < offs &&
			      !strcmp(cast_const_char entries[mr].ah->file, cast_const_char entries[mr + 1].ah->file) &&
			      entries[mr].ah->line == entries[mr + 1].ah->line) {
				mr++;
				entries[offs2].cumulative_size += entries[mr].ah->size;
				entries[offs2].n_blocks++;
			}
			offs2++;
		}
	} else {
		offs2 = offs;
	}
	if (offs2) qsort(entries, offs2, sizeof(struct memory_entry), (int (*)(const void *, const void *))memory_sort_cumulative_size);
	r = init_str();
	rl = 0;
	if (offs2) {
		nd = num_digits(entries[0].cumulative_size);
	}
	for (mr = 0, ln = 0; mr < offs2 && ln < n; mr++, ln++) {
		int l1 = rl;
		int d1;
		unsigned char *g, *f = entries[mr].ah->file;
		while ((g = cast_uchar strchr(cast_const_char f, '/'))) f = g + 1;
		add_to_str(&r, &rl, f);
		add_chr_to_str(&r, &rl, ':');
		add_num_to_str(&r, &rl, entries[mr].ah->line);
		add_chr_to_str(&r, &rl, ' ');
		d1 = num_digits(entries[mr].cumulative_size);
		while (rl < l1 + 24 + (nd - d1))
			add_chr_to_str(&r, &rl, ' ');
		add_num_to_str(&r, &rl, entries[mr].cumulative_size);
		if (mode == GTM_MOST_ALLOCATED) {
			add_to_str(&r, &rl, cast_uchar " / ");
			add_num_to_str(&r, &rl, entries[mr].n_blocks);
		} else if (mode == GTM_LARGEST_BLOCKS) {
			my_uintptr_t mq;
			for (mq = mr + 1; mq < offs2; mq++) {
				if (strcmp(cast_const_char entries[mr].ah->file, cast_const_char entries[mq].ah->file))
					break;
				if (entries[mr].ah->line != entries[mq].ah->line)
					break;
				if (entries[mr].cumulative_size != entries[mq].cumulative_size)
					break;
			}
			if (mq > mr + 1) {
				add_to_str(&r, &rl, cast_uchar " x ");
				add_num_to_str(&r, &rl, mq - mr);
			}
			mr = mq - 1;
		}
		add_chr_to_str(&r, &rl, '\n');
	}
	if (rl) {
		rl--;
		r[rl] = 0;
	}
	free(entries);
	return r;
}

#endif

#ifdef OOPS

struct prot {
	list_entry_1st
	sigjmp_buf buf;
	list_entry_last
};

static struct list_head prot = { &prot, &prot };

static void fault(void *dummy)
{
	struct prot *p;
	/*fprintf(stderr, "FAULT: %d !\n", (int)(unsigned long)dummy);*/
	if (list_empty(prot)) {
		fatal_tty_exit();
		exit(0);
	}
	p = list_struct(prot.next, struct prot);
	del_from_list(p);
	longjmp(p->buf, 1);
}

sigjmp_buf *new_stack_frame(void)
{
	static int handled = 0;
	struct prot *new;
	if (!handled) {
#ifdef SIGILL
		install_signal_handler(SIGILL, fault, (void *)SIGILL, 1);
#endif
#ifdef SIGABRT
		install_signal_handler(SIGABRT, fault, (void *)SIGABRT, 1);
#endif
#ifdef SIGFPE
		install_signal_handler(SIGFPE, fault, (void *)SIGFPE, 1);
#endif
#ifdef SIGSEGV
		install_signal_handler(SIGSEGV, fault, (void *)SIGSEGV, 1);
#endif
#ifdef SIGBUS
		install_signal_handler(SIGBUS, fault, (void *)SIGBUS, 1);
#endif
		handled = 1;
	}
	if (!(new = mem_alloc(sizeof(struct prot)))) return NULL;
	add_to_list(prot, new);
	return &new->buf;
}

void xpr(void)
{
	if (!list_empty(prot)) {
		struct prot *next = list_struct(prot.next, struct prot);
		del_from_list(next);
		mem_free(next);
	}
}

void nopr(void)
{
	free_list(struct prot, prot);
}

#endif