mirror of https://github.com/grpc/grpc.git
Craig Tiller
8 years ago
parent
36b3135929
commit
ddea41e666
13 changed files with 57 additions and 3378 deletions
@ -1,7 +0,0 @@ |
||||
perfect |
||||
*.o |
||||
phash.h |
||||
phash.c |
||||
compile.txt |
||||
hash.txt |
||||
|
||||
@ -1,4 +0,0 @@ |
||||
#!/bin/bash |
||||
set -e |
||||
cd $(dirname $0) |
||||
gcc -o perfect perfect.c recycle.c lookupa.c perfhex.c 2> compile.txt |
||||
@ -1,240 +0,0 @@ |
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
lookupa.c, by Bob Jenkins, December 1996. Same as lookup2.c |
||||
Use this code however you wish. Public Domain. No warranty. |
||||
Source is http://burtleburtle.net/bob/c/lookupa.c
|
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef STANDARD |
||||
#include "standard.h" |
||||
#endif |
||||
#ifndef LOOKUPA |
||||
#include "lookupa.h" |
||||
#endif |
||||
|
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
mix -- mix 3 32-bit values reversibly. |
||||
For every delta with one or two bit set, and the deltas of all three |
||||
high bits or all three low bits, whether the original value of a,b,c |
||||
is almost all zero or is uniformly distributed, |
||||
* If mix() is run forward or backward, at least 32 bits in a,b,c |
||||
have at least 1/4 probability of changing. |
||||
* If mix() is run forward, every bit of c will change between 1/3 and |
||||
2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.) |
||||
mix() was built out of 36 single-cycle latency instructions in a
|
||||
structure that could supported 2x parallelism, like so: |
||||
a -= b;
|
||||
a -= c; x = (c>>13); |
||||
b -= c; a ^= x; |
||||
b -= a; x = (a<<8); |
||||
c -= a; b ^= x; |
||||
c -= b; x = (b>>13); |
||||
... |
||||
Unfortunately, superscalar Pentiums and Sparcs can't take advantage
|
||||
of that parallelism. They've also turned some of those single-cycle |
||||
latency instructions into multi-cycle latency instructions. Still, |
||||
this is the fastest good hash I could find. There were about 2^^68 |
||||
to choose from. I only looked at a billion or so. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
#define mix(a,b,c) \ |
||||
{ \
|
||||
a -= b; a -= c; a ^= (c>>13); \
|
||||
b -= c; b -= a; b ^= (a<<8); \
|
||||
c -= a; c -= b; c ^= (b>>13); \
|
||||
a -= b; a -= c; a ^= (c>>12); \
|
||||
b -= c; b -= a; b ^= (a<<16); \
|
||||
c -= a; c -= b; c ^= (b>>5); \
|
||||
a -= b; a -= c; a ^= (c>>3); \
|
||||
b -= c; b -= a; b ^= (a<<10); \
|
||||
c -= a; c -= b; c ^= (b>>15); \
|
||||
} |
||||
|
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
lookup() -- hash a variable-length key into a 32-bit value |
||||
k : the key (the unaligned variable-length array of bytes) |
||||
len : the length of the key, counting by bytes |
||||
level : can be any 4-byte value |
||||
Returns a 32-bit value. Every bit of the key affects every bit of |
||||
the return value. Every 1-bit and 2-bit delta achieves avalanche. |
||||
About 6len+35 instructions. |
||||
|
||||
The best hash table sizes are powers of 2. There is no need to do |
||||
mod a prime (mod is sooo slow!). If you need less than 32 bits, |
||||
use a bitmask. For example, if you need only 10 bits, do |
||||
h = (h & hashmask(10)); |
||||
In which case, the hash table should have hashsize(10) elements. |
||||
|
||||
If you are hashing n strings (ub1 **)k, do it like this: |
||||
for (i=0, h=0; i<n; ++i) h = lookup( k[i], len[i], h); |
||||
|
||||
By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this |
||||
code any way you wish, private, educational, or commercial. |
||||
|
||||
See http://burtleburtle.net/bob/hash/evahash.html
|
||||
Use for hash table lookup, or anything where one collision in 2^32 is |
||||
acceptable. Do NOT use for cryptographic purposes. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
ub4 lookup( k, length, level) |
||||
register ub1 *k; /* the key */ |
||||
register ub4 length; /* the length of the key */ |
||||
register ub4 level; /* the previous hash, or an arbitrary value */ |
||||
{ |
||||
register ub4 a,b,c,len; |
||||
|
||||
/* Set up the internal state */ |
||||
len = length; |
||||
a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */ |
||||
c = level; /* the previous hash value */ |
||||
|
||||
/*---------------------------------------- handle most of the key */ |
||||
while (len >= 12) |
||||
{ |
||||
a += (k[0] +((ub4)k[1]<<8) +((ub4)k[2]<<16) +((ub4)k[3]<<24)); |
||||
b += (k[4] +((ub4)k[5]<<8) +((ub4)k[6]<<16) +((ub4)k[7]<<24)); |
||||
c += (k[8] +((ub4)k[9]<<8) +((ub4)k[10]<<16)+((ub4)k[11]<<24)); |
||||
mix(a,b,c); |
||||
k += 12; len -= 12; |
||||
} |
||||
|
||||
/*------------------------------------- handle the last 11 bytes */ |
||||
c += length; |
||||
switch(len) /* all the case statements fall through */ |
||||
{ |
||||
case 11: c+=((ub4)k[10]<<24); |
||||
case 10: c+=((ub4)k[9]<<16); |
||||
case 9 : c+=((ub4)k[8]<<8); |
||||
/* the first byte of c is reserved for the length */ |
||||
case 8 : b+=((ub4)k[7]<<24); |
||||
case 7 : b+=((ub4)k[6]<<16); |
||||
case 6 : b+=((ub4)k[5]<<8); |
||||
case 5 : b+=k[4]; |
||||
case 4 : a+=((ub4)k[3]<<24); |
||||
case 3 : a+=((ub4)k[2]<<16); |
||||
case 2 : a+=((ub4)k[1]<<8); |
||||
case 1 : a+=k[0]; |
||||
/* case 0: nothing left to add */ |
||||
} |
||||
mix(a,b,c); |
||||
/*-------------------------------------------- report the result */ |
||||
return c; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
mixc -- mixc 8 4-bit values as quickly and thoroughly as possible. |
||||
Repeating mix() three times achieves avalanche. |
||||
Repeating mix() four times eliminates all funnels and all |
||||
characteristics stronger than 2^{-11}. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
#define mixc(a,b,c,d,e,f,g,h) \ |
||||
{ \
|
||||
a^=b<<11; d+=a; b+=c; \
|
||||
b^=c>>2; e+=b; c+=d; \
|
||||
c^=d<<8; f+=c; d+=e; \
|
||||
d^=e>>16; g+=d; e+=f; \
|
||||
e^=f<<10; h+=e; f+=g; \
|
||||
f^=g>>4; a+=f; g+=h; \
|
||||
g^=h<<8; b+=g; h+=a; \
|
||||
h^=a>>9; c+=h; a+=b; \
|
||||
} |
||||
|
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
checksum() -- hash a variable-length key into a 256-bit value |
||||
k : the key (the unaligned variable-length array of bytes) |
||||
len : the length of the key, counting by bytes |
||||
state : an array of CHECKSTATE 4-byte values (256 bits) |
||||
The state is the checksum. Every bit of the key affects every bit of |
||||
the state. There are no funnels. About 112+6.875len instructions. |
||||
|
||||
If you are hashing n strings (ub1 **)k, do it like this: |
||||
for (i=0; i<8; ++i) state[i] = 0x9e3779b9; |
||||
for (i=0, h=0; i<n; ++i) checksum( k[i], len[i], state); |
||||
|
||||
See http://burtleburtle.net/bob/hash/evahash.html
|
||||
Use to detect changes between revisions of documents, assuming nobody |
||||
is trying to cause collisions. Do NOT use for cryptography. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
void checksum( k, len, state) |
||||
register ub1 *k; |
||||
register ub4 len; |
||||
register ub4 *state; |
||||
{ |
||||
register ub4 a,b,c,d,e,f,g,h,length; |
||||
|
||||
/* Use the length and level; add in the golden ratio. */ |
||||
length = len; |
||||
a=state[0]; b=state[1]; c=state[2]; d=state[3]; |
||||
e=state[4]; f=state[5]; g=state[6]; h=state[7]; |
||||
|
||||
/*---------------------------------------- handle most of the key */ |
||||
while (len >= 32) |
||||
{ |
||||
a += (k[0] +(k[1]<<8) +(k[2]<<16) +(k[3]<<24)); |
||||
b += (k[4] +(k[5]<<8) +(k[6]<<16) +(k[7]<<24)); |
||||
c += (k[8] +(k[9]<<8) +(k[10]<<16)+(k[11]<<24)); |
||||
d += (k[12]+(k[13]<<8)+(k[14]<<16)+(k[15]<<24)); |
||||
e += (k[16]+(k[17]<<8)+(k[18]<<16)+(k[19]<<24)); |
||||
f += (k[20]+(k[21]<<8)+(k[22]<<16)+(k[23]<<24)); |
||||
g += (k[24]+(k[25]<<8)+(k[26]<<16)+(k[27]<<24)); |
||||
h += (k[28]+(k[29]<<8)+(k[30]<<16)+(k[31]<<24)); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
k += 32; len -= 32; |
||||
} |
||||
|
||||
/*------------------------------------- handle the last 31 bytes */ |
||||
h += length; |
||||
switch(len) |
||||
{ |
||||
case 31: h+=(k[30]<<24); |
||||
case 30: h+=(k[29]<<16); |
||||
case 29: h+=(k[28]<<8); |
||||
case 28: g+=(k[27]<<24); |
||||
case 27: g+=(k[26]<<16); |
||||
case 26: g+=(k[25]<<8); |
||||
case 25: g+=k[24]; |
||||
case 24: f+=(k[23]<<24); |
||||
case 23: f+=(k[22]<<16); |
||||
case 22: f+=(k[21]<<8); |
||||
case 21: f+=k[20]; |
||||
case 20: e+=(k[19]<<24); |
||||
case 19: e+=(k[18]<<16); |
||||
case 18: e+=(k[17]<<8); |
||||
case 17: e+=k[16]; |
||||
case 16: d+=(k[15]<<24); |
||||
case 15: d+=(k[14]<<16); |
||||
case 14: d+=(k[13]<<8); |
||||
case 13: d+=k[12]; |
||||
case 12: c+=(k[11]<<24); |
||||
case 11: c+=(k[10]<<16); |
||||
case 10: c+=(k[9]<<8); |
||||
case 9 : c+=k[8]; |
||||
case 8 : b+=(k[7]<<24); |
||||
case 7 : b+=(k[6]<<16); |
||||
case 6 : b+=(k[5]<<8); |
||||
case 5 : b+=k[4]; |
||||
case 4 : a+=(k[3]<<24); |
||||
case 3 : a+=(k[2]<<16); |
||||
case 2 : a+=(k[1]<<8); |
||||
case 1 : a+=k[0]; |
||||
} |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
mixc(a,b,c,d,e,f,g,h); |
||||
|
||||
/*-------------------------------------------- report the result */ |
||||
state[0]=a; state[1]=b; state[2]=c; state[3]=d; |
||||
state[4]=e; state[5]=f; state[6]=g; state[7]=h; |
||||
} |
||||
@ -1,24 +0,0 @@ |
||||
/*
|
||||
------------------------------------------------------------------------------ |
||||
By Bob Jenkins, September 1996. |
||||
lookupa.h, a hash function for table lookup, same function as lookup.c. |
||||
Use this code in any way you wish. Public Domain. It has no warranty. |
||||
Source is http://burtleburtle.net/bob/c/lookupa.h
|
||||
------------------------------------------------------------------------------ |
||||
*/ |
||||
|
||||
#ifndef STANDARD |
||||
#include "standard.h" |
||||
#endif |
||||
|
||||
#ifndef LOOKUPA |
||||
#define LOOKUPA |
||||
|
||||
#define CHECKSTATE 8 |
||||
#define hashsize(n) ((ub4)1<<(n)) |
||||
#define hashmask(n) (hashsize(n)-1) |
||||
|
||||
ub4 lookup(/*_ ub1 *k, ub4 length, ub4 level _*/); |
||||
void checksum(/*_ ub1 *k, ub4 length, ub4 *state _*/); |
||||
|
||||
#endif /* LOOKUPA */ |
||||
File diff suppressed because it is too large
Load Diff
@ -1,132 +0,0 @@ |
||||
/*
|
||||
------------------------------------------------------------------------------ |
||||
perfect.h: code to generate code for a hash for perfect hashing. |
||||
(c) Bob Jenkins, September 1996 |
||||
You may use this code in any way you wish, and it is free. No warranty. |
||||
I hereby place this in the public domain. |
||||
Source is http://burtleburtle.net/bob/c/perfect.h
|
||||
------------------------------------------------------------------------------ |
||||
*/ |
||||
|
||||
#ifndef STANDARD |
||||
#include "standard.h" |
||||
#endif |
||||
|
||||
#ifndef PERFECT |
||||
#define PERFECT |
||||
|
||||
#define MAXKEYLEN 30 /* maximum length of a key */ |
||||
#define USE_SCRAMBLE 4096 /* use scramble if blen >= USE_SCRAMBLE */ |
||||
#define SCRAMBLE_LEN ((ub4)1<<16) /* length of *scramble* */ |
||||
#define RETRY_INITKEY 2048 /* number of times to try to find distinct (a,b) */ |
||||
#define RETRY_PERFECT 1 /* number of times to try to make a perfect hash */ |
||||
#define RETRY_HEX 200 /* RETRY_PERFECT when hex keys given */ |
||||
|
||||
/* the generated code for the final hash, assumes initial hash is done */ |
||||
struct gencode |
||||
{ |
||||
char **line; /* array of text lines, 80 bytes apiece */ |
||||
/*
|
||||
* The code placed here must declare "ub4 rsl"
|
||||
* and assign it the value of the perfect hash using the function inputs. |
||||
* Later code will be tacked on which returns rsl or manipulates it according |
||||
* to the user directives. |
||||
* |
||||
* This code is at the top of the routine; it may and must declare any |
||||
* local variables it needs. |
||||
* |
||||
* Each way of filling in **line should be given a comment that is a unique |
||||
* tag. A testcase named with that tag should also be found which tests |
||||
* the generated code. |
||||
*/ |
||||
ub4 len; /* number of lines available for final hash */ |
||||
ub4 used; /* number of lines used by final hash */ |
||||
|
||||
ub4 lowbit; /* for HEX, lowest interesting bit */ |
||||
ub4 highbit; /* for HEX, highest interesting bit */ |
||||
ub4 diffbits; /* bits which differ for some key */ |
||||
ub4 i,j,k,l,m,n,o; /* state machine used in hexn() */ |
||||
}; |
||||
typedef struct gencode gencode; |
||||
|
||||
/* user directives: perfect hash? minimal perfect hash? input is an int? */ |
||||
struct hashform |
||||
{ |
||||
enum { |
||||
NORMAL_HM, /* key is a string */ |
||||
INLINE_HM, /* user will do initial hash, we must choose salt for them */ |
||||
HEX_HM, /* key to be hashed is a hexidecimal 4-byte integer */ |
||||
DECIMAL_HM, /* key to be hashed is a decimal 4-byte integer */ |
||||
AB_HM, /* key to be hashed is "A B", where A and B are (A,B) in hex */ |
||||
ABDEC_HM /* like AB_HM, but in decimal */ |
||||
} mode; |
||||
enum { |
||||
STRING_HT, /* key is a string */ |
||||
INT_HT, /* key is an integer */ |
||||
AB_HT /* dunno what key is, but input is distinct (A,B) pair */ |
||||
} hashtype; |
||||
enum { |
||||
NORMAL_HP, /* just find a perfect hash */ |
||||
MINIMAL_HP /* find a minimal perfect hash */ |
||||
} perfect; |
||||
enum { |
||||
FAST_HS, /* fast mode */ |
||||
SLOW_HS /* slow mode */ |
||||
} speed; |
||||
}; |
||||
typedef struct hashform hashform; |
||||
|
||||
/* representation of a key */ |
||||
struct key |
||||
{ |
||||
ub1 *name_k; /* the actual key */ |
||||
ub4 len_k; /* the length of the actual key */ |
||||
ub4 hash_k; /* the initial hash value for this key */ |
||||
struct key *next_k; /* next key */ |
||||
/* beyond this point is mapping-dependent */ |
||||
ub4 a_k; /* a, of the key maps to (a,b) */ |
||||
ub4 b_k; /* b, of the key maps to (a,b) */ |
||||
struct key *nextb_k; /* next key with this b */ |
||||
}; |
||||
typedef struct key key; |
||||
|
||||
/* things indexed by b of original (a,b) pair */ |
||||
struct bstuff |
||||
{ |
||||
ub2 val_b; /* hash=a^tabb[b].val_b */ |
||||
key *list_b; /* tabb[i].list_b is list of keys with b==i */ |
||||
ub4 listlen_b; /* length of list_b */ |
||||
ub4 water_b; /* high watermark of who has visited this map node */ |
||||
}; |
||||
typedef struct bstuff bstuff; |
||||
|
||||
/* things indexed by final hash value */ |
||||
struct hstuff |
||||
{ |
||||
key *key_h; /* tabh[i].key_h is the key with a hash of i */ |
||||
}; |
||||
typedef struct hstuff hstuff; |
||||
|
||||
/* things indexed by queue position */ |
||||
struct qstuff |
||||
{ |
||||
bstuff *b_q; /* b that currently occupies this hash */ |
||||
ub4 parent_q; /* queue position of parent that could use this hash */ |
||||
ub2 newval_q; /* what to change parent tab[b] to to use this hash */ |
||||
ub2 oldval_q; /* original value of tab[b] */ |
||||
}; |
||||
typedef struct qstuff qstuff; |
||||
|
||||
/* return ceiling(log based 2 of x) */ |
||||
ub4 mylog2(/*_ ub4 x _*/); |
||||
|
||||
/* Given the keys, scramble[], and hash mode, find the perfect hash */ |
||||
void findhash(/*_ bstuff **tabb, ub4 *alen, ub4 *blen, ub4 *salt,
|
||||
gencode *final, ub4 *scramble, ub4 smax, key *keys, ub4 nkeys,
|
||||
hashform *form _*/); |
||||
|
||||
/* private, but in a different file because it's excessively verbose */ |
||||
int inithex(/*_ key *keys, ub4 *alen, ub4 *blen, ub4 smax, ub4 nkeys,
|
||||
ub4 salt, gencode *final, gencode *form _*/); |
||||
|
||||
#endif /* PERFECT */ |
||||
File diff suppressed because it is too large
Load Diff
@ -1,87 +0,0 @@ |
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
By Bob Jenkins, September 1996. recycle.c |
||||
You may use this code in any way you wish, and it is free. No warranty. |
||||
|
||||
This manages memory for commonly-allocated structures. |
||||
It allocates RESTART to REMAX items at a time. |
||||
Timings have shown that, if malloc is used for every new structure, |
||||
malloc will consume about 90% of the time in a program. This |
||||
module cuts down the number of mallocs by an order of magnitude. |
||||
This also decreases memory fragmentation, and freeing structures |
||||
only requires freeing the root. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef STANDARD |
||||
# include "standard.h" |
||||
#endif |
||||
#ifndef RECYCLE |
||||
# include "recycle.h" |
||||
#endif |
||||
|
||||
reroot *remkroot(size) |
||||
size_t size; |
||||
{ |
||||
reroot *r = (reroot *)remalloc(sizeof(reroot), "recycle.c, root"); |
||||
r->list = (recycle *)0; |
||||
r->trash = (recycle *)0; |
||||
r->size = align(size); |
||||
r->logsize = RESTART; |
||||
r->numleft = 0; |
||||
return r; |
||||
} |
||||
|
||||
void refree(r) |
||||
struct reroot *r; |
||||
{ |
||||
recycle *temp; |
||||
if (temp = r->list) while (r->list) |
||||
{ |
||||
temp = r->list->next; |
||||
free((char *)r->list); |
||||
r->list = temp; |
||||
} |
||||
free((char *)r); |
||||
return; |
||||
} |
||||
|
||||
/* to be called from the macro renew only */ |
||||
char *renewx(r) |
||||
struct reroot *r; |
||||
{ |
||||
recycle *temp; |
||||
if (r->trash) |
||||
{ /* pull a node off the trash heap */ |
||||
temp = r->trash; |
||||
r->trash = temp->next; |
||||
(void)memset((void *)temp, 0, r->size); |
||||
} |
||||
else |
||||
{ /* allocate a new block of nodes */ |
||||
r->numleft = r->size*((ub4)1<<r->logsize); |
||||
if (r->numleft < REMAX) ++r->logsize; |
||||
temp = (recycle *)remalloc(sizeof(recycle) + r->numleft,
|
||||
"recycle.c, data"); |
||||
temp->next = r->list; |
||||
r->list = temp; |
||||
r->numleft-=r->size; |
||||
temp = (recycle *)((char *)(r->list+1)+r->numleft); |
||||
} |
||||
return (char *)temp; |
||||
} |
||||
|
||||
char *remalloc(len, purpose) |
||||
size_t len; |
||||
char *purpose; |
||||
{ |
||||
char *x = (char *)malloc(len); |
||||
if (!x) |
||||
{ |
||||
fprintf(stderr, "malloc of %d failed for %s\n",
|
||||
len, purpose); |
||||
exit(SUCCESS); |
||||
} |
||||
return x; |
||||
} |
||||
|
||||
@ -1,65 +0,0 @@ |
||||
/*
|
||||
-------------------------------------------------------------------- |
||||
By Bob Jenkins, September 1996. recycle.h |
||||
You may use this code in any way you wish, and it is free. No warranty. |
||||
|
||||
This manages memory for commonly-allocated structures. |
||||
It allocates RESTART to REMAX items at a time. |
||||
Timings have shown that, if malloc is used for every new structure, |
||||
malloc will consume about 90% of the time in a program. This |
||||
module cuts down the number of mallocs by an order of magnitude. |
||||
This also decreases memory fragmentation, and freeing all structures |
||||
only requires freeing the root. |
||||
-------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#ifndef STANDARD |
||||
#include "standard.h" |
||||
#endif |
||||
|
||||
#ifndef RECYCLE |
||||
#define RECYCLE |
||||
|
||||
#define RESTART 0 |
||||
#define REMAX 32000 |
||||
|
||||
struct recycle |
||||
{ |
||||
struct recycle *next; |
||||
}; |
||||
typedef struct recycle recycle; |
||||
|
||||
struct reroot |
||||
{ |
||||
struct recycle *list; /* list of malloced blocks */ |
||||
struct recycle *trash; /* list of deleted items */ |
||||
size_t size; /* size of an item */ |
||||
size_t logsize; /* log_2 of number of items in a block */ |
||||
word numleft; /* number of bytes left in this block */ |
||||
}; |
||||
typedef struct reroot reroot; |
||||
|
||||
/* make a new recycling root */ |
||||
reroot *remkroot(/*_ size_t mysize _*/); |
||||
|
||||
/* free a recycling root and all the items it has made */ |
||||
void refree(/*_ struct reroot *r _*/); |
||||
|
||||
/* get a new (cleared) item from the root */ |
||||
#define renew(r) ((r)->numleft ? \ |
||||
(((char *)((r)->list+1))+((r)->numleft-=(r)->size)) : renewx(r)) |
||||
|
||||
char *renewx(/*_ struct reroot *r _*/); |
||||
|
||||
/* delete an item; let the root recycle it */ |
||||
/* void redel(/o_ struct reroot *r, struct recycle *item _o/); */ |
||||
#define redel(root,item) { \ |
||||
((recycle *)item)->next=(root)->trash; \
|
||||
(root)->trash=(recycle *)(item); \
|
||||
} |
||||
|
||||
/* malloc, but complain to stderr and exit program if no joy */ |
||||
/* use plain free() to free memory allocated by remalloc() */ |
||||
char *remalloc(/*_ size_t len, char *purpose _*/); |
||||
|
||||
#endif /* RECYCLE */ |
||||
@ -1,6 +0,0 @@ |
||||
#!/bin/bash |
||||
set -e |
||||
cd $(dirname $0) |
||||
fn=$1 |
||||
shift |
||||
./perfect $* < $fn |
||||
@ -1,57 +0,0 @@ |
||||
/*
|
||||
------------------------------------------------------------------------------ |
||||
Standard definitions and types, Bob Jenkins |
||||
------------------------------------------------------------------------------ |
||||
*/ |
||||
#ifndef STANDARD |
||||
# define STANDARD |
||||
# ifndef STDIO |
||||
# include <stdio.h> |
||||
# define STDIO |
||||
# endif |
||||
# ifndef STDDEF |
||||
# include <stddef.h> |
||||
# define STDDEF |
||||
# endif |
||||
typedef unsigned long long ub8; |
||||
#define UB8MAXVAL 0xffffffffffffffffLL |
||||
#define UB8BITS 64 |
||||
typedef signed long long sb8; |
||||
#define SB8MAXVAL 0x7fffffffffffffffLL |
||||
typedef unsigned long int ub4; /* unsigned 4-byte quantities */ |
||||
#define UB4MAXVAL 0xffffffff |
||||
typedef signed long int sb4; |
||||
#define UB4BITS 32 |
||||
#define SB4MAXVAL 0x7fffffff |
||||
typedef unsigned short int ub2; |
||||
#define UB2MAXVAL 0xffff |
||||
#define UB2BITS 16 |
||||
typedef signed short int sb2; |
||||
#define SB2MAXVAL 0x7fff |
||||
typedef unsigned char ub1; |
||||
#define UB1MAXVAL 0xff |
||||
#define UB1BITS 8 |
||||
typedef signed char sb1; /* signed 1-byte quantities */ |
||||
#define SB1MAXVAL 0x7f |
||||
typedef int word; /* fastest type available */ |
||||
|
||||
#define bis(target,mask) ((target) |= (mask)) |
||||
#define bic(target,mask) ((target) &= ~(mask)) |
||||
#define bit(target,mask) ((target) & (mask)) |
||||
#ifndef min |
||||
# define min(a,b) (((a)<(b)) ? (a) : (b)) |
||||
#endif /* min */ |
||||
#ifndef max |
||||
# define max(a,b) (((a)<(b)) ? (b) : (a)) |
||||
#endif /* max */ |
||||
#ifndef align |
||||
# define align(a) (((ub4)a+(sizeof(void *)-1))&(~(sizeof(void *)-1))) |
||||
#endif /* align */ |
||||
#ifndef abs |
||||
# define abs(a) (((a)>0) ? (a) : -(a)) |
||||
#endif |
||||
#define TRUE 1 |
||||
#define FALSE 0 |
||||
#define SUCCESS 0 /* 1 on VAX */ |
||||
|
||||
#endif /* STANDARD */ |
||||
Loading…
Reference in new issue