[deliverable/binutils-gdb.git] / gdb / dictionary.h

/* Routines for name->symbol lookups in GDB.
   
   Copyright (C) 2003-2017 Free Software Foundation, Inc.

   Contributed by David Carlton <carlton@bactrian.org> and by Kealia,
   Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef DICTIONARY_H
#define DICTIONARY_H

#include "symfile.h"

/* An opaque type for dictionaries; only dictionary.c should know
   about its innards.  */

struct dictionary;

/* Other types needed for declarations.  */

struct symbol;
struct obstack;
struct pending;


/* The creation functions for various implementations of
   dictionaries.  */

/* Create a dictionary implemented via a fixed-size hashtable.  All
   memory it uses is allocated on OBSTACK; the environment is
   initialized from SYMBOL_LIST.  */

extern struct dictionary *dict_create_hashed (struct obstack *obstack,
					      const struct pending
					      *symbol_list);

/* Create a dictionary implemented via a hashtable that grows as
   necessary.  The dictionary is initially empty; to add symbols to
   it, call dict_add_symbol().  Call dict_free() when you're done with
   it.  */

extern struct dictionary *dict_create_hashed_expandable (void);

/* Create a dictionary implemented via a fixed-size array.  All memory
   it uses is allocated on OBSTACK; the environment is initialized
   from the SYMBOL_LIST.  The symbols are ordered in the same order
   that they're found in SYMBOL_LIST.  */

extern struct dictionary *dict_create_linear (struct obstack *obstack,
					      const struct pending
					      *symbol_list);

/* Create a dictionary implemented via an array that grows as
   necessary.  The dictionary is initially empty; to add symbols to
   it, call dict_add_symbol().  Call dict_free() when you're done with
   it.  */

extern struct dictionary *dict_create_linear_expandable (void);


/* The functions providing the interface to dictionaries.  Note that
   the most common parts of the interface, namely symbol lookup, are
   only provided via iterator functions.  */

/* Free the memory used by a dictionary that's not on an obstack.  (If
   any.)  */

extern void dict_free (struct dictionary *dict);

/* Add a symbol to an expandable dictionary.  */

extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym);

/* Utility to add a list of symbols to a dictionary.  */

extern void dict_add_pending (struct dictionary *dict,
			      const struct pending *symbol_list);

/* Is the dictionary empty?  */

extern int dict_empty (struct dictionary *dict);

/* A type containing data that is used when iterating over all symbols
   in a dictionary.  Don't ever look at its innards; this type would
   be opaque if we didn't need to be able to allocate it on the
   stack.  */

struct dict_iterator
{
  /* The dictionary that this iterator is associated to.  */
  const struct dictionary *dict;
  /* The next two members are data that is used in a way that depends
     on DICT's implementation type.  */
  int index;
  struct symbol *current;
};

/* Initialize ITERATOR to point at the first symbol in DICT, and
   return that first symbol, or NULL if DICT is empty.  */

extern struct symbol *dict_iterator_first (const struct dictionary *dict,
					   struct dict_iterator *iterator);

/* Advance ITERATOR, and return the next symbol, or NULL if there are
   no more symbols.  Don't call this if you've previously received
   NULL from dict_iterator_first or dict_iterator_next on this
   iteration.  */

extern struct symbol *dict_iterator_next (struct dict_iterator *iterator);

/* Initialize ITERATOR to point at the first symbol in DICT whose
   SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use
   the same conventions as strcmp_iw and be compatible with any
   dictionary hashing function), and return that first symbol, or NULL
   if there are no such symbols.  */

extern struct symbol *dict_iter_match_first (const struct dictionary *dict,
					     const char *name,
					     symbol_compare_ftype *compare,
					     struct dict_iterator *iterator);

/* Advance ITERATOR to point at the next symbol in DICT whose
   SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see
   dict_iter_match_first), or NULL if there are no more such symbols.
   Don't call this if you've previously received NULL from 
   dict_iterator_match_first or dict_iterator_match_next on this
   iteration.  And don't call it unless ITERATOR was created by a
   previous call to dict_iter_match_first with the same NAME and COMPARE.  */

extern struct symbol *dict_iter_match_next (const char *name,
					    symbol_compare_ftype *compare,
					    struct dict_iterator *iterator);

/* Return some notion of the size of the dictionary: the number of
   symbols if we have that, the number of hash buckets otherwise.  */

extern int dict_size (const struct dictionary *dict);

/* Macro to loop through all symbols in a dictionary DICT, in no
   particular order.  ITER is a struct dict_iterator (NOTE: __not__ a
   struct dict_iterator *), and SYM points to the current symbol.

   It's implemented as a single loop, so you can terminate the loop
   early by a break if you desire.  */

#define ALL_DICT_SYMBOLS(dict, iter, sym)			\
	for ((sym) = dict_iterator_first ((dict), &(iter));	\
	     (sym);						\
	     (sym) = dict_iterator_next (&(iter)))

#endif /* DICTIONARY_H */
Commit	Line	Data
de4f826b DC	1	/* Routines for name->symbol lookups in GDB.
de4f826b DC	2
61baf725	3	Copyright (C) 2003-2017 Free Software Foundation, Inc.
de4f826b DC	4
	5	Contributed by David Carlton <carlton@bactrian.org> and by Kealia,
	6	Inc.
	7
	8	This file is part of GDB.
	9
	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
a9762ec7 JB	12	the Free Software Foundation; either version 3 of the License, or
a9762ec7 JB	13	(at your option) any later version.
de4f826b	14
a9762ec7 JB	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.
de4f826b DC	19
de4f826b DC	20	You should have received a copy of the GNU General Public License
a9762ec7	21	along with this program. If not, see <http://www.gnu.org/licenses/>. */
de4f826b DC	22
	23	#ifndef DICTIONARY_H
	24	#define DICTIONARY_H
	25
2edb89d3 JK	26	#include "symfile.h"
2edb89d3 JK	27
de4f826b DC	28	/* An opaque type for dictionaries; only dictionary.c should know
	29	about its innards. */
	30
	31	struct dictionary;
	32
	33	/* Other types needed for declarations. */
	34
	35	struct symbol;
	36	struct obstack;
	37	struct pending;
	38
	39
	40	/* The creation functions for various implementations of
	41	dictionaries. */
	42
	43	/* Create a dictionary implemented via a fixed-size hashtable. All
	44	memory it uses is allocated on OBSTACK; the environment is
	45	initialized from SYMBOL_LIST. */
	46
	47	extern struct dictionary dict_create_hashed (struct obstack obstack,
	48	const struct pending
	49	*symbol_list);
	50
	51	/* Create a dictionary implemented via a hashtable that grows as
	52	necessary. The dictionary is initially empty; to add symbols to
	53	it, call dict_add_symbol(). Call dict_free() when you're done with
	54	it. */
	55
	56	extern struct dictionary *dict_create_hashed_expandable (void);
	57
	58	/* Create a dictionary implemented via a fixed-size array. All memory
	59	it uses is allocated on OBSTACK; the environment is initialized
	60	from the SYMBOL_LIST. The symbols are ordered in the same order
	61	that they're found in SYMBOL_LIST. */
	62
	63	extern struct dictionary dict_create_linear (struct obstack obstack,
	64	const struct pending
	65	*symbol_list);
	66
	67	/* Create a dictionary implemented via an array that grows as
	68	necessary. The dictionary is initially empty; to add symbols to
	69	it, call dict_add_symbol(). Call dict_free() when you're done with
	70	it. */
	71
	72	extern struct dictionary *dict_create_linear_expandable (void);
	73
	74
	75	/* The functions providing the interface to dictionaries. Note that
	76	the most common parts of the interface, namely symbol lookup, are
	77	only provided via iterator functions. */
	78
	79	/* Free the memory used by a dictionary that's not on an obstack. (If
	80	any.) */
	81
	82	extern void dict_free (struct dictionary *dict);
	83
	84	/* Add a symbol to an expandable dictionary. */
	85
	86	extern void dict_add_symbol (struct dictionary dict, struct symbol sym);
	87
0bfa869d DE	88	/* Utility to add a list of symbols to a dictionary. */
	89
	90	extern void dict_add_pending (struct dictionary *dict,
	91	const struct pending *symbol_list);
	92
de4f826b DC	93	/* Is the dictionary empty? */
	94
	95	extern int dict_empty (struct dictionary *dict);
	96
	97	/* A type containing data that is used when iterating over all symbols
	98	in a dictionary. Don't ever look at its innards; this type would
	99	be opaque if we didn't need to be able to allocate it on the
	100	stack. */
	101
	102	struct dict_iterator
	103	{
	104	/* The dictionary that this iterator is associated to. */
	105	const struct dictionary *dict;
	106	/* The next two members are data that is used in a way that depends
	107	on DICT's implementation type. */
	108	int index;
	109	struct symbol *current;
	110	};
	111
	112	/* Initialize ITERATOR to point at the first symbol in DICT, and
	113	return that first symbol, or NULL if DICT is empty. */
	114
	115	extern struct symbol dict_iterator_first (const struct dictionary dict,
	116	struct dict_iterator *iterator);
	117
	118	/* Advance ITERATOR, and return the next symbol, or NULL if there are
	119	no more symbols. Don't call this if you've previously received
	120	NULL from dict_iterator_first or dict_iterator_next on this
	121	iteration. */
	122
	123	extern struct symbol dict_iterator_next (struct dict_iterator iterator);
	124
c4d840bd PH	125	/* Initialize ITERATOR to point at the first symbol in DICT whose
	126	SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use
	127	the same conventions as strcmp_iw and be compatible with any
	128	dictionary hashing function), and return that first symbol, or NULL
	129	if there are no such symbols. */
	130
	131	extern struct symbol dict_iter_match_first (const struct dictionary dict,
	132	const char *name,
2edb89d3	133	symbol_compare_ftype *compare,
c4d840bd PH	134	struct dict_iterator *iterator);
	135
	136	/* Advance ITERATOR to point at the next symbol in DICT whose
	137	SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see
	138	dict_iter_match_first), or NULL if there are no more such symbols.
	139	Don't call this if you've previously received NULL from
	140	dict_iterator_match_first or dict_iterator_match_next on this
0963b4bd	141	iteration. And don't call it unless ITERATOR was created by a
c4d840bd PH	142	previous call to dict_iter_match_first with the same NAME and COMPARE. */
	143
	144	extern struct symbol dict_iter_match_next (const char name,
2edb89d3	145	symbol_compare_ftype *compare,
c4d840bd PH	146	struct dict_iterator *iterator);
c4d840bd PH	147
de4f826b DC	148	/* Return some notion of the size of the dictionary: the number of
	149	symbols if we have that, the number of hash buckets otherwise. */
	150
	151	extern int dict_size (const struct dictionary *dict);
	152
	153	/* Macro to loop through all symbols in a dictionary DICT, in no
	154	particular order. ITER is a struct dict_iterator (NOTE: __not__ a
	155	struct dict_iterator *), and SYM points to the current symbol.
	156
	157	It's implemented as a single loop, so you can terminate the loop
	158	early by a break if you desire. */
	159
	160	#define ALL_DICT_SYMBOLS(dict, iter, sym) \
	161	for ((sym) = dict_iterator_first ((dict), &(iter)); \
	162	(sym); \
	163	(sym) = dict_iterator_next (&(iter)))
	164
	165	#endif /* DICTIONARY_H */