/haiku-fatelf/src/tools/fs_shell/ |
H A D | hash.cpp | 1 /* Generic hash table 35 struct hash_element **table; member in struct:FSShell::hash_table 51 next_element(hash_table *table, void *element) argument 54 return (void *)(*(unsigned long *)NEXT_ADDR(table, element)); 75 t->table = (struct hash_element **)malloc(sizeof(void *) * table_size); 76 if (t->table == NULL) { 82 t->table[i] = NULL; 91 TRACE(("hash_init: created table %p, next_ptr_offset %d, compare_func %p, hash_func %p\n", 99 hash_uninit(struct hash_table *table) argument 101 ASSERT(table 111 hash_insert(struct hash_table *table, void *element) argument 130 hash_remove(struct hash_table *table, void *_element) argument 154 hash_remove_current(struct hash_table *table, struct hash_iterator *iterator) argument 188 hash_remove_first(struct hash_table *table, uint32_t *_cookie) argument 209 hash_find(struct hash_table *table, void *searchedElement) argument 224 hash_lookup(struct hash_table *table, const void *key) argument 239 hash_open(struct hash_table *table, struct hash_iterator *iterator) argument 254 hash_close(struct hash_table *table, struct hash_iterator *iterator, bool freeIterator) argument 262 hash_rewind(struct hash_table *table, struct hash_iterator *iterator) argument 270 hash_next(struct hash_table *table, struct hash_iterator *iterator) argument [all...] |
H A D | hash.h | 24 int hash_uninit(struct hash_table *table); 25 fssh_status_t hash_insert(struct hash_table *table, void *_element); 26 fssh_status_t hash_remove(struct hash_table *table, void *_element); 27 void hash_remove_current(struct hash_table *table, struct hash_iterator *iterator); 28 void *hash_remove_first(struct hash_table *table, uint32_t *_cookie); 29 void *hash_find(struct hash_table *table, void *e); 30 void *hash_lookup(struct hash_table *table, const void *key); 31 struct hash_iterator *hash_open(struct hash_table *table, struct hash_iterator *i); 32 void hash_close(struct hash_table *table, struct hash_iterator *i, bool free_iterator); 33 void *hash_next(struct hash_table *table, struc [all...] |
/haiku-fatelf/src/system/libroot/posix/glibc/locale/ |
H A D | coll-lookup.c | 26 /* Lookup in a table of int32_t, with default value 0. */ 29 __collidx_table_lookup (const char *table, uint32_t wc) argument 31 uint32_t shift1 = ((const uint32_t *) table)[0]; 33 uint32_t bound = ((const uint32_t *) table)[1]; 36 uint32_t lookup1 = ((const uint32_t *) table)[5 + index1]; 39 uint32_t shift2 = ((const uint32_t *) table)[2]; 40 uint32_t mask2 = ((const uint32_t *) table)[3]; 42 uint32_t lookup2 = ((const uint32_t *)(table + lookup1))[index2]; 45 uint32_t mask3 = ((const uint32_t *) table)[4]; 47 int32_t lookup3 = ((const int32_t *)(table 60 __collseq_table_lookup(const char *table, uint32_t wc) argument [all...] |
H A D | coll-lookup.h | 22 /* Lookup in a table of int32_t, with default value 0. */ 23 extern int32_t __collidx_table_lookup (const char *table, uint32_t wc) 26 /* Lookup in a table of uint32_t, with default value 0xffffffff. */ 27 extern uint32_t __collseq_table_lookup (const char *table, uint32_t wc)
|
/haiku-fatelf/src/system/kernel/util/ |
H A D | khash.cpp | 9 //! Generic hash table 31 struct hash_element **table; member in struct:hash_table 68 next_element(hash_table *table, void *element) argument 71 return (void *)(*(unsigned long *)NEXT_ADDR(table, element)); 76 hash_grow(struct hash_table *table) argument 78 uint32 newSize = get_prime_table_size(table->num_elements); 82 if (table->table_size >= newSize) 91 // rehash all the entries and add them to the new table 92 for (index = 0; index < table->table_size; index++) { 96 for (element = table 160 hash_uninit(struct hash_table *table) argument 172 hash_insert(struct hash_table *table, void *element) argument 189 hash_insert_grow(struct hash_table *table, void *element) argument 211 hash_remove(struct hash_table *table, void *_element) argument 235 hash_remove_current(struct hash_table *table, struct hash_iterator *iterator) argument 278 hash_remove_first(struct hash_table *table, uint32 *_cookie) argument 299 hash_find(struct hash_table *table, void *searchedElement) argument 314 hash_lookup(struct hash_table *table, const void *key) argument 329 hash_open(struct hash_table *table, struct hash_iterator *iterator) argument 344 hash_close(struct hash_table *table, struct hash_iterator *iterator, bool freeIterator) argument 352 hash_rewind(struct hash_table *table, struct hash_iterator *iterator) argument 360 hash_next(struct hash_table *table, struct hash_iterator *iterator) argument 402 hash_count_elements(struct hash_table *table) argument 409 hash_count_used_slots(struct hash_table *table) argument 423 hash_dump_table(struct hash_table* table) argument [all...] |
/haiku-fatelf/src/bin/coreutils/lib/ |
H A D | hash.c | 1 /* hash - hashing table processing. 20 /* A generic hash table package. */ 56 are not empty, there are N_ENTRIES active entries in the table. */ 86 /* A hash table contains many internal entries, each holding a pointer to 91 and the current table size. At each slot position in the hash table, 97 entries divided by the table size. Finding the slot for a data is usually 100 larger hash table size (that is, a larger number of buckets) is prone to 103 Long buckets slow down the lookup algorithm. One might use big hash table 105 become inordinate, as unused slots in the hash table tak 150 hash_get_n_buckets(const Hash_table *table) argument 158 hash_get_n_buckets_used(const Hash_table *table) argument 166 hash_get_n_entries(const Hash_table *table) argument 174 hash_get_max_bucket_length(const Hash_table *table) argument 201 hash_table_ok(const Hash_table *table) argument 230 hash_print_statistics(const Hash_table *table, FILE *stream) argument 250 hash_lookup(const Hash_table *table, const void *entry) argument 281 hash_get_first(const Hash_table *table) argument 300 hash_get_next(const Hash_table *table, const void *entry) argument 328 hash_get_entries(const Hash_table *table, void **buffer, size_t buffer_size) argument 360 hash_do_for_each(const Hash_table *table, Hash_processor processor, void *processor_data) argument 504 check_tuning(Hash_table *table) argument 590 Hash_table *table; local 645 hash_clear(Hash_table *table) argument 688 hash_free(Hash_table *table) argument 743 allocate_entry(Hash_table *table) argument 768 free_entry(Hash_table *table, struct hash_entry *entry) argument 782 hash_find_entry(Hash_table *table, const void *entry, struct hash_entry **bucket_head, bool delete) argument 945 hash_rehash(Hash_table *table, size_t candidate) argument 1030 hash_insert(Hash_table *table, const void *entry) argument 1109 hash_delete(Hash_table *table, const void *entry) argument 1173 hash_print(const Hash_table *table) argument [all...] |
H A D | str-kmp.h | 40 /* Allocate the table. */ 41 size_t *table = (size_t *) nmalloca (m, sizeof (size_t)); local 42 if (table == NULL) 44 /* Fill the table. 46 0 < table[i] <= i is defined such that 47 forall 0 < x < table[i]: needle[x..i-1] != needle[0..i-1-x], 48 and table[i] is as large as possible with this property. 51 If table[i] < i, 52 needle[table[i]..i-1] = needle[0..i-1-table[ [all...] |
/haiku-fatelf/src/bin/findutils/gnulib/lib/ |
H A D | hash.c | 1 /* hash - hashing table processing. 21 /* A generic hash table package. */ 53 are not empty, there are N_ENTRIES active entries in the table. */ 83 /* A hash table contains many internal entries, each holding a pointer to 88 and the current table size. At each slot position in the hash table, 94 entries divided by the table size. Finding the slot for a data is usually 97 larger hash table size (that is, a larger number of buckets) is prone to 100 Long buckets slow down the lookup algorithm. One might use big hash table 102 become inordinate, as unused slots in the hash table tak 147 hash_get_n_buckets(const Hash_table *table) argument 155 hash_get_n_buckets_used(const Hash_table *table) argument 163 hash_get_n_entries(const Hash_table *table) argument 171 hash_get_max_bucket_length(const Hash_table *table) argument 198 hash_table_ok(const Hash_table *table) argument 227 hash_print_statistics(const Hash_table *table, FILE *stream) argument 247 hash_lookup(const Hash_table *table, const void *entry) argument 276 hash_get_first(const Hash_table *table) argument 295 hash_get_next(const Hash_table *table, const void *entry) argument 323 hash_get_entries(const Hash_table *table, void **buffer, size_t buffer_size) argument 355 hash_do_for_each(const Hash_table *table, Hash_processor processor, void *processor_data) argument 481 check_tuning(Hash_table *table) argument 541 Hash_table *table; local 604 hash_clear(Hash_table *table) argument 647 hash_free(Hash_table *table) argument 704 allocate_entry(Hash_table *table) argument 729 free_entry(Hash_table *table, struct hash_entry *entry) argument 743 hash_find_entry(Hash_table *table, const void *entry, struct hash_entry **bucket_head, bool delete) argument 818 hash_rehash(Hash_table *table, size_t candidate) argument 907 hash_insert(Hash_table *table, const void *entry) argument 982 hash_delete(Hash_table *table, const void *entry) argument 1028 hash_print(const Hash_table *table) argument [all...] |
/haiku-fatelf/src/system/libroot/posix/glibc/wctype/ |
H A D | wchar-lookup.h | 40 The table contains the following uint32_t words: 46 - 1st-level table: s offsets, pointing into the 2nd-level table, 47 - 2nd-level table: k*2^q offsets, pointing into the 3rd-level table, 48 - 3rd-level table: j*2^p words, each containing 32 bits of data. 52 wctype_table_lookup (const char *table, uint32_t wc) argument 54 uint32_t shift1 = ((const uint32_t *) table)[0]; 56 uint32_t bound = ((const uint32_t *) table)[1]; 59 uint32_t lookup1 = ((const uint32_t *) table)[ 83 wcwidth_table_lookup(const char *table, uint32_t wc) argument 116 wctrans_table_lookup(const char *table, uint32_t wc) argument [all...] |
/haiku-fatelf/headers/private/kernel/util/ |
H A D | khash.h | 36 int hash_uninit(struct hash_table *table); 37 status_t hash_insert(struct hash_table *table, void *_element); 38 status_t hash_insert_grow(struct hash_table *table, void *_element); 39 status_t hash_remove(struct hash_table *table, void *_element); 40 void hash_remove_current(struct hash_table *table, struct hash_iterator *iterator); 41 void *hash_remove_first(struct hash_table *table, uint32 *_cookie); 42 void *hash_find(struct hash_table *table, void *e); 43 void *hash_lookup(struct hash_table *table, const void *key); 44 struct hash_iterator *hash_open(struct hash_table *table, struct hash_iterator *i); 45 void hash_close(struct hash_table *table, struc [all...] |
/haiku-fatelf/src/bin/gdb/bfd/ |
H A D | hash.c | 1 /* hash.c -- hash table routines for BFD 33 BFD provides a simple set of hash table functions. Routines 34 are provided to initialize a hash table, to free a hash table, 35 to look up a string in a hash table and optionally create an 36 entry for it, and to traverse a hash table. There is 37 currently no routine to delete an string from a hash table. 39 The basic hash table does not permit any data to be stored 40 with a string. However, a hash table is designed to present a 44 rather than simply providing a data pointer in a hash table 549 struct bfd_hash_table table; member in struct:bfd_strtab_hash 607 struct bfd_strtab_hash *table; local [all...] |
H A D | genlink.h | 34 /* The generic linker uses a hash table which is a derived class of 35 the standard linker hash table, just as the other backend specific 36 linkers do. Do not confuse the generic linker hash table with the 37 standard BFD linker hash table it is built upon. */ 39 /* Generic linker hash table entries. */ 50 /* Generic linker hash table. */ 57 /* Look up an entry in a generic link hash table. */ 59 #define _bfd_generic_link_hash_lookup(table, string, create, copy, follow) \ 61 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow))) 63 /* Traverse a generic link hash table [all...] |
/haiku-fatelf/src/bin/bash/ |
H A D | hashlib.c | 43 /* Make a new hash table with BUCKETS number of buckets. Initialize 44 each slot in the table to NULL. */ 68 hash_size (table) 69 HASH_TABLE *table; 71 return (HASH_ENTRIES(table)); 109 hash_copy (table, cpdata) 110 HASH_TABLE *table; 116 if (table == 0) 119 new_table = hash_create (table->nbuckets); 121 for (i = 0; i < table 382 HASH_TABLE *table, *ntable; variable [all...] |
/haiku-fatelf/src/tools/docbook/libxml2/ |
H A D | hash.c | 35 * A single entry in the hash table 49 * The entire hash table 52 struct _xmlHashEntry *table; member in struct:_xmlHashTable 63 xmlHashComputeKey(xmlHashTablePtr table, const xmlChar *name, argument 84 return (value % table->size); 88 xmlHashComputeQKey(xmlHashTablePtr table, argument 133 return (value % table->size); 138 * @size: the size of the hash table 146 xmlHashTablePtr table; local 151 table 177 xmlHashTablePtr table; local 197 xmlHashGrow(xmlHashTablePtr table, int size) argument 288 xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f) argument 344 xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata) argument 361 xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata) argument 380 xmlHashUpdateEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata, xmlHashDeallocator f) argument 400 xmlHashUpdateEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata, xmlHashDeallocator f) argument 416 xmlHashLookup(xmlHashTablePtr table, const xmlChar *name) argument 431 xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2) argument 447 xmlHashQLookup(xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name) argument 465 xmlHashQLookup2(xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name, const xmlChar *prefix2, const xmlChar *name2) argument 486 xmlHashAddEntry3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata) argument 602 xmlHashUpdateEntry3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata, xmlHashDeallocator f) argument 724 xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3) argument 768 xmlHashQLookup3(xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name, const xmlChar *prefix2, const xmlChar *name2, const xmlChar *prefix3, const xmlChar *name3) argument 814 xmlHashScan(xmlHashTablePtr table, xmlHashScanner f, void *data) argument 830 xmlHashScanFull(xmlHashTablePtr table, xmlHashScannerFull f, void *data) argument 870 xmlHashScan3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashScanner f, void *data) argument 891 xmlHashScanFull3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashScannerFull f, void *data) argument 933 xmlHashCopy(xmlHashTablePtr table, xmlHashCopier f) argument 972 xmlHashSize(xmlHashTablePtr table) argument 990 xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, xmlHashDeallocator f) argument 1009 xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, xmlHashDeallocator f) argument 1029 xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashDeallocator f) argument [all...] |
/haiku-fatelf/src/libs/ncurses/ncurses/ |
H A D | unctrl.c | 9 static const char* const table[] = { local 45 if (check < 0 || check >= (int)SIZEOF(table)) return 0; 47 return (NCURSES_CONST char *)table[check];
|
/haiku-fatelf/src/bin/gdb/gdb/ |
H A D | frame-base.c | 76 struct frame_base_table *table local 78 table->tail = &table->head; 79 table->default_base = &default_frame_base; 80 return table; 87 struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data); local 88 (*table->tail) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_base_table_entry); 89 (*table->tail)->sniffer = sniffer; 90 table->tail = &(*table 97 struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data); local 105 struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data); local [all...] |
H A D | frame-unwind.c | 48 struct frame_unwind_table *table local 50 /* Start the table out with a few default sniffers. OSABI code 52 table->list = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); 53 table->list->unwinder = dummy_frame_unwind; 55 table->osabi_head = &table->list->next; 56 return table; 63 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); local 67 for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); 76 struct frame_unwind_table *table local 91 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); local [all...] |
/haiku-fatelf/src/bin/less/ |
H A D | position.c | 13 * Routines dealing with the "position" table. 14 * This is a table which tells the position (in the input file) of the 17 * {{ The position table is scrolled by moving all the entries. 18 * Would be better to have a circular table 25 static POSITION *table = NULL; /* The position table */ variable 54 return (table[where]); 58 * Add a new file position to the bottom of the position table. 67 * Scroll the position table up. 70 table[ [all...] |
/haiku-fatelf/src/system/libroot/posix/glibc/misc/ |
H A D | hsearch_r.c | 42 /* For the used double hash method the table size has to be a prime. To 43 correct the user given table size we need a prime test. This trivial 46 b) the number is small because the table must fit in the core */ 60 /* Before using the hash table we must allocate memory for it. 61 Test for an existing table are done. We allocate one element 64 The contents of the table is zeroed, especially the field used 78 /* There is still another table active. Return with error. */ 79 if (htab->table != NULL) 95 htab->table = (_ENTRY *) calloc (htab->size + 1, sizeof (_ENTRY)); 96 if (htab->table [all...] |
/haiku-fatelf/src/system/kernel/arch/x86/64/ |
H A D | descriptors.cpp | 75 // switching mechanism, the IST. The IST is a table of stack addresses 89 // Initialize the interrupt handler table. 90 interrupt_handler_function** table = gInterruptHandlerTable; local 92 table[i] = x86_invalid_exception; 94 table[i] = x86_hardware_interrupt; 96 table[0] = x86_unexpected_exception; // Divide Error Exception (#DE) 97 table[1] = x86_handle_debug_exception; // Debug Exception (#DB) 98 table[2] = x86_fatal_exception; // NMI Interrupt 99 table[3] = x86_handle_breakpoint_exception; // Breakpoint Exception (#BP) 100 table[ [all...] |
/haiku-fatelf/src/tools/docbook/libxml2/include/libxml/ |
H A D | hash.h | 3 * Description: This module implements the hash table support used in 19 * The hash table. 112 xmlHashFree (xmlHashTablePtr table, 116 * Add a new entry to the hash table. 119 xmlHashAddEntry (xmlHashTablePtr table, 123 xmlHashUpdateEntry(xmlHashTablePtr table, 128 xmlHashAddEntry2(xmlHashTablePtr table, 133 xmlHashUpdateEntry2(xmlHashTablePtr table, 139 xmlHashAddEntry3(xmlHashTablePtr table, 145 xmlHashUpdateEntry3(xmlHashTablePtr table, [all...] |
/haiku-fatelf/headers/os/drivers/ |
H A D | mime_table.h | 5 / Description: Kernel mime table and matcher module API 26 status_t get_table(struct ext_mime **table) 27 Returns the current kernel mime table. 30 void free_table(struct ext_mime *table) 31 Frees the given mime table; 45 status_t (*get_table)(struct ext_mime **table); 46 void (*free_table)(struct ext_mime *table);
|
/haiku-fatelf/src/kits/opengl/ |
H A D | GLDispatcher.cpp | 64 BGLDispatcher::CheckTable(const struct _glapi_table* table) argument 66 _glapi_check_table(table ? table : _glapi_get_dispatch()); 72 BGLDispatcher::SetTable(struct _glapi_table* table) argument 74 _glapi_set_dispatch(table);
|
/haiku-fatelf/src/add-ons/accelerants/intel_810/ |
H A D | i810_watermark.cpp | 111 WatermarkInfo *table; local 119 table = watermarks_8; 123 table = watermarks_16; 133 for (i = 0; i < tableLen && table[i].freq < clockFreq; i++) 139 TRACE("chosen watermark 0x%lx (freq %f)\n", table[i].watermark, 140 table[i].freq); 142 return table[i].watermark;
|
/haiku-fatelf/src/apps/debugger/user_interface/gui/util/ |
H A D | GuiSettingsUtils.h | 26 AbstractTable* table); 30 AbstractTable* table);
|