#include <errno.h>
#include "gmqcc.h"
-unsigned long long mem_ab = 0;
-unsigned long long mem_db = 0;
-unsigned long long mem_at = 0;
-unsigned long long mem_dt = 0;
+uint64_t mem_ab = 0;
+uint64_t mem_db = 0;
+uint64_t mem_at = 0;
+uint64_t mem_dt = 0;
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++;
mem_ab += info->byte;
+
return data;
}
void util_memory_d(void *ptrn, unsigned int line, const char *file) {
+ void *data = NULL;
+ struct memblock_t *info = NULL;
+
if (!ptrn) return;
- void *data = (void*)((uintptr_t)ptrn-sizeof(struct memblock_t));
- struct memblock_t *info = (struct memblock_t*)data;
+ 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\
* as well. This function shouldn't be used to create a
* char array that is later freed (it uses pointer arith)
*/
-char *util_strrq(char *s) {
- char *dst = s;
- char *src = s;
+char *util_strrq(const char *s) {
+ char *dst = (char*)s;
+ char *src = (char*)s;
char chr;
while ((chr = *src++) != '\0') {
if (chr == '\\') {
}
/*
- * Remove newline from a string (if it exists). This is
- * done pointer wise instead of strlen(), and an array
- * access.
+ * Chops a substring from an existing string by creating a
+ * copy of it and null terminating it at the required position.
*/
-char *util_strrnl(char *src) {
- if (!src) return NULL;
- char *cpy = src;
- while (*cpy && *cpy != '\n')
- cpy++;
-
- *cpy = '\0';
- return src;
+char *util_strchp(const char *s, const char *e) {
+ const char *c = NULL;
+ if (!s || !e)
+ return NULL;
+
+ c = s;
+ while (c != e)
+ c++;
+
+ return util_strdup(s);
+}
+
+/*
+ * Returns true if string is all uppercase, otherwise
+ * it returns false.
+ */
+bool util_strupper(const char *str) {
+ while (*str) {
+ if(!isupper(*str))
+ return false;
+ str++;
+ }
+ return true;
+}
+
+/*
+ * Returns true if string is all digits, otherwise
+ * it returns false.
+ */
+bool util_strdigit(const char *str) {
+ while (*str) {
+ if(!isdigit(*str))
+ return false;
+ str++;
+ }
+ return true;
+}
+
+bool util_strncmpexact(const char *src, const char *ned, size_t len) {
+ return (!strncmp(src, ned, len) && !src[len]);
}
void util_debug(const char *area, const char *ms, ...) {
+ va_list va;
if (!opts_debug)
return;
- va_list va;
+ if (!strcmp(area, "MEM") && !opts_memchk)
+ return;
+
va_start(va, ms);
fprintf (stdout, "DEBUG: ");
fputc ('[', stdout);
0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};
-
+
/*
* 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
if (!lineptr || !n || !stream)
return -1;
if (!*lineptr) {
- if (!(*lineptr = mem_a((*n=64))))
+ if (!(*lineptr = (char*)mem_a((*n=64))))
return -1;
}
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;
return (ret = pos - *lineptr);
}
-/*
- * Strechy string buffer (for easy string creation) -- this is fast, just
- * say no to strict aliasing.
- */
-//#define util_stringbuf_add(a,v) ((((a)==0 ||((int*)(a)-2)[1]+(1)>=((int*)(a)-2)[0])?util_stringbuf_grow((void**)&(a),(1),sizeof(*(a))):0),(a)[((int*)(a)-2)[1]++]=(v))
-//#define util_stringbuf_len(a) ((a)? ((int*)(a)-2)[1]:0)
-//#define util_stringbuf_del(a) ((a)?free (((int*)(a)-2)),0:0)
-void *util_stringbuf_grow(void **a, int in, int it) {
- int m = *a ? 2 * ((int*)(*a)-2)[0]+in : in+1;
- void *p = realloc(*a ? ((int*)(*a)-2) : 0, it * m + sizeof(int)*2);
- if (p) {
- if (!*a) ((int*)p)[1] = 0;
- *a = (void*)((int*)p+2);
- ((int*)(*a)-2)[0] = m;
+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;
}
- return *a;
+ *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
}
+
projects / xonotic / gmqcc.git / blobdiff