gdb/observer.c

   1 /* GDB Notifications to Observers.
   2    Copyright 2003 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* An observer is an entity who is interested in being notified when GDB
  22    reaches certain states, or certain events occur in GDB. The entity being
  23    observed is called the Subject. To receive notifications, the observer
  24    attaches a callback to the subject. One subject can have several
  25    observers.
  26
  27    This file implements an internal generic low-level event notification
  28    mechanism based on the Observer paradigm described in the book "Design
  29    Patterns".  This generic event notification mechansim is then re-used
  30    to implement the exported high-level notification management routines
  31    for all possible notifications.
  32
  33    The current implementation of the generic observer provides support
  34    for contextual data. This contextual data is given to the subject
  35    when attaching the callback. In return, the subject will provide
  36    this contextual data back to the observer as a parameter of the
  37    callback.
  38
  39    FIXME: The current support for the contextual data is only partial,
  40    as it lacks a mechanism that would deallocate this data when the
  41    callback is detached. This is not a problem so far, as this contextual
  42    data is only used internally to hold a function pointer. Later on,
  43    if a certain observer needs to provide support for user-level
  44    contextual data, then the generic notification mechanism will need
  45    need to be enhanced to allow the observer to provide a routine to
  46    deallocate the data when attaching the callback.
  47
  48    This file is currently maintained by hand, but the long term plan
  49    if the number of different notifications starts growing is to create
  50    a new script (observer.sh) that would generate this file, and the
  51    associated documentation.  */
  52
  53 #include "defs.h"
  54 #include "observer.h"
  55
  56 /* The internal generic observer.  */
  57
  58 typedef void (generic_observer_notification_ftype) (const void *data,
  59                                                     const void *args);
  60
  61 struct observer
  62 {
  63   generic_observer_notification_ftype *notify;
  64   /* No memory management needed for the following field for now.  */
  65   void *data;
  66 };
  67
  68 /* A list of observers, maintained by the subject.  A subject is
  69    actually represented by its list of observers.  */
  70
  71 struct observer_list
  72 {
  73   struct observer_list *next;
  74   struct observer *observer;
  75 };
  76
  77 /* Allocate a struct observer_list, intended to be used as a node
  78    in the list of observers maintained by a subject.  */
  79
  80 static struct observer_list *
  81 xalloc_observer_list_node (void)
  82 {
  83   struct observer_list *node = XMALLOC (struct observer_list);
  84   node->observer = XMALLOC (struct observer);
  85   return node;
  86 }
  87
  88 /* The opposite of xalloc_observer_list_node, frees the memory for
  89    the given node.  */
  90
  91 static void
  92 xfree_observer_list_node (struct observer_list *node)
  93 {
  94   xfree (node->observer);
  95   xfree (node);
  96 }
  97
  98 /* Attach the callback NOTIFY to a subject represented by its list
  99    of observers LIST.  The DATA is also stored, in order for the subject
 100    to provide it back to the observer during a notification.  */
 101
 102 static struct observer *
 103 generic_observer_attach (struct observer_list **subject,
 104                          generic_observer_notification_ftype * notify,
 105                          void *data)
 106 {
 107   struct observer_list *observer_list = xalloc_observer_list_node ();
 108
 109   observer_list->next = *subject;
 110   observer_list->observer->notify = notify;
 111   observer_list->observer->data = data;
 112   *subject = observer_list;
 113
 114   return observer_list->observer;
 115 }
 116
 117 /* Remove the given OBSERVER from the list of observers that need
 118    to be notified by the subject represented by its LIST of observers.
 119    Once detached, OBSERVER should no longer be used, as it is no longer
 120    valid.  */
 121 static void
 122 generic_observer_detach (struct observer_list **subject,
 123                          const struct observer *observer)
 124 {
 125   struct observer_list *previous_node = NULL;
 126   struct observer_list *current_node = *subject;
 127
 128   while (current_node != NULL)
 129     {
 130       if (current_node->observer == observer)
 131         {
 132           if (previous_node != NULL)
 133             previous_node->next = current_node->next;
 134           else
 135             *subject = current_node->next;
 136           xfree_observer_list_node (current_node);
 137           return;
 138         }
 139       previous_node = current_node;
 140       current_node = current_node->next;
 141     }
 142
 143   /* We should never reach this point.  However, this should not be
 144      a very serious error, so simply report a warning to the user.  */
 145   warning ("Failed to detach observer");
 146 }
 147
 148 /* Send a notification to all the observers of a subject represented by
 149    its LIST of observers.  ARGS is passed to all observers as an argument
 150    to the notification callback.  */
 151
 152 static void
 153 generic_observer_notify (struct observer_list *subject, const void *args)
 154 {
 155   struct observer_list *current_node = subject;
 156
 157   while (current_node != NULL)
 158     {
 159       (*current_node->observer->notify) (current_node->observer->data, args);
 160       current_node = current_node->next;
 161     }
 162 }
 163
 164 /* normal_stop notifications.  */
 165
 166 static struct observer_list *normal_stop_subject = NULL;
 167
 168 static void
 169 observer_normal_stop_notification_stub (const void *data,
 170                                         const void *unused_args)
 171 {
 172   observer_normal_stop_ftype *notify = (observer_normal_stop_ftype *) data;
 173   (*notify) ();
 174 }
 175
 176 struct observer *
 177 observer_attach_normal_stop (observer_normal_stop_ftype *f)
 178 {
 179   return generic_observer_attach (&normal_stop_subject,
 180                                   &observer_normal_stop_notification_stub,
 181                                   (void *) f);
 182 }
 183
 184 void
 185 observer_detach_normal_stop (struct observer *observer)
 186 {
 187   generic_observer_detach (&normal_stop_subject, observer);
 188 }
 189
 190 void
 191 observer_notify_normal_stop (void)
 192 {
 193   generic_observer_notify (normal_stop_subject, NULL);
 194 }