Searched refs:table (Results 1 - 25 of 348) sorted by relevance

1234567891011>>

/haiku-fatelf/src/tools/fs_shell/
H A Dhash.cpp1 /* 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 Dhash.h24 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 Dcoll-lookup.c26 /* 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 Dcoll-lookup.h22 /* 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 Dkhash.cpp9 //! 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 Dhash.c1 /* 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 Dstr-kmp.h40 /* 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 Dhash.c1 /* 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 Dwchar-lookup.h40 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 Dkhash.h36 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 Dhash.c1 /* 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 Dgenlink.h34 /* 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 Dhashlib.c43 /* 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 Dhash.c35 * 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 Dunctrl.c9 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 Dframe-base.c76 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 Dframe-unwind.c48 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 Dposition.c13 * 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 Dhsearch_r.c42 /* 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 Ddescriptors.cpp75 // 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 Dhash.h3 * 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 Dmime_table.h5 / 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 DGLDispatcher.cpp64 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 Di810_watermark.cpp111 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 DGuiSettingsUtils.h26 AbstractTable* table);
30 AbstractTable* table);

Completed in 139 milliseconds

1234567891011>>