MdeModulePkg RegularExpressionDxe: Update Oniguruma to 6.9.0
https://bugzilla.tianocore.org/show_bug.cgi?id=1200 Update Oniguruma to the latest version v6.9.0. Oniguruma https://github.com/kkos/oniguruma Verify VS2017, GCC5 build. Verify RegularExpressionProtocol GetInfo() and Match() function. Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Dongao Guo <dongao.guo@intel.com> Reviewed-by: Liming Gao <liming.gao@intel.com> Reviewed-by: Cinnamon Shia <cinnamon.shia@hpe.com>
This commit is contained in:
Dongao Guo
Liming Gao
@@ -109,17 +109,16 @@ new_size(size)
|
||||
|
||||
#if 0
|
||||
for (i=3; i<31; i++) {
|
||||
if ((1<<i) > size) return 1<<i;
|
||||
if ((1<<i) > size) return 1<<i;
|
||||
}
|
||||
return -1;
|
||||
#else
|
||||
int newsize;
|
||||
|
||||
for (i = 0, newsize = MINSIZE;
|
||||
i < (int )(sizeof(primes)/sizeof(primes[0]));
|
||||
i++, newsize <<= 1)
|
||||
{
|
||||
if (newsize > size) return primes[i];
|
||||
i < (int )(sizeof(primes)/sizeof(primes[0]));
|
||||
i++, newsize <<= 1) {
|
||||
if (newsize > size) return primes[i];
|
||||
}
|
||||
/* Ran out of polynomials */
|
||||
return -1; /* should raise exception */
|
||||
@@ -131,11 +130,13 @@ static int collision = 0;
|
||||
static int init_st = 0;
|
||||
|
||||
static void
|
||||
stat_col()
|
||||
stat_col(void)
|
||||
{
|
||||
FILE *f = fopen("/tmp/col", "w");
|
||||
fprintf(f, "collision: %d\n", collision);
|
||||
fclose(f);
|
||||
FILE *f = fopen("/tmp/col", "w");
|
||||
if (f == 0) return ;
|
||||
|
||||
(void) fprintf(f, "collision: %d\n", collision);
|
||||
(void) fclose(f);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -144,77 +145,82 @@ st_init_table_with_size(type, size)
|
||||
struct st_hash_type *type;
|
||||
int size;
|
||||
{
|
||||
st_table *tbl;
|
||||
st_table *tbl;
|
||||
|
||||
#ifdef HASH_LOG
|
||||
if (init_st == 0) {
|
||||
init_st = 1;
|
||||
atexit(stat_col);
|
||||
}
|
||||
if (init_st == 0) {
|
||||
init_st = 1;
|
||||
atexit(stat_col);
|
||||
}
|
||||
#endif
|
||||
|
||||
size = new_size(size); /* round up to prime number */
|
||||
size = new_size(size); /* round up to prime number */
|
||||
|
||||
tbl = alloc(st_table);
|
||||
CHECK_NULL_RETURN(tbl);
|
||||
tbl->type = type;
|
||||
tbl->num_entries = 0;
|
||||
tbl->num_bins = size;
|
||||
tbl->bins = (st_table_entry **)Calloc(size, sizeof(st_table_entry*));
|
||||
tbl = alloc(st_table);
|
||||
if (tbl == 0) return 0;
|
||||
|
||||
return tbl;
|
||||
tbl->type = type;
|
||||
tbl->num_entries = 0;
|
||||
tbl->num_bins = size;
|
||||
tbl->bins = (st_table_entry **)Calloc(size, sizeof(st_table_entry*));
|
||||
if (tbl->bins == 0) {
|
||||
free(tbl);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return tbl;
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_init_table(type)
|
||||
struct st_hash_type *type;
|
||||
{
|
||||
return st_init_table_with_size(type, 0);
|
||||
return st_init_table_with_size(type, 0);
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_init_numtable(void)
|
||||
{
|
||||
return st_init_table(&type_numhash);
|
||||
return st_init_table(&type_numhash);
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_init_numtable_with_size(size)
|
||||
int size;
|
||||
{
|
||||
return st_init_table_with_size(&type_numhash, size);
|
||||
return st_init_table_with_size(&type_numhash, size);
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_init_strtable(void)
|
||||
{
|
||||
return st_init_table(&type_strhash);
|
||||
return st_init_table(&type_strhash);
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_init_strtable_with_size(size)
|
||||
int size;
|
||||
{
|
||||
return st_init_table_with_size(&type_strhash, size);
|
||||
return st_init_table_with_size(&type_strhash, size);
|
||||
}
|
||||
|
||||
void
|
||||
st_free_table(table)
|
||||
st_table *table;
|
||||
{
|
||||
register st_table_entry *ptr, *next;
|
||||
int i;
|
||||
register st_table_entry *ptr, *next;
|
||||
int i;
|
||||
|
||||
for(i = 0; i < table->num_bins; i++) {
|
||||
ptr = table->bins[i];
|
||||
while (ptr != 0) {
|
||||
for(i = 0; i < table->num_bins; i++) {
|
||||
ptr = table->bins[i];
|
||||
while (ptr != 0) {
|
||||
next = ptr->next;
|
||||
free(ptr);
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
free(table->bins);
|
||||
free(table);
|
||||
}
|
||||
free(table->bins);
|
||||
free(table);
|
||||
}
|
||||
|
||||
#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \
|
||||
@@ -230,190 +236,186 @@ st_free_table(table)
|
||||
bin_pos = hash_val%(table)->num_bins;\
|
||||
ptr = (table)->bins[bin_pos];\
|
||||
if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\
|
||||
COLLISION;\
|
||||
while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
|
||||
ptr = ptr->next;\
|
||||
}\
|
||||
ptr = ptr->next;\
|
||||
COLLISION;\
|
||||
while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
|
||||
ptr = ptr->next;\
|
||||
}\
|
||||
ptr = ptr->next;\
|
||||
}\
|
||||
} while (0)
|
||||
|
||||
int
|
||||
st_lookup(table, key, value)
|
||||
st_table *table;
|
||||
register st_data_t key;
|
||||
st_data_t *value;
|
||||
st_table *table;
|
||||
register st_data_t key;
|
||||
st_data_t *value;
|
||||
{
|
||||
unsigned int hash_val, bin_pos;
|
||||
register st_table_entry *ptr;
|
||||
unsigned int hash_val, bin_pos;
|
||||
register st_table_entry *ptr;
|
||||
|
||||
hash_val = do_hash(key, table);
|
||||
FIND_ENTRY(table, ptr, hash_val, bin_pos);
|
||||
hash_val = do_hash(key, table);
|
||||
FIND_ENTRY(table, ptr, hash_val, bin_pos);
|
||||
|
||||
if (ptr == 0) {
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
if (value != 0) *value = ptr->record;
|
||||
return 1;
|
||||
}
|
||||
if (ptr == 0) {
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
if (value != 0) *value = ptr->record;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
#define ADD_DIRECT(table, key, value, hash_val, bin_pos)\
|
||||
#define ADD_DIRECT(table, key, value, hash_val, bin_pos, ret) \
|
||||
do {\
|
||||
st_table_entry *entry;\
|
||||
if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\
|
||||
rehash(table);\
|
||||
bin_pos = hash_val % table->num_bins;\
|
||||
}\
|
||||
\
|
||||
entry = alloc(st_table_entry);\
|
||||
if (entry == NULL) {\
|
||||
break;\
|
||||
}\
|
||||
\
|
||||
entry->hash = hash_val;\
|
||||
entry->key = key;\
|
||||
entry->record = value;\
|
||||
entry->next = table->bins[bin_pos];\
|
||||
table->bins[bin_pos] = entry;\
|
||||
table->num_entries++;\
|
||||
st_table_entry *entry;\
|
||||
if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\
|
||||
rehash(table);\
|
||||
bin_pos = hash_val % table->num_bins;\
|
||||
}\
|
||||
entry = alloc(st_table_entry);\
|
||||
if (IS_NULL(entry)) return ret;\
|
||||
entry->hash = hash_val;\
|
||||
entry->key = key;\
|
||||
entry->record = value;\
|
||||
entry->next = table->bins[bin_pos];\
|
||||
table->bins[bin_pos] = entry;\
|
||||
table->num_entries++;\
|
||||
} while (0)
|
||||
|
||||
int
|
||||
st_insert(table, key, value)
|
||||
register st_table *table;
|
||||
register st_data_t key;
|
||||
st_data_t value;
|
||||
register st_table *table;
|
||||
register st_data_t key;
|
||||
st_data_t value;
|
||||
{
|
||||
unsigned int hash_val, bin_pos;
|
||||
register st_table_entry *ptr;
|
||||
unsigned int hash_val, bin_pos;
|
||||
register st_table_entry *ptr;
|
||||
|
||||
hash_val = do_hash(key, table);
|
||||
FIND_ENTRY(table, ptr, hash_val, bin_pos);
|
||||
hash_val = do_hash(key, table);
|
||||
FIND_ENTRY(table, ptr, hash_val, bin_pos);
|
||||
|
||||
if (ptr == 0) {
|
||||
ADD_DIRECT(table, key, value, hash_val, bin_pos);
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
ptr->record = value;
|
||||
return 1;
|
||||
}
|
||||
if (ptr == 0) {
|
||||
ADD_DIRECT(table, key, value, hash_val, bin_pos, ONIGERR_MEMORY);
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
ptr->record = value;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
st_add_direct(table, key, value)
|
||||
st_table *table;
|
||||
st_data_t key;
|
||||
st_data_t value;
|
||||
st_table *table;
|
||||
st_data_t key;
|
||||
st_data_t value;
|
||||
{
|
||||
unsigned int hash_val, bin_pos;
|
||||
unsigned int hash_val, bin_pos;
|
||||
|
||||
hash_val = do_hash(key, table);
|
||||
bin_pos = hash_val % table->num_bins;
|
||||
ADD_DIRECT(table, key, value, hash_val, bin_pos);
|
||||
hash_val = do_hash(key, table);
|
||||
bin_pos = hash_val % table->num_bins;
|
||||
ADD_DIRECT(table, key, value, hash_val, bin_pos,);
|
||||
}
|
||||
|
||||
static void
|
||||
rehash(table)
|
||||
register st_table *table;
|
||||
register st_table *table;
|
||||
{
|
||||
register st_table_entry *ptr, *next, **new_bins;
|
||||
int i, old_num_bins = table->num_bins, new_num_bins;
|
||||
unsigned int hash_val;
|
||||
register st_table_entry *ptr, *next, **new_bins;
|
||||
int i, old_num_bins = table->num_bins, new_num_bins;
|
||||
unsigned int hash_val;
|
||||
|
||||
new_num_bins = new_size(old_num_bins+1);
|
||||
new_bins = (st_table_entry**)Calloc(new_num_bins, sizeof(st_table_entry*));
|
||||
if (new_bins == NULL) {
|
||||
return;
|
||||
}
|
||||
new_num_bins = new_size(old_num_bins+1);
|
||||
new_bins = (st_table_entry**)Calloc(new_num_bins, sizeof(st_table_entry*));
|
||||
if (new_bins == 0) {
|
||||
return ;
|
||||
}
|
||||
|
||||
for(i = 0; i < old_num_bins; i++) {
|
||||
ptr = table->bins[i];
|
||||
while (ptr != 0) {
|
||||
for(i = 0; i < old_num_bins; i++) {
|
||||
ptr = table->bins[i];
|
||||
while (ptr != 0) {
|
||||
next = ptr->next;
|
||||
hash_val = ptr->hash % new_num_bins;
|
||||
ptr->next = new_bins[hash_val];
|
||||
new_bins[hash_val] = ptr;
|
||||
ptr = next;
|
||||
}
|
||||
}
|
||||
free(table->bins);
|
||||
table->num_bins = new_num_bins;
|
||||
table->bins = new_bins;
|
||||
}
|
||||
free(table->bins);
|
||||
table->num_bins = new_num_bins;
|
||||
table->bins = new_bins;
|
||||
}
|
||||
|
||||
st_table*
|
||||
st_copy(old_table)
|
||||
st_table *old_table;
|
||||
st_table *old_table;
|
||||
{
|
||||
st_table *new_table;
|
||||
st_table_entry *ptr, *entry;
|
||||
int i, num_bins = old_table->num_bins;
|
||||
st_table *new_table;
|
||||
st_table_entry *ptr, *entry;
|
||||
int i, num_bins = old_table->num_bins;
|
||||
|
||||
new_table = alloc(st_table);
|
||||
if (new_table == 0) {
|
||||
return 0;
|
||||
}
|
||||
new_table = alloc(st_table);
|
||||
if (new_table == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
*new_table = *old_table;
|
||||
new_table->bins = (st_table_entry**)
|
||||
Calloc((unsigned)num_bins, sizeof(st_table_entry*));
|
||||
*new_table = *old_table;
|
||||
new_table->bins = (st_table_entry**)
|
||||
Calloc((unsigned)num_bins, sizeof(st_table_entry*));
|
||||
|
||||
if (new_table->bins == 0) {
|
||||
free(new_table);
|
||||
return 0;
|
||||
}
|
||||
if (new_table->bins == 0) {
|
||||
free(new_table);
|
||||
return 0;
|
||||
}
|
||||
|
||||
for(i = 0; i < num_bins; i++) {
|
||||
new_table->bins[i] = 0;
|
||||
ptr = old_table->bins[i];
|
||||
while (ptr != 0) {
|
||||
for(i = 0; i < num_bins; i++) {
|
||||
new_table->bins[i] = 0;
|
||||
ptr = old_table->bins[i];
|
||||
while (ptr != 0) {
|
||||
entry = alloc(st_table_entry);
|
||||
if (entry == 0) {
|
||||
free(new_table->bins);
|
||||
free(new_table);
|
||||
return 0;
|
||||
free(new_table->bins);
|
||||
free(new_table);
|
||||
return 0;
|
||||
}
|
||||
*entry = *ptr;
|
||||
entry->next = new_table->bins[i];
|
||||
new_table->bins[i] = entry;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
}
|
||||
return new_table;
|
||||
}
|
||||
return new_table;
|
||||
}
|
||||
|
||||
int
|
||||
st_delete(table, key, value)
|
||||
register st_table *table;
|
||||
register st_data_t *key;
|
||||
st_data_t *value;
|
||||
register st_table *table;
|
||||
register st_data_t *key;
|
||||
st_data_t *value;
|
||||
{
|
||||
unsigned int hash_val;
|
||||
st_table_entry *tmp;
|
||||
register st_table_entry *ptr;
|
||||
unsigned int hash_val;
|
||||
st_table_entry *tmp;
|
||||
register st_table_entry *ptr;
|
||||
|
||||
hash_val = do_hash_bin(*key, table);
|
||||
ptr = table->bins[hash_val];
|
||||
hash_val = do_hash_bin(*key, table);
|
||||
ptr = table->bins[hash_val];
|
||||
|
||||
if (ptr == 0) {
|
||||
if (value != 0) *value = 0;
|
||||
return 0;
|
||||
}
|
||||
if (ptr == 0) {
|
||||
if (value != 0) *value = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (EQUAL(table, *key, ptr->key)) {
|
||||
table->bins[hash_val] = ptr->next;
|
||||
table->num_entries--;
|
||||
if (value != 0) *value = ptr->record;
|
||||
*key = ptr->key;
|
||||
free(ptr);
|
||||
return 1;
|
||||
}
|
||||
if (EQUAL(table, *key, ptr->key)) {
|
||||
table->bins[hash_val] = ptr->next;
|
||||
table->num_entries--;
|
||||
if (value != 0) *value = ptr->record;
|
||||
*key = ptr->key;
|
||||
free(ptr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
for(; ptr->next != 0; ptr = ptr->next) {
|
||||
if (EQUAL(table, ptr->next->key, *key)) {
|
||||
for(; ptr->next != 0; ptr = ptr->next) {
|
||||
if (EQUAL(table, ptr->next->key, *key)) {
|
||||
tmp = ptr->next;
|
||||
ptr->next = ptr->next->next;
|
||||
table->num_entries--;
|
||||
@@ -421,41 +423,41 @@ st_delete(table, key, value)
|
||||
*key = tmp->key;
|
||||
free(tmp);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
st_delete_safe(table, key, value, never)
|
||||
register st_table *table;
|
||||
register st_data_t *key;
|
||||
st_data_t *value;
|
||||
st_data_t never;
|
||||
register st_table *table;
|
||||
register st_data_t *key;
|
||||
st_data_t *value;
|
||||
st_data_t never;
|
||||
{
|
||||
unsigned int hash_val;
|
||||
register st_table_entry *ptr;
|
||||
unsigned int hash_val;
|
||||
register st_table_entry *ptr;
|
||||
|
||||
hash_val = do_hash_bin(*key, table);
|
||||
ptr = table->bins[hash_val];
|
||||
hash_val = do_hash_bin(*key, table);
|
||||
ptr = table->bins[hash_val];
|
||||
|
||||
if (ptr == 0) {
|
||||
if (value != 0) *value = 0;
|
||||
return 0;
|
||||
}
|
||||
if (ptr == 0) {
|
||||
if (value != 0) *value = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
for(; ptr != 0; ptr = ptr->next) {
|
||||
if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) {
|
||||
for(; ptr != 0; ptr = ptr->next) {
|
||||
if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) {
|
||||
table->num_entries--;
|
||||
*key = ptr->key;
|
||||
if (value != 0) *value = ptr->record;
|
||||
ptr->key = ptr->record = never;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
@@ -473,114 +475,114 @@ delete_never(key, value, never)
|
||||
|
||||
void
|
||||
st_cleanup_safe(table, never)
|
||||
st_table *table;
|
||||
st_data_t never;
|
||||
st_table *table;
|
||||
st_data_t never;
|
||||
{
|
||||
int num_entries = table->num_entries;
|
||||
int num_entries = table->num_entries;
|
||||
|
||||
st_foreach(table, delete_never, never);
|
||||
table->num_entries = num_entries;
|
||||
st_foreach(table, delete_never, never);
|
||||
table->num_entries = num_entries;
|
||||
}
|
||||
|
||||
int
|
||||
st_foreach(table, func, arg)
|
||||
st_table *table;
|
||||
int (*func)();
|
||||
st_data_t arg;
|
||||
st_table *table;
|
||||
int (*func)();
|
||||
st_data_t arg;
|
||||
{
|
||||
st_table_entry *ptr, *last, *tmp;
|
||||
enum st_retval retval;
|
||||
int i;
|
||||
st_table_entry *ptr, *last, *tmp;
|
||||
enum st_retval retval;
|
||||
int i;
|
||||
|
||||
for(i = 0; i < table->num_bins; i++) {
|
||||
last = 0;
|
||||
for(ptr = table->bins[i]; ptr != 0;) {
|
||||
for(i = 0; i < table->num_bins; i++) {
|
||||
last = 0;
|
||||
for(ptr = table->bins[i]; ptr != 0;) {
|
||||
retval = (*func)(ptr->key, ptr->record, arg);
|
||||
switch (retval) {
|
||||
case ST_CHECK: /* check if hash is modified during iteration */
|
||||
tmp = 0;
|
||||
if (i < table->num_bins) {
|
||||
for (tmp = table->bins[i]; tmp; tmp=tmp->next) {
|
||||
if (tmp == ptr) break;
|
||||
}
|
||||
}
|
||||
if (!tmp) {
|
||||
/* call func with error notice */
|
||||
return 1;
|
||||
}
|
||||
/* fall through */
|
||||
tmp = 0;
|
||||
if (i < table->num_bins) {
|
||||
for (tmp = table->bins[i]; tmp; tmp=tmp->next) {
|
||||
if (tmp == ptr) break;
|
||||
}
|
||||
}
|
||||
if (!tmp) {
|
||||
/* call func with error notice */
|
||||
return 1;
|
||||
}
|
||||
/* fall through */
|
||||
case ST_CONTINUE:
|
||||
last = ptr;
|
||||
ptr = ptr->next;
|
||||
break;
|
||||
last = ptr;
|
||||
ptr = ptr->next;
|
||||
break;
|
||||
case ST_STOP:
|
||||
return 0;
|
||||
return 0;
|
||||
case ST_DELETE:
|
||||
tmp = ptr;
|
||||
if (last == 0) {
|
||||
table->bins[i] = ptr->next;
|
||||
}
|
||||
else {
|
||||
last->next = ptr->next;
|
||||
}
|
||||
ptr = ptr->next;
|
||||
free(tmp);
|
||||
table->num_entries--;
|
||||
tmp = ptr;
|
||||
if (last == 0) {
|
||||
table->bins[i] = ptr->next;
|
||||
}
|
||||
else {
|
||||
last->next = ptr->next;
|
||||
}
|
||||
ptr = ptr->next;
|
||||
free(tmp);
|
||||
table->num_entries--;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
strhash(string)
|
||||
register const char *string;
|
||||
register const char *string;
|
||||
{
|
||||
register int c;
|
||||
register int c;
|
||||
|
||||
#ifdef HASH_ELFHASH
|
||||
register unsigned int h = 0, g;
|
||||
register unsigned int h = 0, g;
|
||||
|
||||
while ((c = *string++) != '\0') {
|
||||
h = ( h << 4 ) + c;
|
||||
if ( g = h & 0xF0000000 )
|
||||
while ((c = *string++) != '\0') {
|
||||
h = ( h << 4 ) + c;
|
||||
if ( g = h & 0xF0000000 )
|
||||
h ^= g >> 24;
|
||||
h &= ~g;
|
||||
}
|
||||
return h;
|
||||
h &= ~g;
|
||||
}
|
||||
return h;
|
||||
#elif HASH_PERL
|
||||
register int val = 0;
|
||||
register int val = 0;
|
||||
|
||||
while ((c = *string++) != '\0') {
|
||||
val += c;
|
||||
val += (val << 10);
|
||||
val ^= (val >> 6);
|
||||
}
|
||||
val += (val << 3);
|
||||
val ^= (val >> 11);
|
||||
while ((c = *string++) != '\0') {
|
||||
val += c;
|
||||
val += (val << 10);
|
||||
val ^= (val >> 6);
|
||||
}
|
||||
val += (val << 3);
|
||||
val ^= (val >> 11);
|
||||
|
||||
return val + (val << 15);
|
||||
return val + (val << 15);
|
||||
#else
|
||||
register int val = 0;
|
||||
register int val = 0;
|
||||
|
||||
while ((c = *string++) != '\0') {
|
||||
val = val*997 + c;
|
||||
}
|
||||
while ((c = *string++) != '\0') {
|
||||
val = val*997 + c;
|
||||
}
|
||||
|
||||
return val + (val>>5);
|
||||
return val + (val>>5);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int
|
||||
numcmp(x, y)
|
||||
long x, y;
|
||||
long x, y;
|
||||
{
|
||||
return x != y;
|
||||
return x != y;
|
||||
}
|
||||
|
||||
static int
|
||||
numhash(n)
|
||||
long n;
|
||||
long n;
|
||||
{
|
||||
return n;
|
||||
return n;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user