I was always a bit confused by next_adapter, because it kind of mixes
the element type and the iterator type. In reality, it is not much more
than a class that wraps two iterators (begin and end). However, it
assumes that:
- you can construct the begin iterator by passing a pointer to the
first element of the iterable
- you can default-construct iterator to make the end iterator
I think that by generalizing it a little bit, we can re-use it at more
places.
Rename it to "iterator_range". I think it describes a bit better: it's
a range made by wrapping a begin and end iterator. Move it to its own
file, since it's not related to next_iterator anymore.
iterator_range has two constructors. The variadic one, where arguments
are forwarded to construct the underlying begin iterator. The end
iterator is constructed through default construction. This is a
generalization of what we have today.
There is another constructor which receives already constructed begin
and end iterators, useful if the end iterator can't be obtained by
default-construction. Or, if you wanted to make a range that does not
end at the end of the container, you could pass any iterator as the
"end".
This generalization allows removing some "range" classes, like
all_inferiors_range. These classes existed only to pass some arguments
when constructing the begin iterator. With iterator_range, those same
arguments are passed to the iterator_range constructed and then
forwarded to the constructed begin iterator.
There is a small functional difference in how iterator_range works
compared to next_adapter. next_adapter stored the pointer it received
as argument and constructeur an iterator in the `begin` method.
iterator_range constructs the begin iterator and stores it as a member.
Its `begin` method returns a copy of that iterator.
With just iterator_range, uses of next_adapter<foo> would be replaced
with:
using foo_iterator = next_iterator<foo>;
using foo_range = iterator_range<foo_iterator>;
However, I added a `next_range` wrapper as a direct replacement for
next_adapter<foo>. IMO, next_range is a slightly better name than
next_adapter.
The rest of the changes are applications of this new class.
gdbsupport/ChangeLog:
* next-iterator.h (class next_adapter): Remove.
* iterator-range.h: New.
gdb/ChangeLog:
* breakpoint.h (bp_locations_range): Remove.
(bp_location_range): New.
(struct breakpoint) <locations>: Adjust type.
(breakpoint_range): Use iterator_range.
(tracepoint_range): Use iterator_range.
* breakpoint.c (breakpoint::locations): Adjust return type.
* gdb_bfd.h (gdb_bfd_section_range): Use iterator_range.
* gdbthread.h (all_threads_safe): Pass argument to
all_threads_safe_range.
* inferior-iter.h (all_inferiors_range): Use iterator_range.
(all_inferiors_safe_range): Use iterator_range.
(all_non_exited_inferiors_range): Use iterator_range.
* inferior.h (all_inferiors, all_non_exited_inferiors): Pass
inferior_list as argument.
* objfiles.h (struct objfile) <compunits_range>: Remove.
<compunits>: Return compunit_symtab_range.
* progspace.h (unwrapping_objfile_iterator)
<unwrapping_objfile_iterator>: Take parameter by value.
(unwrapping_objfile_range): Use iterator_range.
(struct program_space) <objfiles_range>: Define with "using".
<objfiles>: Adjust.
<objfiles_safe_range>: Define with "using".
<objfiles_safe>: Adjust.
<solibs>: Return so_list_range, define here.
* progspace.c (program_space::solibs): Remove.
* psymtab.h (class psymtab_storage) <partial_symtab_iterator>:
New.
<partial_symtab_range>: Use iterator_range.
* solist.h (so_list_range): New.
* symtab.h (compunit_symtab_range):
New.
(symtab_range): New.
(compunit_filetabs): Change to a function.
* thread-iter.h (inf_threads_range,
inf_non_exited_threads_range, safe_inf_threads_range,
all_threads_safe_range): Use iterator_range.
* top.h (ui_range): New.
(all_uis): Use ui_range.
Change-Id: Ib7a9d2a3547f45f01aa1c6b24536ba159db9b854
/* See breakpoint.h. */
-bp_locations_range breakpoint::locations ()
+bp_location_range breakpoint::locations ()
{
- return bp_locations_range (this->loc);
+ return bp_location_range (this->loc);
}
static struct bp_location *
#include "gdbsupport/array-view.h"
#include "gdbsupport/filtered-iterator.h"
#include "gdbsupport/function-view.h"
+#include "gdbsupport/next-iterator.h"
+#include "gdbsupport/iterator-range.h"
#include "gdbsupport/refcounted-object.h"
#include "gdbsupport/safe-iterator.h"
#include "cli/cli-script.h"
/* bp_location linked list range. */
-using bp_locations_range = next_adapter<bp_location>;
+using bp_location_range = next_range<bp_location>;
/* Note that the ->silent field is not currently used by any commands
(though the code is in there if it was to be, and set_raw_breakpoint
virtual ~breakpoint ();
/* Return a range of this breakpoint's locations. */
- bp_locations_range locations ();
+ bp_location_range locations ();
/* Methods associated with this breakpoint. */
const breakpoint_ops *ops = NULL;
/* Breakpoint linked list range. */
-using breakpoint_range = next_adapter<breakpoint, breakpoint_iterator>;
+using breakpoint_range = iterator_range<breakpoint_iterator>;
/* Return a range to iterate over all breakpoints. */
/* Breakpoint linked list range, filtering to only keep tracepoints. */
-using tracepoint_range = next_adapter<breakpoint, tracepoint_iterator>;
+using tracepoint_range = iterator_range<tracepoint_iterator>;
/* Return a range to iterate over all tracepoints. */
#include "registry.h"
#include "gdbsupport/byte-vector.h"
#include "gdbsupport/gdb_ref_ptr.h"
+#include "gdbsupport/iterator-range.h"
#include "gdbsupport/next-iterator.h"
DECLARE_REGISTRY (bfd);
... use SECT ...
*/
-using gdb_bfd_section_iterator = next_iterator<asection>;
-using gdb_bfd_section_range = next_adapter<asection, gdb_bfd_section_iterator>;
+using gdb_bfd_section_range = next_range<asection>;
static inline gdb_bfd_section_range
gdb_bfd_sections (bfd *abfd)
inline all_threads_safe_range
all_threads_safe ()
{
- return {};
+ return all_threads_safe_range (all_threads_iterator::begin_t {});
}
extern int thread_count (process_stratum_target *proc_target);
inferior *m_inf;
};
+/* A range adapter that makes it possible to iterate over all
+ inferiors with range-for. */
+
+using all_inferiors_range = iterator_range<all_inferiors_iterator>;
+
/* Filter for filtered_iterator. Filters out exited inferiors. */
struct exited_inferior_filter
= filtered_iterator<all_inferiors_iterator, exited_inferior_filter>;
/* A range adapter that makes it possible to iterate over all
- inferiors with range-for. */
-struct all_inferiors_range
-{
- all_inferiors_range (process_stratum_target *proc_target = nullptr)
- : m_filter_target (proc_target)
- {}
+ non-exited inferiors with range-for. */
- all_inferiors_iterator begin () const
- { return all_inferiors_iterator (m_filter_target, inferior_list); }
- all_inferiors_iterator end () const
- { return all_inferiors_iterator (); }
-
-private:
- process_stratum_target *m_filter_target;
-};
+using all_non_exited_inferiors_range
+ = iterator_range<all_non_exited_inferiors_iterator>;
/* Iterate over all inferiors, safely. */
inferiors with range-for "safely". I.e., it is safe to delete the
currently-iterated inferior. */
-struct all_inferiors_safe_range
-{
- explicit all_inferiors_safe_range (process_stratum_target *filter_target)
- : m_filter_target (filter_target)
- {}
-
- all_inferiors_safe_range ()
- : m_filter_target (nullptr)
- {}
-
- all_inferiors_safe_iterator begin () const
- {
- return (all_inferiors_safe_iterator
- (all_inferiors_iterator (m_filter_target, inferior_list)));
- }
-
- all_inferiors_safe_iterator end () const
- { return all_inferiors_safe_iterator (); }
-
-private:
- /* The filter. */
- process_stratum_target *m_filter_target;
-};
-
-/* A range adapter that makes it possible to iterate over all
- non-exited inferiors with range-for. */
-
-struct all_non_exited_inferiors_range
-{
- explicit all_non_exited_inferiors_range (process_stratum_target *filter_target)
- : m_filter_target (filter_target)
- {}
-
- all_non_exited_inferiors_range ()
- : m_filter_target (nullptr)
- {}
-
- all_non_exited_inferiors_iterator begin () const
- { return all_non_exited_inferiors_iterator (m_filter_target, inferior_list); }
- all_non_exited_inferiors_iterator end () const
- { return all_non_exited_inferiors_iterator (); }
-
-private:
- /* The filter. */
- process_stratum_target *m_filter_target;
-};
+using all_inferiors_safe_range = iterator_range<all_inferiors_safe_iterator>;
#endif /* !defined (INFERIOR_ITER_H) */
inline all_inferiors_range
all_inferiors (process_stratum_target *proc_target = nullptr)
{
- return all_inferiors_range (proc_target);
+ return all_inferiors_range (proc_target, inferior_list);
}
/* Return a range that can be used to walk over all inferiors with PID
inline all_non_exited_inferiors_range
all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
{
- return all_non_exited_inferiors_range (proc_target);
+ return all_non_exited_inferiors_range (proc_target, inferior_list);
}
/* Prune away automatically added inferiors that aren't required
DISABLE_COPY_AND_ASSIGN (objfile);
- typedef next_adapter<struct compunit_symtab> compunits_range;
-
/* A range adapter that makes it possible to iterate over all
compunits in one objfile. */
- compunits_range compunits ()
+ compunit_symtab_range compunits ()
{
- return compunits_range (compunit_symtabs);
+ return compunit_symtab_range (compunit_symtabs);
}
/* A range adapter that makes it possible to iterate over all
/* See progspace.h. */
-next_adapter<struct so_list>
-program_space::solibs () const
-{
- return next_adapter<struct so_list> (this->so_list);
-}
-
-/* See progspace.h. */
-
void
program_space::exec_close ()
{
#include "gdb_bfd.h"
#include "gdbsupport/gdb_vecs.h"
#include "registry.h"
+#include "solist.h"
#include "gdbsupport/next-iterator.h"
#include "gdbsupport/safe-iterator.h"
#include <list>
typedef typename objfile_list::iterator::iterator_category iterator_category;
typedef typename objfile_list::iterator::difference_type difference_type;
- unwrapping_objfile_iterator (const objfile_list::iterator &iter)
- : m_iter (iter)
+ unwrapping_objfile_iterator (objfile_list::iterator iter)
+ : m_iter (std::move (iter))
{
}
/* A range that returns unwrapping_objfile_iterators. */
-struct unwrapping_objfile_range
-{
- typedef unwrapping_objfile_iterator iterator;
-
- unwrapping_objfile_range (objfile_list &ol)
- : m_list (ol)
- {
- }
-
- iterator begin () const
- {
- return iterator (m_list.begin ());
- }
-
- iterator end () const
- {
- return iterator (m_list.end ());
- }
-
-private:
-
- objfile_list &m_list;
-};
+using unwrapping_objfile_range = iterator_range<unwrapping_objfile_iterator>;
/* A program space represents a symbolic view of an address space.
Roughly speaking, it holds all the data associated with a
a program space. */
~program_space ();
- typedef unwrapping_objfile_range objfiles_range;
+ using objfiles_range = unwrapping_objfile_range;
/* Return an iterable object that can be used to iterate over all
objfiles. The basic use is in a foreach, like:
for (objfile *objf : pspace->objfiles ()) { ... } */
objfiles_range objfiles ()
{
- return unwrapping_objfile_range (objfiles_list);
+ return objfiles_range
+ (unwrapping_objfile_iterator (objfiles_list.begin ()),
+ unwrapping_objfile_iterator (objfiles_list.end ()));
}
- typedef basic_safe_range<objfiles_range> objfiles_safe_range;
+ using objfiles_safe_range = basic_safe_range<objfiles_range>;
/* An iterable object that can be used to iterate over all objfiles.
The basic use is in a foreach, like:
deleted during iteration. */
objfiles_safe_range objfiles_safe ()
{
- return objfiles_safe_range (objfiles_list);
+ return objfiles_safe_range
+ (objfiles_range
+ (unwrapping_objfile_iterator (objfiles_list.begin ()),
+ unwrapping_objfile_iterator (objfiles_list.end ())));
}
/* Add OBJFILE to the list of objfiles, putting it just before
program space. Use it like:
for (so_list *so : pspace->solibs ()) { ... } */
- next_adapter<struct so_list> solibs () const;
+ so_list_range solibs () const
+ { return so_list_range (this->so_list); }
/* Close and clear exec_bfd. If we end up with no target sections
to read memory from, this unpushes the exec_ops target. */
void install_psymtab (partial_symtab *pst);
- typedef next_adapter<struct partial_symtab> partial_symtab_range;
+ using partial_symtab_range = next_range<partial_symtab>;
/* A range adapter that makes it possible to iterate over all
psymtabs in one objfile. */
void (*handle_event) (void);
};
+using so_list_range = next_range<so_list>;
+
/* Free the memory associated with a (so_list *). */
void free_so (struct so_list *so);
#include "gdbsupport/gdb_optional.h"
#include "gdbsupport/gdb_string_view.h"
#include "gdbsupport/next-iterator.h"
+#include "gdbsupport/iterator-range.h"
#include "completer.h"
#include "gdb-demangle.h"
struct compunit_symtab *user;
};
+using compunit_symtab_range = next_range<compunit_symtab>;
+
#define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
#define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
#define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
/* A range adapter to allowing iterating over all the file tables
within a compunit. */
-struct compunit_filetabs : public next_adapter<struct symtab>
+using symtab_range = next_range<symtab>;
+
+static inline symtab_range
+compunit_filetabs (compunit_symtab *cu)
{
- compunit_filetabs (struct compunit_symtab *cu)
- : next_adapter<struct symtab> (cu->filetabs)
- {
- }
-};
+ return symtab_range (cu->filetabs);
+}
/* Return the primary symtab of CUST. */
/* A range adapter that makes it possible to iterate over all threads
of an inferior with range-for. */
-using inf_threads_range
- = next_adapter<thread_info, inf_threads_iterator>;
+using inf_threads_range = iterator_range<inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all
non-exited threads of an inferior with range-for. */
using inf_non_exited_threads_range
- = next_adapter<thread_info, inf_non_exited_threads_iterator>;
+ = iterator_range<inf_non_exited_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
of an inferior with range-for, safely. */
-using safe_inf_threads_range
- = next_adapter<thread_info, safe_inf_threads_iterator>;
-
-/* A range adapter that makes it possible to iterate over all threads
- of all inferiors with range-for. */
-
-struct all_threads_range
-{
- all_threads_iterator begin () const
- { return all_threads_iterator (all_threads_iterator::begin_t {}); }
- all_threads_iterator end () const
- { return all_threads_iterator (); }
-};
+using safe_inf_threads_range = iterator_range<safe_inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
with range-for "safely". I.e., it is safe to delete the
currently-iterated thread. */
-struct all_threads_safe_range
-{
- all_threads_safe_iterator begin () const
- { return all_threads_safe_iterator (all_threads_iterator::begin_t {}); }
- all_threads_safe_iterator end () const
- { return all_threads_safe_iterator (); }
-};
+using all_threads_safe_range = iterator_range<all_threads_safe_iterator>;
/* A range adapter that makes it possible to iterate over all threads
that match a PTID filter with range-for. */
#define SWITCH_THRU_ALL_UIS() \
for (switch_thru_all_uis stau_state; !stau_state.done (); stau_state.next ())
+using ui_range = next_range<ui>;
+
/* An adapter that can be used to traverse over all UIs. */
static inline
-next_adapter<ui> all_uis ()
+ui_range all_uis ()
{
- return next_adapter<ui> (ui_list);
+ return ui_range (ui_list);
}
/* Register the UI's input file descriptor in the event loop. */
--- /dev/null
+/* A range adapter that wraps begin / end iterators.
+ Copyright (C) 2021 Free Software Foundation, 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 GDBSUPPORT_ITERATOR_RANGE_H
+#define GDBSUPPORT_ITERATOR_RANGE_H
+
+/* A wrapper that allows using ranged for-loops on a range described by two
+ iterators. */
+
+template <typename IteratorType>
+struct iterator_range
+{
+ using iterator = IteratorType;
+
+ /* Create an iterator_range using BEGIN as the begin iterator.
+
+ Assume that the end iterator can be default-constructed. */
+ template <typename... Args>
+ iterator_range (Args &&...args)
+ : m_begin (std::forward<Args> (args)...)
+ {}
+
+ /* Create an iterator range using explicit BEGIN and END iterators. */
+ template <typename... Args>
+ iterator_range (IteratorType begin, IteratorType end)
+ : m_begin (std::move (begin)), m_end (std::move (end))
+ {}
+
+ /* Need these as the variadic constructor would be a better match
+ otherwise. */
+ iterator_range (iterator_range &) = default;
+ iterator_range (const iterator_range &) = default;
+ iterator_range (iterator_range &&) = default;
+
+ IteratorType begin () const
+ { return m_begin; }
+
+ IteratorType end () const
+ { return m_end; }
+
+private:
+ IteratorType m_begin, m_end;
+};
+
+#endif /* GDBSUPPORT_ITERATOR_RANGE_H */
#ifndef COMMON_NEXT_ITERATOR_H
#define COMMON_NEXT_ITERATOR_H
+#include "gdbsupport/iterator-range.h"
+
/* An iterator that uses the 'next' field of a type to iterate. This
can be used with various GDB types that are stored as linked
lists. */
T *m_item;
};
-/* A range adapter that allows iterating over a linked list. */
-
-template<typename T, typename Iterator = next_iterator<T>>
-class next_adapter
-{
-public:
-
- explicit next_adapter (T *item)
- : m_item (item)
- {
- }
-
- using iterator = Iterator;
-
- iterator begin () const
- {
- return iterator (m_item);
- }
-
- iterator end () const
- {
- return iterator ();
- }
+/* A convenience wrapper to make a range type around a next_iterator. */
-private:
-
- T *m_item;
-};
+template <typename T>
+using next_range = iterator_range<next_iterator<T>>;
#endif /* COMMON_NEXT_ITERATOR_H */
projects / binutils-gdb.git / commitdiff