Subversion Repositories igor

#define _GNU_SOURCE

#include <sys/types.h>

#include <assert.h>

#include <stdio.h>

#include <err.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include "debug.h"

#include "hash.h"

#include "linkedlist.h"

#include "alloc.h"

hash

uint_hash(unsigned int *_key)

{

        hash key = *_key;

        key = ~key + (key << 15); // key = (key << 15) - key - 1;

        key = key ^ (key >> 12);

        key = key + (key << 2);

        key = key ^ (key >> 4);

        key = key * 2057; // key = (key + (key << 3)) + (key << 11);

        key = key ^ (key >> 16);

        return key;

}

hash

uint_cmp(unsigned int *k1, unsigned int *k2)

{

        return (*k1 == *k2);

}

HASH_DEFINE(hash_debuginfo, uint_cmp, uint_hash, unsigned int, void);

HASH_DECLARE(hash_debuginfo, uint_cmp, uint_hash, unsigned int, void);

static void

add_constant(char *group, char *name, unsigned int number)

{

        llist_t list;

        struct di_const *c;

        list = hash_debuginfo_lookup(debuginfo->constants, &number);

        if (list == NULL) {

                unsigned int *key = smalloc(sizeof(*key));

                *key = number;

                list = llist_make();

                hash_debuginfo_insert(debuginfo->constants, key, list);

        }

        c = smalloc(sizeof(*c));

        c->group = sstrdup(group);

        c->name = sstrdup(name);

        llist_add_tail(list, c);

}

int

debug_init(const char *path)

{

        char constfile[2048];

        char *line, group[1024], name[1024];

        unsigned int number;

        char *p, *p2;

        size_t n;

        FILE *fp;

        debuginfo = malloc(sizeof(*debuginfo));

        if (debuginfo == NULL)

                return 0;

        debuginfo->constants = hash_debuginfo_create(128, 0.50);

        snprintf(constfile, sizeof(constfile), "%s.const", path);

        fp = fopen(constfile, "r");

        if (fp == NULL) {

                debuginfo = NULL;

                return 0;

        }

        // Load constant information from file

        line = NULL;

        while (getline(&line, &n, fp) > 0) {

                line[strlen(line)-1] = '\0';

                p = strchr(line, ' ');

                *p = '\0';

                strncpy(group, line, sizeof(group));

                p++;

                p2 = strchr(p, ' ');

                *p2 = '\0';

                strncpy(name, p, sizeof(name));

                p2++;

                number = strtol(p2, NULL, 16);

                free(line);

                add_constant(group, name, number);

                line = NULL;

        }

        fclose(fp);

        return 1;

}

void

debug_show(unsigned int x)

{

        debug_show_filter(x, NULL);

}

void

debug_show_filter(unsigned int x, const char *filter)

{

        llist_t l;

        llist_node_t node;

        if (debuginfo == NULL) {

                // No debuginfo loaded

                return;

        }

        l = hash_debuginfo_lookup(debuginfo->constants, &x);

        if (l == NULL) {

                printf("no debuginfo for: %x\n", x);

        } else {

                struct di_const *c;

                LLIST_FOREACH(l, node) {

                        c = llist_getobj(node);

                        if (filter == NULL || strcmp(filter, c->group) == 0)

                                printf("> %s %s %x\n", c->group, c->name, x);

                }

        }

}

struct di_const *

debug_get1(unsigned int x)

{

        return debug_get1_filter(x, NULL);

}

struct di_const *

debug_get1_filter(unsigned int x, const char *filter)

{

        llist_t l;

        llist_node_t node;

        if (debuginfo == NULL) {

                // No debuginfo loaded

                return NULL;

        }

        l = hash_debuginfo_lookup(debuginfo->constants, &x);

        if (l == NULL) {

                return NULL;

        } else {

                struct di_const *c;

                LLIST_FOREACH(l, node) {

                        c = llist_getobj(node);

                        if (filter == NULL || strcmp(filter, c->group) == 0)

                                return c;

                }

        }

        return NULL;

}

unsigned int

debug_get_key(const char *name, const char *group)

{

        hash i;

        struct hash_bucket *b;

        struct di_const *c;

        llist_node_t node;

        llist_t l;

        for (i = 0; i < debuginfo->constants->h_size; i++) {

                b = &debuginfo->constants->h_bucket[i];

                if (b->key == NULL)

                        continue;

                l = b->value;

                LLIST_FOREACH(l, node) {

                        c = llist_getobj(node);

                        if (strcasecmp(c->name, name) == 0 &&

                            strcasecmp(c->group, group) == 0)

                                return *((unsigned int*)b->key);

                }

        }

        return 0xdeadbeef;

}