nc4dim.c#114      if (nn_hash == dim->hash && !strncmp(dim->name, norm_name, NC_MAX_NAME))


#129   dim->hash = nn_hash;


#169	 if (dim->hash == shash && !strncmp(dim->name, norm_name, NC_MAX_NAME))


#306   dim->hash = hash_fast(norm_name, strlen(norm_name));


nc4file.c#631   new_dim->hash = hash_fast(obj_name, strlen(obj_name));


#1598   var->hash = hash_fast(var->name, strlen(var->name));


#2613      var->hash = hash_fast(var->name, strlen(var->name));


#2718	    dim->hash = hash_fast(dim_name, strlen(dim_name));


nc4hdf.c#3778                      dim->hash = hash_fast(phony_dim_name, strlen(phony_dim_name));


nc4internal.c#779   uint32_t hash;


#792   hash =  hash_fast(name, strlen(name));


#794      if (var->hash == hash && !strcmp(var->name, name))


nc4internal.h#121   uint32_t hash;


#157   uint32_t hash;


nc4var.c#424   var->hash = hash_fast(norm_name, strlen(norm_name));


#513      if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->name, norm_name) == 0)


#571      if (dim->hash == var->hash && !strcmp(dim->name, norm_name) &&


#1152      if (nn_hash == var->hash && !(strcmp(var->name, norm_name)))


#1202      if (nn_hash == var->hash && !strncmp(var->name, name, NC_MAX_NAME))


#1230   var->hash = nn_hash;


nc_hashmap.c#131  NC_hashmap* hash = ncap->hashmap;


#133  if (hash->size*3/4 <= hash->count) {


#140    unsigned long index = key % hash->size;


#141    unsigned long step = (key % MAX(1,(hash->size-2))) + 1;


#143    for (i = 0; i < hash->size; i++)


#145      if (hash->table[index].flags & ACTIVE)


#147	hEntry entry = hash->table[index];


#152	  hash->table[index].data = data+1;


#158	hash->table[index].flags |= ACTIVE;


#159	hash->table[index].data = data+1;


#160	hash->table[index].key = key;


#161	++hash->count;


#165      index = (index + step) % hash->size;


#178  NC_hashmap* hash = ncap->hashmap;


#180  if (hash->size*3/4 <= hash->count) {


#187    unsigned long index = key % hash->size;


#188    unsigned long step = (key % MAX(1,(hash->size-2))) + 1;


#190    for (i = 0; i < hash->size; i++)


#192      if (hash->table[index].flags & ACTIVE)


#194	hEntry entry = hash->table[index];


#199	  hash->table[index].data = data+1;


#205	hash->table[index].flags |= ACTIVE;


#206	hash->table[index].data = data+1;


#207	hash->table[index].key = key;


#208	++hash->count;


#212      index = (index + step) % hash->size;


#226  NC_hashmap* hash = ncap->hashmap;


#228  unsigned long index = key % hash->size;


#229  unsigned long step = (key % (hash->size-2)) + 1;


#231  for (i = 0; i < hash->size; i++)


#233    if (hash->table[index].data > 0)


#235      hEntry entry = hash->table[index];


#240	if (hash->table[index].flags & ACTIVE)


#242	  hash->table[index].flags &= ~ACTIVE;


#243	  --hash->count;


#244	  return hash->table[index].data-1;


#253    index = (index + step) % hash->size;


#263  NC_hashmap* hash = ncap->hashmap;


#265  unsigned long index = key % hash->size;


#266  unsigned long step = (key % (hash->size-2)) + 1;


#268  for (i = 0; i < hash->size; i++)


#270    if (hash->table[index].data > 0)


#272      hEntry entry = hash->table[index];


#277	if (hash->table[index].flags & ACTIVE)


#279	  hash->table[index].flags &= ~ACTIVE;


#280	  --hash->count;


#281	  return hash->table[index].data-1;


#290    index = (index + step) % hash->size;


#298  NC_hashmap* hash = ncap->hashmap;


#299  if (hash->count)


#302    NC_hashmap* hash = ncap->hashmap;


#305    unsigned long index = key % hash->size;


#306    unsigned long step = (key % (hash->size-2)) + 1;


#308    for (i = 0; i < hash->size; i++)


#310      hEntry entry = hash->table[index];


#323      index = (index + step) % hash->size;


#332  NC_hashmap* hash = ncap->hashmap;


#333  if (hash->count)


#336    NC_hashmap* hash = ncap->hashmap;


#339    unsigned long index = key % hash->size;


#340    unsigned long step = (key % (hash->size-2)) + 1;


#342    for (i = 0; i < hash->size; i++)


#344      hEntry entry = hash->table[index];


#357      index = (index + step) % hash->size;


#364unsigned long NC_hashmapCount(NC_hashmap* hash)


#366  return hash->count;


#369void NC_hashmapDelete(NC_hashmap* hash)


#371  if (hash) {


#372    free(hash->table);


#373    free(hash);


nchashmap.c#61nchashinsert(NChashmap* hm, nchashid hash, void* value)


#68    offset = (hash % hm->alloc);


#74	if(hash==(nchashid)(*list)) return FALSE;


#76    nclistpush(seq,(void*)hash);


#85nchashreplace(NChashmap* hm, nchashid hash, void* value)


#92    offset = (hash % hm->alloc);


#98	if(hash==(nchashid)(*list)) {list[1] = value; return TRUE;}


#100    nclistpush(seq,(void*)hash);


#109nchashremove(NChashmap* hm, nchashid hash)


#116    offset = (hash % hm->alloc);


#122	if(hash==(nchashid)(*list)) {


#136nchashget(NChashmap* hm, nchashid hash)


#139    if(!nchashlookup(hm,hash,&value)) return NULL;


#144nchashlookup(NChashmap* hm, nchashid hash, void** valuep)


#151    offset = (hash % hm->alloc);


#157	if(hash==(nchashid)(*list)) {if(valuep) {*valuep = list[1]; return TRUE;}}


test_put.c#10998		    value[k] = hash(ATT_TYPE(i,j), -1, &k);


test_read.c#869	    expect = hash( var_type[i], var_rank[i], index );


#987		    expect = hash(var_type[i], var_rank[i], index);


#1142			expect = hash(var_type[i], var_rank[i], index2);


#1312            expect = hash( var_type[i], var_rank[i], index);


#1375		    expect = hash(ATT_TYPE(i,j), -1, &k );


test_write.c#753            value = hash( var_type[i], var_rank[i], index);


#870		value = hash( var_type[i], var_rank[i], index);


#1024		    value = hash( var_type[i], var_rank[i], index2);


#1118	    value = hash( var_type[i], var_rank[i], index);


#1342		value = hash(datatype, -1, &k );


#1612                    expect = hash(datatype, -1, &k);


#1624                    expect = hash(datatype, -1, &k);


tests.h#536double hash( const nc_type type, const int rank, const size_t *index );


util.c#377hash( const nc_type type, const int rank, const size_t *index )


#482hash( const nc_type type, const int rank, const size_t *index )


#590    result = hash( type, rank, index );


#790		    catt[k] = hash(ATT_TYPE(i,j), -1, &k);


#798		    att[k] = hash(ATT_TYPE(i,j), -1, &k);


#835		text[j] = hash(var_type[i], var_rank[i], index);


#837		value[j]  = hash(var_type[i], var_rank[i], index);


#961	    expect = hash( var_type[i], var_rank[i], index );


#1042		    IF (text[k] != hash(datatype, -1, &k)) {


#1051		    expect = hash(datatype, -1, &k);




HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017  | Polyhedron Solutions - INTERNAL USE | COMMERCIAL  (Any O/S) SN 4AKIed