prt_tuple.c

Go to the documentation of this file.

#include "prt_tuple.h"

static unsigned int fnv_hash(void *key, int len);


int *prt_tuple_new(int len, ...)
{
    int *tuple = (int*)malloc((len+1)*sizeof(int));
    prt_assert(tuple != NULL, "malloc failed");
    int i;
    va_list ap;
    va_start(ap, len);
    for (i = 0; i < len; i++)
        tuple[i] = va_arg(ap, int);
    va_end(ap);
    tuple[len] = INT_MAX;
    return tuple;
}


int prt_tuple_len(int *tuple)
{
    int *p = tuple;
    while (*p++ != INT_MAX);
    return (p-tuple-1);
}


int* prt_tuple_cat(int *first_tuple, ...)
{
    int len;
    int *tuple;
    va_list ap;
    va_start(ap, first_tuple);
    len = prt_tuple_len(first_tuple);
    while ((tuple = va_arg(ap, int*)) != NULL)
        len += prt_tuple_len(tuple);
    va_end(ap);

    int *out_tuple = (int*)malloc((len+1)*sizeof(int));
    prt_assert(out_tuple != NULL, "malloc failed");
    va_start(ap, first_tuple);
    while(*first_tuple != INT_MAX)
        *out_tuple++ = *first_tuple++;
    while ((tuple = va_arg(ap, int*)) != NULL)
        while(*tuple != INT_MAX)
            *out_tuple++ = *tuple++;
    va_end(ap);

    *out_tuple = INT_MAX;
    return (out_tuple-len);
}


void prt_tuple_delete(int *tuple)
{
    // Free the tuple.
    free(tuple);
}


int *prt_tuple_copy(int *in_tuple)
{
    int i;
    int len = 0;
    int *out_tuple;
    while (in_tuple[len] != INT_MAX)
        len++;
    out_tuple = (int*)malloc((len+1)*sizeof(int));
    prt_assert(out_tuple != NULL, "malloc failed");
    for (i = 0; i < len; i++)
        out_tuple[i] = in_tuple[i];
    out_tuple[len] = INT_MAX;
    return out_tuple;
}


int prt_tuple_compare(void *tuple_a, void *tuple_b)
{
    int *tupa = (int*)tuple_a;
    int *tupb = (int*)tuple_b;
    while (*tupa != INT_MAX && *tupb != INT_MAX) {
        if (*tupa < *tupb) return -1;
        else if (*tupa > *tupb) return 1;
        tupa++;
        tupb++;
    }
    if (*tupa == INT_MAX && *tupb == INT_MAX) return 0;
    else if (*tupa == INT_MAX) return -1;
    else if (*tupb == INT_MAX) return 1;
}


int prt_tuple_equal(void *tuple_a, void *tuple_b)
{
    return (prt_tuple_compare(tuple_a, tuple_b) == 0);
}


void prt_tuple_print(int *tuple)
{
    while (*tuple != INT_MAX)
        printf("%3d", *tuple++);
}


unsigned int prt_tuple_hash(void *tuple)
{
    int len = 0;
    int *tup = (int*)tuple;
    while (tup[len] != INT_MAX)
        len++;
    return fnv_hash(tuple, len*sizeof(int));
}


static unsigned int fnv_hash(void *key, int len)
{
    unsigned char *p = key;
    unsigned h = 2166136261;
    int i;
    for (i = 0; i < len; i++)
        h = (h * 16777619) ^ p[i];
    return h;
}