1 /* Routines for name->symbol lookups in GDB.
3 Copyright (C) 2003, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 Contributed by David Carlton <carlton@bactrian.org> and by Kealia,
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_obstack.h"
27 #include "gdb_assert.h"
28 #include "dictionary.h"
30 /* This file implements dictionaries, which are tables that associate
31 symbols to names. They are represented by an opaque type 'struct
32 dictionary'. That type has various internal implementations, which
33 you can choose between depending on what properties you need
34 (e.g. fast lookup, order-preserving, expandable).
36 Each dictionary starts with a 'virtual function table' that
37 contains the functions that actually implement the various
38 operations that dictionaries provide. (Note, however, that, for
39 the sake of client code, we also provide some functions that can be
40 implemented generically in terms of the functions in the vtable.)
42 To add a new dictionary implementation <impl>, what you should do
45 * Add a new element DICT_<IMPL> to dict_type.
47 * Create a new structure dictionary_<impl>. If your new
48 implementation is a variant of an existing one, make sure that
49 their structs have the same initial data members. Define accessor
50 macros for your new data members.
52 * Implement all the functions in dict_vector as static functions,
53 whose name is the same as the corresponding member of dict_vector
54 plus _<impl>. You don't have to do this for those members where
55 you can reuse existing generic functions
56 (e.g. add_symbol_nonexpandable, free_obstack) or in the case where
57 your new implementation is a variant of an existing implementation
58 and where the variant doesn't affect the member function in
61 * Define a static const struct dict_vector dict_<impl>_vector.
63 * Define a function dict_create_<impl> to create these
64 gizmos. Add its declaration to dictionary.h.
66 To add a new operation <op> on all existing implementations, what
69 * Add a new member <op> to struct dict_vector.
71 * If there is useful generic behavior <op>, define a static
72 function <op>_something_informative that implements that behavior.
73 (E.g. add_symbol_nonexpandable, free_obstack.)
75 * For every implementation <impl> that should have its own specific
76 behavior for <op>, define a static function <op>_<impl>
79 * Modify all existing dict_vector_<impl>'s to include the appropriate
82 * Define a function dict_<op> that looks up <op> in the dict_vector
83 and calls the appropriate function. Add a declaration for
84 dict_<op> to dictionary.h.
88 /* An enum representing the various implementations of dictionaries.
89 Used only for debugging. */
93 /* Symbols are stored in a fixed-size hash table. */
95 /* Symbols are stored in an expandable hash table. */
96 DICT_HASHED_EXPANDABLE
,
97 /* Symbols are stored in a fixed-size array. */
99 /* Symbols are stored in an expandable array. */
100 DICT_LINEAR_EXPANDABLE
103 /* The virtual function table. */
107 /* The type of the dictionary. This is only here to make debugging
108 a bit easier; it's not actually used. */
110 /* The function to free a dictionary. */
111 void (*free
) (struct dictionary
*dict
);
112 /* Add a symbol to a dictionary, if possible. */
113 void (*add_symbol
) (struct dictionary
*dict
, struct symbol
*sym
);
114 /* Iterator functions. */
115 struct symbol
*(*iterator_first
) (const struct dictionary
*dict
,
116 struct dict_iterator
*iterator
);
117 struct symbol
*(*iterator_next
) (struct dict_iterator
*iterator
);
118 /* Functions to iterate over symbols with a given name. */
119 struct symbol
*(*iter_name_first
) (const struct dictionary
*dict
,
121 struct dict_iterator
*iterator
);
122 struct symbol
*(*iter_name_next
) (const char *name
,
123 struct dict_iterator
*iterator
);
124 /* A size function, for maint print symtabs. */
125 int (*size
) (const struct dictionary
*dict
);
128 /* Now comes the structs used to store the data for different
129 implementations. If two implementations have data in common, put
130 the common data at the top of their structs, ordered in the same
133 struct dictionary_hashed
136 struct symbol
**buckets
;
139 struct dictionary_hashed_expandable
141 /* How many buckets we currently have. */
143 struct symbol
**buckets
;
144 /* How many syms we currently have; we need this so we will know
145 when to add more buckets. */
149 struct dictionary_linear
152 struct symbol
**syms
;
155 struct dictionary_linear_expandable
157 /* How many symbols we currently have. */
159 struct symbol
**syms
;
160 /* How many symbols we can store before needing to reallocate. */
164 /* And now, the star of our show. */
168 const struct dict_vector
*vector
;
171 struct dictionary_hashed hashed
;
172 struct dictionary_hashed_expandable hashed_expandable
;
173 struct dictionary_linear linear
;
174 struct dictionary_linear_expandable linear_expandable
;
179 /* Accessor macros. */
181 #define DICT_VECTOR(d) (d)->vector
183 /* These can be used for DICT_HASHED_EXPANDABLE, too. */
185 #define DICT_HASHED_NBUCKETS(d) (d)->data.hashed.nbuckets
186 #define DICT_HASHED_BUCKETS(d) (d)->data.hashed.buckets
187 #define DICT_HASHED_BUCKET(d,i) DICT_HASHED_BUCKETS (d) [i]
189 #define DICT_HASHED_EXPANDABLE_NSYMS(d) (d)->data.hashed_expandable.nsyms
191 /* These can be used for DICT_LINEAR_EXPANDABLEs, too. */
193 #define DICT_LINEAR_NSYMS(d) (d)->data.linear.nsyms
194 #define DICT_LINEAR_SYMS(d) (d)->data.linear.syms
195 #define DICT_LINEAR_SYM(d,i) DICT_LINEAR_SYMS (d) [i]
197 #define DICT_LINEAR_EXPANDABLE_CAPACITY(d) \
198 (d)->data.linear_expandable.capacity
200 /* The initial size of a DICT_*_EXPANDABLE dictionary. */
202 #define DICT_EXPANDABLE_INITIAL_CAPACITY 10
204 /* This calculates the number of buckets we'll use in a hashtable,
205 given the number of symbols that it will contain. */
207 #define DICT_HASHTABLE_SIZE(n) ((n)/5 + 1)
209 /* Accessor macros for dict_iterators; they're here rather than
210 dictionary.h because code elsewhere should treat dict_iterators as
213 /* The dictionary that the iterator is associated to. */
214 #define DICT_ITERATOR_DICT(iter) (iter)->dict
215 /* For linear dictionaries, the index of the last symbol returned; for
216 hashed dictionaries, the bucket of the last symbol returned. */
217 #define DICT_ITERATOR_INDEX(iter) (iter)->index
218 /* For hashed dictionaries, this points to the last symbol returned;
219 otherwise, this is unused. */
220 #define DICT_ITERATOR_CURRENT(iter) (iter)->current
222 /* Declarations of functions for vectors. */
224 /* Functions that might work across a range of dictionary types. */
226 static void add_symbol_nonexpandable (struct dictionary
*dict
,
229 static void free_obstack (struct dictionary
*dict
);
231 /* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE
234 static struct symbol
*iterator_first_hashed (const struct dictionary
*dict
,
235 struct dict_iterator
*iterator
);
237 static struct symbol
*iterator_next_hashed (struct dict_iterator
*iterator
);
239 static struct symbol
*iter_name_first_hashed (const struct dictionary
*dict
,
241 struct dict_iterator
*iterator
);
243 static struct symbol
*iter_name_next_hashed (const char *name
,
244 struct dict_iterator
*iterator
);
246 /* Functions only for DICT_HASHED. */
248 static int size_hashed (const struct dictionary
*dict
);
250 /* Functions only for DICT_HASHED_EXPANDABLE. */
252 static void free_hashed_expandable (struct dictionary
*dict
);
254 static void add_symbol_hashed_expandable (struct dictionary
*dict
,
257 static int size_hashed_expandable (const struct dictionary
*dict
);
259 /* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE
262 static struct symbol
*iterator_first_linear (const struct dictionary
*dict
,
263 struct dict_iterator
*iterator
);
265 static struct symbol
*iterator_next_linear (struct dict_iterator
*iterator
);
267 static struct symbol
*iter_name_first_linear (const struct dictionary
*dict
,
269 struct dict_iterator
*iterator
);
271 static struct symbol
*iter_name_next_linear (const char *name
,
272 struct dict_iterator
*iterator
);
274 static int size_linear (const struct dictionary
*dict
);
276 /* Functions only for DICT_LINEAR_EXPANDABLE. */
278 static void free_linear_expandable (struct dictionary
*dict
);
280 static void add_symbol_linear_expandable (struct dictionary
*dict
,
283 /* Various vectors that we'll actually use. */
285 static const struct dict_vector dict_hashed_vector
=
287 DICT_HASHED
, /* type */
288 free_obstack
, /* free */
289 add_symbol_nonexpandable
, /* add_symbol */
290 iterator_first_hashed
, /* iterator_first */
291 iterator_next_hashed
, /* iterator_next */
292 iter_name_first_hashed
, /* iter_name_first */
293 iter_name_next_hashed
, /* iter_name_next */
294 size_hashed
, /* size */
297 static const struct dict_vector dict_hashed_expandable_vector
=
299 DICT_HASHED_EXPANDABLE
, /* type */
300 free_hashed_expandable
, /* free */
301 add_symbol_hashed_expandable
, /* add_symbol */
302 iterator_first_hashed
, /* iterator_first */
303 iterator_next_hashed
, /* iterator_next */
304 iter_name_first_hashed
, /* iter_name_first */
305 iter_name_next_hashed
, /* iter_name_next */
306 size_hashed_expandable
, /* size */
309 static const struct dict_vector dict_linear_vector
=
311 DICT_LINEAR
, /* type */
312 free_obstack
, /* free */
313 add_symbol_nonexpandable
, /* add_symbol */
314 iterator_first_linear
, /* iterator_first */
315 iterator_next_linear
, /* iterator_next */
316 iter_name_first_linear
, /* iter_name_first */
317 iter_name_next_linear
, /* iter_name_next */
318 size_linear
, /* size */
321 static const struct dict_vector dict_linear_expandable_vector
=
323 DICT_LINEAR_EXPANDABLE
, /* type */
324 free_linear_expandable
, /* free */
325 add_symbol_linear_expandable
, /* add_symbol */
326 iterator_first_linear
, /* iterator_first */
327 iterator_next_linear
, /* iterator_next */
328 iter_name_first_linear
, /* iter_name_first */
329 iter_name_next_linear
, /* iter_name_next */
330 size_linear
, /* size */
333 /* Declarations of helper functions (i.e. ones that don't go into
336 static struct symbol
*iterator_hashed_advance (struct dict_iterator
*iter
);
338 static void insert_symbol_hashed (struct dictionary
*dict
,
341 static void expand_hashtable (struct dictionary
*dict
);
343 /* The creation functions. */
345 /* Create a dictionary implemented via a fixed-size hashtable. All
346 memory it uses is allocated on OBSTACK; the environment is
347 initialized from SYMBOL_LIST. */
350 dict_create_hashed (struct obstack
*obstack
,
351 const struct pending
*symbol_list
)
353 struct dictionary
*retval
;
354 int nsyms
= 0, nbuckets
, i
;
355 struct symbol
**buckets
;
356 const struct pending
*list_counter
;
358 retval
= obstack_alloc (obstack
, sizeof (struct dictionary
));
359 DICT_VECTOR (retval
) = &dict_hashed_vector
;
361 /* Calculate the number of symbols, and allocate space for them. */
362 for (list_counter
= symbol_list
;
363 list_counter
!= NULL
;
364 list_counter
= list_counter
->next
)
366 nsyms
+= list_counter
->nsyms
;
368 nbuckets
= DICT_HASHTABLE_SIZE (nsyms
);
369 DICT_HASHED_NBUCKETS (retval
) = nbuckets
;
370 buckets
= obstack_alloc (obstack
, nbuckets
* sizeof (struct symbol
*));
371 memset (buckets
, 0, nbuckets
* sizeof (struct symbol
*));
372 DICT_HASHED_BUCKETS (retval
) = buckets
;
374 /* Now fill the buckets. */
375 for (list_counter
= symbol_list
;
376 list_counter
!= NULL
;
377 list_counter
= list_counter
->next
)
379 for (i
= list_counter
->nsyms
- 1; i
>= 0; --i
)
381 insert_symbol_hashed (retval
, list_counter
->symbol
[i
]);
388 /* Create a dictionary implemented via a hashtable that grows as
389 necessary. The dictionary is initially empty; to add symbols to
390 it, call dict_add_symbol(). Call dict_free() when you're done with
393 extern struct dictionary
*
394 dict_create_hashed_expandable (void)
396 struct dictionary
*retval
;
398 retval
= xmalloc (sizeof (struct dictionary
));
399 DICT_VECTOR (retval
) = &dict_hashed_expandable_vector
;
400 DICT_HASHED_NBUCKETS (retval
) = DICT_EXPANDABLE_INITIAL_CAPACITY
;
401 DICT_HASHED_BUCKETS (retval
) = xcalloc (DICT_EXPANDABLE_INITIAL_CAPACITY
,
402 sizeof (struct symbol
*));
403 DICT_HASHED_EXPANDABLE_NSYMS (retval
) = 0;
408 /* Create a dictionary implemented via a fixed-size array. All memory
409 it uses is allocated on OBSTACK; the environment is initialized
410 from the SYMBOL_LIST. The symbols are ordered in the same order
411 that they're found in SYMBOL_LIST. */
414 dict_create_linear (struct obstack
*obstack
,
415 const struct pending
*symbol_list
)
417 struct dictionary
*retval
;
419 struct symbol
**syms
;
420 const struct pending
*list_counter
;
422 retval
= obstack_alloc (obstack
, sizeof (struct dictionary
));
423 DICT_VECTOR (retval
) = &dict_linear_vector
;
425 /* Calculate the number of symbols, and allocate space for them. */
426 for (list_counter
= symbol_list
;
427 list_counter
!= NULL
;
428 list_counter
= list_counter
->next
)
430 nsyms
+= list_counter
->nsyms
;
432 DICT_LINEAR_NSYMS (retval
) = nsyms
;
433 syms
= obstack_alloc (obstack
, nsyms
* sizeof (struct symbol
*));
434 DICT_LINEAR_SYMS (retval
) = syms
;
436 /* Now fill in the symbols. Start filling in from the back, so as
437 to preserve the original order of the symbols. */
438 for (list_counter
= symbol_list
, j
= nsyms
- 1;
439 list_counter
!= NULL
;
440 list_counter
= list_counter
->next
)
442 for (i
= list_counter
->nsyms
- 1;
446 syms
[j
] = list_counter
->symbol
[i
];
453 /* Create a dictionary implemented via an array that grows as
454 necessary. The dictionary is initially empty; to add symbols to
455 it, call dict_add_symbol(). Call dict_free() when you're done with
459 dict_create_linear_expandable (void)
461 struct dictionary
*retval
;
463 retval
= xmalloc (sizeof (struct dictionary
));
464 DICT_VECTOR (retval
) = &dict_linear_expandable_vector
;
465 DICT_LINEAR_NSYMS (retval
) = 0;
466 DICT_LINEAR_EXPANDABLE_CAPACITY (retval
)
467 = DICT_EXPANDABLE_INITIAL_CAPACITY
;
468 DICT_LINEAR_SYMS (retval
)
469 = xmalloc (DICT_LINEAR_EXPANDABLE_CAPACITY (retval
)
470 * sizeof (struct symbol
*));
475 /* The functions providing the dictionary interface. */
477 /* Free the memory used by a dictionary that's not on an obstack. (If
481 dict_free (struct dictionary
*dict
)
483 (DICT_VECTOR (dict
))->free (dict
);
486 /* Add SYM to DICT. DICT had better be expandable. */
489 dict_add_symbol (struct dictionary
*dict
, struct symbol
*sym
)
491 (DICT_VECTOR (dict
))->add_symbol (dict
, sym
);
494 /* Initialize ITERATOR to point at the first symbol in DICT, and
495 return that first symbol, or NULL if DICT is empty. */
498 dict_iterator_first (const struct dictionary
*dict
,
499 struct dict_iterator
*iterator
)
501 return (DICT_VECTOR (dict
))->iterator_first (dict
, iterator
);
504 /* Advance ITERATOR, and return the next symbol, or NULL if there are
508 dict_iterator_next (struct dict_iterator
*iterator
)
510 return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator
)))
511 ->iterator_next (iterator
);
515 dict_iter_name_first (const struct dictionary
*dict
,
517 struct dict_iterator
*iterator
)
519 return (DICT_VECTOR (dict
))->iter_name_first (dict
, name
, iterator
);
523 dict_iter_name_next (const char *name
, struct dict_iterator
*iterator
)
525 return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator
)))
526 ->iter_name_next (name
, iterator
);
530 dict_size (const struct dictionary
*dict
)
532 return (DICT_VECTOR (dict
))->size (dict
);
535 /* Now come functions (well, one function, currently) that are
536 implemented generically by means of the vtable. Typically, they're
539 /* Test to see if DICT is empty. */
542 dict_empty (struct dictionary
*dict
)
544 struct dict_iterator iter
;
546 return (dict_iterator_first (dict
, &iter
) == NULL
);
550 /* The functions implementing the dictionary interface. */
552 /* Generic functions, where appropriate. */
555 free_obstack (struct dictionary
*dict
)
561 add_symbol_nonexpandable (struct dictionary
*dict
, struct symbol
*sym
)
563 internal_error (__FILE__
, __LINE__
,
564 _("dict_add_symbol: non-expandable dictionary"));
567 /* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE. */
569 static struct symbol
*
570 iterator_first_hashed (const struct dictionary
*dict
,
571 struct dict_iterator
*iterator
)
573 DICT_ITERATOR_DICT (iterator
) = dict
;
574 DICT_ITERATOR_INDEX (iterator
) = -1;
575 return iterator_hashed_advance (iterator
);
578 static struct symbol
*
579 iterator_next_hashed (struct dict_iterator
*iterator
)
583 next
= DICT_ITERATOR_CURRENT (iterator
)->hash_next
;
586 return iterator_hashed_advance (iterator
);
589 DICT_ITERATOR_CURRENT (iterator
) = next
;
594 static struct symbol
*
595 iterator_hashed_advance (struct dict_iterator
*iterator
)
597 const struct dictionary
*dict
= DICT_ITERATOR_DICT (iterator
);
598 int nbuckets
= DICT_HASHED_NBUCKETS (dict
);
601 for (i
= DICT_ITERATOR_INDEX (iterator
) + 1; i
< nbuckets
; ++i
)
603 struct symbol
*sym
= DICT_HASHED_BUCKET (dict
, i
);
607 DICT_ITERATOR_INDEX (iterator
) = i
;
608 DICT_ITERATOR_CURRENT (iterator
) = sym
;
616 static struct symbol
*
617 iter_name_first_hashed (const struct dictionary
*dict
,
619 struct dict_iterator
*iterator
)
621 unsigned int hash_index
622 = msymbol_hash_iw (name
) % DICT_HASHED_NBUCKETS (dict
);
625 DICT_ITERATOR_DICT (iterator
) = dict
;
627 /* Loop through the symbols in the given bucket, breaking when SYM
628 first matches. If SYM never matches, it will be set to NULL;
629 either way, we have the right return value. */
631 for (sym
= DICT_HASHED_BUCKET (dict
, hash_index
);
633 sym
= sym
->hash_next
)
635 /* Warning: the order of arguments to strcmp_iw matters! */
636 if (strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
643 DICT_ITERATOR_CURRENT (iterator
) = sym
;
647 static struct symbol
*
648 iter_name_next_hashed (const char *name
, struct dict_iterator
*iterator
)
652 for (next
= DICT_ITERATOR_CURRENT (iterator
)->hash_next
;
654 next
= next
->hash_next
)
656 if (strcmp_iw (SYMBOL_SEARCH_NAME (next
), name
) == 0)
660 DICT_ITERATOR_CURRENT (iterator
) = next
;
665 /* Insert SYM into DICT. */
668 insert_symbol_hashed (struct dictionary
*dict
,
671 unsigned int hash_index
;
672 struct symbol
**buckets
= DICT_HASHED_BUCKETS (dict
);
674 hash_index
= (msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym
))
675 % DICT_HASHED_NBUCKETS (dict
));
676 sym
->hash_next
= buckets
[hash_index
];
677 buckets
[hash_index
] = sym
;
681 size_hashed (const struct dictionary
*dict
)
683 return DICT_HASHED_NBUCKETS (dict
);
686 /* Functions only for DICT_HASHED_EXPANDABLE. */
689 free_hashed_expandable (struct dictionary
*dict
)
691 xfree (DICT_HASHED_BUCKETS (dict
));
696 add_symbol_hashed_expandable (struct dictionary
*dict
,
699 int nsyms
= ++DICT_HASHED_EXPANDABLE_NSYMS (dict
);
701 if (DICT_HASHTABLE_SIZE (nsyms
) > DICT_HASHED_NBUCKETS (dict
))
702 expand_hashtable (dict
);
704 insert_symbol_hashed (dict
, sym
);
705 DICT_HASHED_EXPANDABLE_NSYMS (dict
) = nsyms
;
709 size_hashed_expandable (const struct dictionary
*dict
)
711 return DICT_HASHED_EXPANDABLE_NSYMS (dict
);
715 expand_hashtable (struct dictionary
*dict
)
717 int old_nbuckets
= DICT_HASHED_NBUCKETS (dict
);
718 struct symbol
**old_buckets
= DICT_HASHED_BUCKETS (dict
);
719 int new_nbuckets
= 2*old_nbuckets
+ 1;
720 struct symbol
**new_buckets
= xcalloc (new_nbuckets
,
721 sizeof (struct symbol
*));
724 DICT_HASHED_NBUCKETS (dict
) = new_nbuckets
;
725 DICT_HASHED_BUCKETS (dict
) = new_buckets
;
727 for (i
= 0; i
< old_nbuckets
; ++i
)
729 struct symbol
*sym
, *next_sym
;
731 sym
= old_buckets
[i
];
734 for (next_sym
= sym
->hash_next
;
736 next_sym
= sym
->hash_next
)
738 insert_symbol_hashed (dict
, sym
);
742 insert_symbol_hashed (dict
, sym
);
749 /* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE. */
751 static struct symbol
*
752 iterator_first_linear (const struct dictionary
*dict
,
753 struct dict_iterator
*iterator
)
755 DICT_ITERATOR_DICT (iterator
) = dict
;
756 DICT_ITERATOR_INDEX (iterator
) = 0;
757 return DICT_LINEAR_NSYMS (dict
) ? DICT_LINEAR_SYM (dict
, 0) : NULL
;
760 static struct symbol
*
761 iterator_next_linear (struct dict_iterator
*iterator
)
763 const struct dictionary
*dict
= DICT_ITERATOR_DICT (iterator
);
765 if (++DICT_ITERATOR_INDEX (iterator
) >= DICT_LINEAR_NSYMS (dict
))
768 return DICT_LINEAR_SYM (dict
, DICT_ITERATOR_INDEX (iterator
));
771 static struct symbol
*
772 iter_name_first_linear (const struct dictionary
*dict
,
774 struct dict_iterator
*iterator
)
776 DICT_ITERATOR_DICT (iterator
) = dict
;
777 DICT_ITERATOR_INDEX (iterator
) = -1;
779 return iter_name_next_linear (name
, iterator
);
782 static struct symbol
*
783 iter_name_next_linear (const char *name
, struct dict_iterator
*iterator
)
785 const struct dictionary
*dict
= DICT_ITERATOR_DICT (iterator
);
786 int i
, nsyms
= DICT_LINEAR_NSYMS (dict
);
787 struct symbol
*sym
, *retval
= NULL
;
789 for (i
= DICT_ITERATOR_INDEX (iterator
) + 1; i
< nsyms
; ++i
)
791 sym
= DICT_LINEAR_SYM (dict
, i
);
792 if (strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
799 DICT_ITERATOR_INDEX (iterator
) = i
;
805 size_linear (const struct dictionary
*dict
)
807 return DICT_LINEAR_NSYMS (dict
);
810 /* Functions only for DICT_LINEAR_EXPANDABLE. */
813 free_linear_expandable (struct dictionary
*dict
)
815 xfree (DICT_LINEAR_SYMS (dict
));
821 add_symbol_linear_expandable (struct dictionary
*dict
,
824 int nsyms
= ++DICT_LINEAR_NSYMS (dict
);
826 /* Do we have enough room? If not, grow it. */
827 if (nsyms
> DICT_LINEAR_EXPANDABLE_CAPACITY (dict
))
829 DICT_LINEAR_EXPANDABLE_CAPACITY (dict
) *= 2;
830 DICT_LINEAR_SYMS (dict
)
831 = xrealloc (DICT_LINEAR_SYMS (dict
),
832 DICT_LINEAR_EXPANDABLE_CAPACITY (dict
)
833 * sizeof (struct symbol
*));
836 DICT_LINEAR_SYM (dict
, nsyms
- 1) = sym
;