X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=util.c;h=006a81445dcfb448fc9c088a54de91a601a2752e;hb=9cf696e0fae66030aa82a7107294c68a93682f07;hp=9b8fb5c9115c5ffbe25b72f2e11dfd3e8ed48b02;hpb=fc1844e2a24cea8da00924067595af9b262f87fa;p=xonotic%2Fgmqcc.git diff --git a/util.c b/util.c index 9b8fb5c..006a814 100644 --- a/util.c +++ b/util.c @@ -33,15 +33,24 @@ struct memblock_t { const char *file; unsigned int line; unsigned int byte; + struct memblock_t *next; + struct memblock_t *prev; }; +static struct memblock_t *mem_start = NULL; + void *util_memory_a(unsigned int byte, unsigned int line, const char *file) { struct memblock_t *info = malloc(sizeof(struct memblock_t) + byte); - void *data =(void*)((uintptr_t)info+sizeof(struct memblock_t)); + void *data =(void*)((unsigned char*)info+sizeof(struct memblock_t)); if (!data) return NULL; info->line = line; info->byte = byte; info->file = file; + info->prev = NULL; + info->next = mem_start; + if (mem_start) + mem_start->prev = info; + mem_start = info; util_debug("MEM", "allocation: % 8u (bytes) address 0x%08X @ %s:%u\n", byte, data, file, line); mem_at++; @@ -53,21 +62,38 @@ void *util_memory_a(unsigned int byte, unsigned int line, const char *file) { void util_memory_d(void *ptrn, unsigned int line, const char *file) { void *data = NULL; struct memblock_t *info = NULL; + if (!ptrn) return; - data = (void*)((uintptr_t)ptrn-sizeof(struct memblock_t)); + data = (void*)((unsigned char *)ptrn-sizeof(struct memblock_t)); info = (struct memblock_t*)data; - util_debug("MEM", "released: % 8u (bytes) address 0x%08X @ %s:%u\n", info->byte, data, file, line); + util_debug("MEM", "released: % 8u (bytes) address 0x%08X @ %s:%u\n", info->byte, ptrn, file, line); mem_db += info->byte; mem_dt++; + if (info->prev) + info->prev->next = info->next; + if (info->next) + info->next->prev = info->prev; + if (info == mem_start) + mem_start = info->next; + free(data); } void util_meminfo() { + struct memblock_t *info; + if (!opts_memchk) return; + for (info = mem_start; info; info = info->next) { + util_debug("MEM", "lost: % 8u (bytes) at %s:%u\n", + info->byte, + info->file, + info->line); + } + util_debug("MEM", "Memory information:\n\ Total allocations: %llu\n\ Total deallocations: %llu\n\ @@ -164,11 +190,7 @@ bool util_strdigit(const char *str) { } bool util_strncmpexact(const char *src, const char *ned, size_t len) { - if (!strncmp(src, ned, len)) { - if (!src[len]) - return true; - } - return false; + return (!strncmp(src, ned, len) && !src[len]); } void util_debug(const char *area, const char *ms, ...) { @@ -176,6 +198,9 @@ void util_debug(const char *area, const char *ms, ...) { if (!opts_debug) return; + if (!strcmp(area, "MEM") && !opts_memchk) + return; + va_start(va, ms); fprintf (stdout, "DEBUG: "); fputc ('[', stdout); @@ -208,6 +233,28 @@ void util_endianswap(void *m, int s, int l) { } } +/* + * CRC algorithms vary in the width of the polynomial, the value of said polynomial, + * the initial value used for the register, weather the bits of each byte are reflected + * before being processed, weather the algorithm itself feeds input bytes through the + * register or XORs them with a byte from one end and then straight into the table, as + * well as (but not limited to the idea of reflected versions) where the final register + * value becomes reversed, and finally weather the value itself is used to XOR the final + * register value. AS such you can already imagine how painfully annoying CRCs are, + * of course we stand to target Quake, which expects it's certian set of rules for proper + * calculation of a CRC. + * + * In most traditional CRC algorithms on uses a reflected table driven method where a value + * or register is reflected if it's bits are swapped around it's center. For example: + * take the bits 0101 is the 4-bit reflection of 1010, and respectfully 0011 would be the + * reflection of 1100. Quakle however expects a NON-Reflected CRC on the output, but still + * requires a final XOR on the values (0xFFFF and 0x0000) this is a standard CCITT CRC-16 + * which I respectfully as a programmer don't agree with. + * + * So now you know what we target, and why we target it, despite how unsettling it may seem + * but those are what Quake seems to request. + */ + /* * This is an implementation of CRC32 & CRC16. The polynomials have been * offline computed for faster generation at the cost of larger code size. @@ -309,17 +356,29 @@ static const uint16_t util_crc16_table[] = { /* * Implements a CRC function for X worth bits using (uint[X]_t) * as type. and util_crc[X]_table. + + * Quake expects a non-reflective CRC. */ #define CRC(X) \ +uint##X##_t util_crc##X(uint##X##_t current, const char *k, size_t len) { \ + register uint##X##_t h= current; \ + for (; len; --len, ++k) \ + h = util_crc##X##_table[(h>>8)^((unsigned char)*k)]^(h<<8); \ + return h; \ +} +CRC(32) +CRC(16) +#undef CRC +/* +#define CRC(X) \ uint##X##_t util_crc##X(const char *k, int len, const short clamp) { \ register uint##X##_t h= (uint##X##_t)0xFFFFFFFF; \ for (; len; --len, ++k) \ h = util_crc##X##_table[(h^((unsigned char)*k))&0xFF]^(h>>8); \ return (~h)%clamp; \ } -CRC(32) -CRC(16) -#undef CRC +*/ + /* * Implements libc getline for systems that don't have it, which is @@ -333,7 +392,7 @@ int util_getline(char **lineptr, size_t *n, FILE *stream) { if (!lineptr || !n || !stream) return -1; if (!*lineptr) { - if (!(*lineptr = mem_a((*n=64)))) + if (!(*lineptr = (char*)mem_a((*n=64)))) return -1; } @@ -344,12 +403,12 @@ int util_getline(char **lineptr, size_t *n, FILE *stream) { int c = getc(stream); if (chr < 2) { - char *tmp = mem_a((*n+=(*n>16)?*n:64)); + char *tmp = (char*)mem_a((*n+=(*n>16)?*n:64)); if (!tmp) return -1; + memcpy(tmp, *lineptr, pos - *lineptr); chr = *n + *lineptr - pos; - strcpy(tmp,*lineptr); if (!(*lineptr = tmp)) { mem_d (tmp); return -1; @@ -375,10 +434,43 @@ int util_getline(char **lineptr, size_t *n, FILE *stream) { return (ret = pos - *lineptr); } -/* TODO: opts.c? when it gets large enugh */ -/* global options */ -bool opts_debug = false; -bool opts_memchk = false; -bool opts_darkplaces_stringtablebug = false; -bool opts_omit_nullcode = false; -int opts_compiler = COMPILER_GMQCC; +size_t util_strtocmd(const char *in, char *out, size_t outsz) { + size_t sz = 1; + for (; *in && sz < outsz; ++in, ++out, ++sz) { + if (*in == '-') + *out = '_'; + else if (isalpha(*in) && !isupper(*in)) + *out = *in + 'A' - 'a'; + else + *out = *in; + } + *out = 0; + return sz-1; +} + +size_t util_strtononcmd(const char *in, char *out, size_t outsz) { + size_t sz = 1; + for (; *in && sz < outsz; ++in, ++out, ++sz) { + if (*in == '_') + *out = '-'; + else if (isalpha(*in) && isupper(*in)) + *out = *in + 'a' - 'A'; + else + *out = *in; + } + *out = 0; + return sz-1; +} + +FILE *util_fopen(const char *filename, const char *mode) +{ +#ifdef WIN32 + FILE *out; + if (fopen_s(&out, filename, mode) != 0) + return NULL; + return out; +#else + return fopen(filename, mode); +#endif +} +