gdb/guile/scm-iterator.c

   1 /* Simple iterators for GDB/Scheme.
   2
   3    Copyright (C) 2014-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* See README file in this directory for implementation notes, coding
  21    conventions, et.al.  */
  22
  23 /* These are *simple* iterators, used to implement iterating over a collection
  24    of objects.  They are implemented as a smob containing three objects:
  25
  26    1) the object being iterated over,
  27    2) an object to record the progress of the iteration,
  28    3) a procedure of one argument (the iterator object) that returns the next
  29       object in the iteration or a pre-determined end marker.
  30
  31    Simple example:
  32
  33    (define-public (make-list-iterator l end-marker)
  34      "Return a <gdb:iterator> object for a list."
  35      (let ((next! (lambda (iter)
  36                     (let ((l (iterator-progress iter)))
  37                       (if (eq? l '())
  38                           end-marker
  39                           (begin
  40                             (set-iterator-progress! iter (cdr l))
  41                             (car l)))))))
  42        (make-iterator l l next!)))
  43
  44    (define l '(1 2))
  45    (define i (make-list-iterator l #:eoi))
  46    (iterator-next! i) -> 1
  47    (iterator-next! i) -> 2
  48    (iterator-next! i) -> #:eoi
  49
  50    There is SRFI 41, Streams.  We might support that too eventually (not with
  51    this interface of course).  */
  52
  53 #include "guile-internal.h"
  54
  55 /* A smob for iterating over something.
  56    Typically this is used when computing a list of everything is
  57    too expensive.  */
  58
  59 struct iterator_smob
  60 {
  61   /* This always appears first.  */
  62   gdb_smob base;
  63
  64   /* The object being iterated over.  */
  65   SCM object;
  66
  67   /* An arbitrary object describing the progress of the iteration.
  68      This is used by next_x to track progress.  */
  69   SCM progress;
  70
  71   /* A procedure of one argument, the iterator.
  72      It returns the next object in the iteration.
  73      How to signal "end of iteration" is up to next_x.  */
  74   SCM next_x;
  75 };
  76
  77 static const char iterator_smob_name[] = "gdb:iterator";
  78
  79 /* The tag Guile knows the iterator smob by.  */
  80 static scm_t_bits iterator_smob_tag;
  81
  82 /* A unique-enough marker to denote "end of iteration".  */
  83 static SCM end_of_iteration;
  84
  85 const char *
  86 itscm_iterator_smob_name (void)
  87 {
  88   return iterator_smob_name;
  89 }
  90
  91 SCM
  92 itscm_iterator_smob_object (iterator_smob *i_smob)
  93 {
  94   return i_smob->object;
  95 }
  96
  97 SCM
  98 itscm_iterator_smob_progress (iterator_smob *i_smob)
  99 {
 100   return i_smob->progress;
 101 }
 102
 103 void
 104 itscm_set_iterator_smob_progress_x (iterator_smob *i_smob, SCM progress)
 105 {
 106   i_smob->progress = progress;
 107 }
 108 \f
 109 /* Administrivia for iterator smobs.  */
 110
 111 /* The smob "print" function for <gdb:iterator>.  */
 112
 113 static int
 114 itscm_print_iterator_smob (SCM self, SCM port, scm_print_state *pstate)
 115 {
 116   iterator_smob *i_smob = (iterator_smob *) SCM_SMOB_DATA (self);
 117
 118   gdbscm_printf (port, "#<%s ", iterator_smob_name);
 119   scm_write (i_smob->object, port);
 120   scm_puts (" ", port);
 121   scm_write (i_smob->progress, port);
 122   scm_puts (" ", port);
 123   scm_write (i_smob->next_x, port);
 124   scm_puts (">", port);
 125
 126   scm_remember_upto_here_1 (self);
 127
 128   /* Non-zero means success.  */
 129   return 1;
 130 }
 131
 132 /* Low level routine to make a <gdb:iterator> object.
 133    Caller must verify correctness of arguments.
 134    No exceptions are thrown.  */
 135
 136 static SCM
 137 itscm_make_iterator_smob (SCM object, SCM progress, SCM next)
 138 {
 139   iterator_smob *i_smob = (iterator_smob *)
 140     scm_gc_malloc (sizeof (iterator_smob), iterator_smob_name);
 141   SCM i_scm;
 142
 143   i_smob->object = object;
 144   i_smob->progress = progress;
 145   i_smob->next_x = next;
 146   i_scm = scm_new_smob (iterator_smob_tag, (scm_t_bits) i_smob);
 147   gdbscm_init_gsmob (&i_smob->base);
 148
 149   return i_scm;
 150 }
 151
 152 /* (make-iterator object object procedure) -> <gdb:iterator> */
 153
 154 SCM
 155 gdbscm_make_iterator (SCM object, SCM progress, SCM next)
 156 {
 157   SCM i_scm;
 158
 159   SCM_ASSERT_TYPE (gdbscm_is_procedure (next), next, SCM_ARG3, FUNC_NAME,
 160                    _("procedure"));
 161
 162   i_scm = itscm_make_iterator_smob (object, progress, next);
 163
 164   return i_scm;
 165 }
 166
 167 /* Return non-zero if SCM is a <gdb:iterator> object.  */
 168
 169 int
 170 itscm_is_iterator (SCM scm)
 171 {
 172   return SCM_SMOB_PREDICATE (iterator_smob_tag, scm);
 173 }
 174
 175 /* (iterator? object) -> boolean */
 176
 177 static SCM
 178 gdbscm_iterator_p (SCM scm)
 179 {
 180   return scm_from_bool (itscm_is_iterator (scm));
 181 }
 182
 183 /* (end-of-iteration) -> an "end-of-iteration" marker
 184    We rely on this not being used as a data result of an iterator.  */
 185
 186 SCM
 187 gdbscm_end_of_iteration (void)
 188 {
 189   return end_of_iteration;
 190 }
 191
 192 /* Return non-zero if OBJ is the end-of-iteration marker.  */
 193
 194 int
 195 itscm_is_end_of_iteration (SCM obj)
 196 {
 197   return scm_is_eq (obj, end_of_iteration);
 198 }
 199
 200 /* (end-of-iteration? obj) -> boolean */
 201
 202 static SCM
 203 gdbscm_end_of_iteration_p (SCM obj)
 204 {
 205   return scm_from_bool (itscm_is_end_of_iteration (obj));
 206 }
 207
 208 /* Call the next! method on ITER, which must be a <gdb:iterator> object.
 209    Returns a <gdb:exception> object if an exception is thrown.
 210    OK_EXCPS is passed to gdbscm_safe_call_1.  */
 211
 212 SCM
 213 itscm_safe_call_next_x (SCM iter, excp_matcher_func *ok_excps)
 214 {
 215   iterator_smob *i_smob;
 216
 217   gdb_assert (itscm_is_iterator (iter));
 218
 219   i_smob = (iterator_smob *) SCM_SMOB_DATA (iter);
 220   return gdbscm_safe_call_1 (i_smob->next_x, iter, ok_excps);
 221 }
 222 \f
 223 /* Iterator methods.  */
 224
 225 /* Returns the <gdb:iterator> smob in SELF.
 226    Throws an exception if SELF is not an iterator smob.  */
 227
 228 SCM
 229 itscm_get_iterator_arg_unsafe (SCM self, int arg_pos, const char *func_name)
 230 {
 231   SCM_ASSERT_TYPE (itscm_is_iterator (self), self, arg_pos, func_name,
 232                    iterator_smob_name);
 233
 234   return self;
 235 }
 236
 237 /* (iterator-object <gdb:iterator>) -> object */
 238
 239 static SCM
 240 gdbscm_iterator_object (SCM self)
 241 {
 242   SCM i_scm;
 243   iterator_smob *i_smob;
 244
 245   i_scm = itscm_get_iterator_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 246   i_smob = (iterator_smob *) SCM_SMOB_DATA (i_scm);
 247
 248   return i_smob->object;
 249 }
 250
 251 /* (iterator-progress <gdb:iterator>) -> object */
 252
 253 static SCM
 254 gdbscm_iterator_progress (SCM self)
 255 {
 256   SCM i_scm;
 257   iterator_smob *i_smob;
 258
 259   i_scm = itscm_get_iterator_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 260   i_smob = (iterator_smob *) SCM_SMOB_DATA (i_scm);
 261
 262   return i_smob->progress;
 263 }
 264
 265 /* (set-iterator-progress! <gdb:iterator> object) -> unspecified */
 266
 267 static SCM
 268 gdbscm_set_iterator_progress_x (SCM self, SCM value)
 269 {
 270   SCM i_scm;
 271   iterator_smob *i_smob;
 272
 273   i_scm = itscm_get_iterator_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 274   i_smob = (iterator_smob *) SCM_SMOB_DATA (i_scm);
 275
 276   i_smob->progress = value;
 277   return SCM_UNSPECIFIED;
 278 }
 279
 280 /* (iterator-next! <gdb:iterator>) -> object
 281    The result is the next value in the iteration or some "end" marker.
 282    It is up to each iterator's next! function to specify what its end
 283    marker is.  */
 284
 285 static SCM
 286 gdbscm_iterator_next_x (SCM self)
 287 {
 288   SCM i_scm;
 289   iterator_smob *i_smob;
 290
 291   i_scm = itscm_get_iterator_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 292   i_smob = (iterator_smob *) SCM_SMOB_DATA (i_scm);
 293   /* We leave type-checking of the procedure to gdbscm_safe_call_1.  */
 294
 295   return gdbscm_safe_call_1 (i_smob->next_x, self, NULL);
 296 }
 297 \f
 298 /* Initialize the Scheme iterator code.  */
 299
 300 static const scheme_function iterator_functions[] =
 301 {
 302   { "make-iterator", 3, 0, 0, as_a_scm_t_subr (gdbscm_make_iterator),
 303     "\
 304 Create a <gdb:iterator> object.\n\
 305 \n\
 306   Arguments: object progress next!\n\
 307     object:   The object to iterate over.\n\
 308     progress: An object to use to track progress of the iteration.\n\
 309     next!:    A procedure of one argument, the iterator.\n\
 310       Returns the next element in the iteration or an implementation-chosen\n\
 311       value to signify iteration is complete.\n\
 312       By convention end-of-iteration should be marked with (end-of-iteration)\n\
 313       from module (gdb iterator)." },
 314
 315   { "iterator?", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_p),
 316     "\
 317 Return #t if the object is a <gdb:iterator> object." },
 318
 319   { "iterator-object", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_object),
 320     "\
 321 Return the object being iterated over." },
 322
 323   { "iterator-progress", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_progress),
 324     "\
 325 Return the progress object of the iterator." },
 326
 327   { "set-iterator-progress!", 2, 0, 0,
 328     as_a_scm_t_subr (gdbscm_set_iterator_progress_x),
 329     "\
 330 Set the progress object of the iterator." },
 331
 332   { "iterator-next!", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_next_x),
 333     "\
 334 Invoke the next! procedure of the iterator and return its result." },
 335
 336   { "end-of-iteration", 0, 0, 0, as_a_scm_t_subr (gdbscm_end_of_iteration),
 337     "\
 338 Return the end-of-iteration marker." },
 339
 340   { "end-of-iteration?", 1, 0, 0, as_a_scm_t_subr (gdbscm_end_of_iteration_p),
 341     "\
 342 Return #t if the object is the end-of-iteration marker." },
 343
 344   END_FUNCTIONS
 345 };
 346
 347 void
 348 gdbscm_initialize_iterators (void)
 349 {
 350   iterator_smob_tag = gdbscm_make_smob_type (iterator_smob_name,
 351                                              sizeof (iterator_smob));
 352   scm_set_smob_print (iterator_smob_tag, itscm_print_iterator_smob);
 353
 354   gdbscm_define_functions (iterator_functions, 1);
 355
 356   /* We can make this more unique if it's necessary,
 357      but this is good enough for now.  */
 358   end_of_iteration = scm_from_latin1_keyword ("end-of-iteration");
 359 }