From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17439 invoked by alias); 28 Feb 2003 07:38:33 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 17418 invoked from network); 28 Feb 2003 07:38:22 -0000 Received: from unknown (HELO takamaka.act-europe.fr) (142.179.108.108) by 172.16.49.205 with SMTP; 28 Feb 2003 07:38:22 -0000 Received: by takamaka.act-europe.fr (Postfix, from userid 507) id 69D0BD34B7; Thu, 27 Feb 2003 23:22:43 -0800 (PST) Date: Fri, 28 Feb 2003 07:38:00 -0000 From: Joel Brobecker To: gdb-patches@sources.redhat.com Subject: [commit] new observer.[hc] files Message-ID: <20030228072243.GD6112@gnat.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="M9NhX3UHpAaciwkO" Content-Disposition: inline User-Agent: Mutt/1.4i X-SW-Source: 2003-02/txt/msg00803.txt.bz2 --M9NhX3UHpAaciwkO Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-length: 938 As requested by Andrew in: http://sources.redhat.com/ml/gdb-patches/2003-02/msg00773.html I checked the attached files in. There have slightly been modified from the file originally sent: added the copyright headers, some documentation, introduced the notion of subject from the "Design Patterns" book, added a missing "static" keyword for an internal function, etc. 2003-02-27 J. Brobecker * observer.h, observer.c: New file. And ARGH, of course I just noticed AFTER the check in that I forgot to update the comments for my last minute parameter renamings... So I then committed the following change: 2003-02-27 J. Brobecker * observer.c: Minor comments edits. The attached files reflect the lastest (corrected) version. The changes to the Makefile will shortly follow as an RFA (should be pretty straightforward, but an extra pair of eyes shouldn't hurt). -- Joel --M9NhX3UHpAaciwkO Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="observer.h" Content-length: 1206 /* GDB Notifications to Observers. Copyright 2003 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 2 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, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef OBSERVER_H #define OBSERVER_H struct observer; /* normal_stop notifications. */ typedef void (observer_normal_stop_ftype) (void); extern struct observer * observer_attach_normal_stop (observer_normal_stop_ftype *f); extern void observer_detach_normal_stop (struct observer *observer); extern void observer_notify_normal_stop (void); #endif /* OBSERVER_H */ --M9NhX3UHpAaciwkO Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="observer.c" Content-length: 6201 /* GDB Notifications to Observers. Copyright 2003 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 2 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, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* An observer is an entity who is interested in being notified when GDB reaches certain states, or certain events occur in GDB. The entity being observed is called the Subject. To receive notifications, the observer attaches a callback to the subject. One subject can have several observers. This file implements an internal generic low-level event notification mechanism based on the Observer paradigm described in the book "Design Patterns". This generic event notification mechansim is then re-used to implement the exported high-level notification management routines for all possible notifications. The current implementation of the generic observer provides support for contextual data. This contextual data is given to the subject when attaching the callback. In return, the subject will provide this contextual data back to the observer as a parameter of the callback. FIXME: The current support for the contextual data is only partial, as it lacks a mechanism that would deallocate this data when the callback is detached. This is not a problem so far, as this contextual data is only used internally to hold a function pointer. Later on, if a certain observer needs to provide support for user-level contextual data, then the generic notification mechanism will need need to be enhanced to allow the observer to provide a routine to deallocate the data when attaching the callback. This file is currently maintained by hand, but the long term plan if the number of different notifications starts growing is to create a new script (observer.sh) that would generate this file, and the associated documentation. */ #include "defs.h" #include "observer.h" /* The internal generic observer. */ typedef void (generic_observer_notification_ftype) (const void *data, const void *args); struct observer { generic_observer_notification_ftype *notify; /* No memory management needed for the following field for now. */ void *data; }; /* A list of observers, maintained by the subject. A subject is actually represented by its list of observers. */ struct observer_list { struct observer_list *next; struct observer *observer; }; /* Allocate a struct observer_list, intended to be used as a node in the list of observers maintained by a subject. */ static struct observer_list * xalloc_observer_list_node (void) { struct observer_list *node = XMALLOC (struct observer_list); node->observer = XMALLOC (struct observer); return node; } /* The opposite of xalloc_observer_list_node, frees the memory for the given node. */ static void xfree_observer_list_node (struct observer_list *node) { xfree (node->observer); xfree (node); } /* Attach the callback NOTIFY to a SUBJECT. The DATA is also stored, in order for the subject to provide it back to the observer during a notification. */ static struct observer * generic_observer_attach (struct observer_list **subject, generic_observer_notification_ftype * notify, void *data) { struct observer_list *observer_list = xalloc_observer_list_node (); observer_list->next = *subject; observer_list->observer->notify = notify; observer_list->observer->data = data; *subject = observer_list; return observer_list->observer; } /* Remove the given OBSERVER from the SUBJECT. Once detached, OBSERVER should no longer be used, as it is no longer valid. */ static void generic_observer_detach (struct observer_list **subject, const struct observer *observer) { struct observer_list *previous_node = NULL; struct observer_list *current_node = *subject; while (current_node != NULL) { if (current_node->observer == observer) { if (previous_node != NULL) previous_node->next = current_node->next; else *subject = current_node->next; xfree_observer_list_node (current_node); return; } previous_node = current_node; current_node = current_node->next; } /* We should never reach this point. However, this should not be a very serious error, so simply report a warning to the user. */ warning ("Failed to detach observer"); } /* Send a notification to all the observers of SUBJECT. ARGS is passed to all observers as an argument to the notification callback. */ static void generic_observer_notify (struct observer_list *subject, const void *args) { struct observer_list *current_node = subject; while (current_node != NULL) { (*current_node->observer->notify) (current_node->observer->data, args); current_node = current_node->next; } } /* normal_stop notifications. */ static struct observer_list *normal_stop_subject = NULL; static void observer_normal_stop_notification_stub (const void *data, const void *unused_args) { observer_normal_stop_ftype *notify = (observer_normal_stop_ftype *) data; (*notify) (); } struct observer * observer_attach_normal_stop (observer_normal_stop_ftype *f) { return generic_observer_attach (&normal_stop_subject, &observer_normal_stop_notification_stub, (void *) f); } void observer_detach_normal_stop (struct observer *observer) { generic_observer_detach (&normal_stop_subject, observer); } void observer_notify_normal_stop (void) { generic_observer_notify (normal_stop_subject, NULL); } --M9NhX3UHpAaciwkO--