| /* |
| Copyright 2002-2003 John Plevyak, All Rights Reserved |
| */ |
| |
| #define INITIAL_SET_SIZE_INDEX 2 |
| |
| #define INITIAL_VEC_SHIFT 3 |
| #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT) |
| #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT) |
| #define INTEGRAL_VEC_SIZE 3 |
| #define INTEGRAL_STACK_SIZE 8 |
| #define TRICK_VEC_SIZE (INITIAL_VEC_SIZE - INTEGRAL_VEC_ELEMENTS) |
| |
| #define SET_MAX_SEQUENTIAL 5 |
| |
| #define IS_BIT_SET(_v, _s) ((_v)[(_s) / 8] & 1 << ((_s) % 8)) |
| #define SET_BIT(_v, _s) (_v)[(_s) / 8] |= (1 << ((_s) %8)) |
| |
| typedef struct AbstractVec { |
| uint n; |
| uint i; /* size index for use with sets */ |
| void **v; |
| void *e[INTEGRAL_VEC_SIZE]; |
| } AbstractVec; |
| #define Vec(_x) struct { \ |
| uint n; \ |
| uint i; \ |
| _x *v; \ |
| _x e[INTEGRAL_VEC_SIZE]; \ |
| } |
| |
| typedef struct AbstractStack { |
| void **start; |
| void **end; |
| void **cur; |
| void *initial[INTEGRAL_STACK_SIZE]; |
| } AbstractStack; |
| #define Stack(_x) struct { \ |
| _x *start; _x *end; _x *cur; _x initial[INTEGRAL_STACK_SIZE]; \ |
| } |
| |
| #define vec_move(_a, _b) do { \ |
| (_a)->n = (_b)->n; \ |
| if ((_b)->v == (_b)->e) { \ |
| memcpy(&(_a)->e[0], &(_b)->e[0], sizeof((_a)->e)); \ |
| (_a)->v = (_a)->e; \ |
| } else (_a)->v = (_b)->v; \ |
| vec_clear(_b); \ |
| } while (0) |
| |
| struct hash_fns_t; |
| typedef uint32 (*hash_fn_t)(void *, struct hash_fns_t*); |
| typedef int (*cmp_fn_t)(void *, void *, struct hash_fns_t*); |
| typedef struct hash_fns_t { |
| hash_fn_t hash_fn; |
| cmp_fn_t cmp_fn; |
| void *data[2]; |
| } hash_fns_t; |
| |
| #define vec_add(_v, _i) do { \ |
| if (!(_v)->v) { \ |
| ((_v)->v = (_v)->e)[(_v)->n++] = (_i); \ |
| break; \ |
| } else if ((_v)->v == ((_v)->e)) { \ |
| if (((_v)->n < INTEGRAL_VEC_SIZE)) { \ |
| (_v)->v[(_v)->n++] = (_i); \ |
| break; \ |
| } \ |
| } else if ((_v)->n & (INITIAL_VEC_SIZE - 1)) { \ |
| (_v)->v[(_v)->n++] = (_i); \ |
| break; \ |
| } \ |
| vec_add_internal((_v), _i); \ |
| } while (0) |
| void vec_add_internal(void *v, void *elem); |
| int vec_eq(void *v, void *vv); |
| int set_add(void *v, void *t); |
| int set_union(void *v, void *vv); |
| void *set_add_fn(void *v, void *t, hash_fns_t *fns); |
| void set_union_fn(void *v, void *vv, hash_fns_t *fns); |
| void set_to_vec(void *av); |
| #define vec_clear(_v) do { (_v)->n = 0; (_v)->v = 0; } while(0) |
| #define vec_free(_v) do { \ |
| if ((_v)->v && (_v)->v != (_v)->e) FREE((_v)->v); vec_clear(_v); } while(0) |
| |
| #define stack_clear(_s) do { \ |
| (_s)->start = (_s)->cur = (_s)->end = (_s)->initial; \ |
| (_s)->end += INTEGRAL_STACK_SIZE; \ |
| } \ |
| while(0) |
| #define stack_free(_s) do { \ |
| if ((_s)->start != (_s)->initial) FREE((_s)->start); \ |
| stack_clear(_s); \ |
| } while(0) |
| #define stack_head(_s) ((_s)->cur[-1]) |
| #define is_stack_empty(_s) ((_s)->cur == (_s)->start) |
| #define stack_empty(_s) ((_s)->cur = (_s)->start) |
| #define stack_depth(_s) ((_s)->cur - (_s)->start) |
| #define stack_pop(_s) (*--((_s)->cur)) |
| #define stack_push(_s, _x) ((_s)->cur == (_s)->end ? \ |
| stack_push_internal((AbstractStack*)((_s)), (void*)_x) : \ |
| (void*)(*((_s)->cur)++ = (_x))) |
| void * stack_push_internal(AbstractStack*, void*); |
| |
| int buf_read(char *pathname, char **buf, int *len); |
| char *sbuf_read(char *pathname); |
| |
| #define STREQ(_x,_n,_s) \ |
| ((_n == sizeof(_s)-1) && !strncasecmp(_x,_s,sizeof(_s)-1)) |
| |
| void d_fail(char *str, ...); |
| char *dup_str(char *str, char *end); |
| uint strhashl(char *s, int len); |
| void d_free(void *); |
| |
| void int_list_diff(int *a, int *b, int *c); |
| void int_list_intersect(int *a, int *b, int *c); |
| int *int_list_dup(int *aa); |
| |
| char *escape_string(char *s); |
| |
| extern uint prime2[]; |
| extern int verbose_level; |
| extern int debug_level; |
| extern int test_level; |
| |
| |