[deliverable/binutils-gdb.git] / gdb / gdb-events.c

/* User Interface Events.

   Copyright 1999, 2001, 2002, 2004, 2005 Free Software Foundation,
   Inc.

   Contributed by Cygnus Solutions.

   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.  */

/* Work in progress */

/* This file was created with the aid of ``gdb-events.sh''.

   The bourn shell script ``gdb-events.sh'' creates the files
   ``new-gdb-events.c'' and ``new-gdb-events.h and then compares
   them against the existing ``gdb-events.[hc]''.  Any differences
   found being reported.

   If editing this file, please also run gdb-events.sh and merge any
   changes into that script. Conversely, when making sweeping changes
   to this file, modifying gdb-events.sh and using its output may
   prove easier.  */


#include "defs.h"
#include "gdb-events.h"
#include "gdbcmd.h"

static struct gdb_events null_event_hooks;
static struct gdb_events queue_event_hooks;
static struct gdb_events *current_event_hooks = &null_event_hooks;

int gdb_events_debug;

void
breakpoint_create_event (int b)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "breakpoint_create_event\n");
  if (!current_event_hooks->breakpoint_create)
    return;
  current_event_hooks->breakpoint_create (b);
}

void
breakpoint_delete_event (int b)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "breakpoint_delete_event\n");
  if (!current_event_hooks->breakpoint_delete)
    return;
  current_event_hooks->breakpoint_delete (b);
}

void
breakpoint_modify_event (int b)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "breakpoint_modify_event\n");
  if (!current_event_hooks->breakpoint_modify)
    return;
  current_event_hooks->breakpoint_modify (b);
}

void
tracepoint_create_event (int number)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "tracepoint_create_event\n");
  if (!current_event_hooks->tracepoint_create)
    return;
  current_event_hooks->tracepoint_create (number);
}

void
tracepoint_delete_event (int number)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "tracepoint_delete_event\n");
  if (!current_event_hooks->tracepoint_delete)
    return;
  current_event_hooks->tracepoint_delete (number);
}

void
tracepoint_modify_event (int number)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "tracepoint_modify_event\n");
  if (!current_event_hooks->tracepoint_modify)
    return;
  current_event_hooks->tracepoint_modify (number);
}

void
architecture_changed_event (void)
{
  if (gdb_events_debug)
    fprintf_unfiltered (gdb_stdlog, "architecture_changed_event\n");
  if (!current_event_hooks->architecture_changed)
    return;
  current_event_hooks->architecture_changed ();
}

struct gdb_events *
deprecated_set_gdb_event_hooks (struct gdb_events *vector)
{
  struct gdb_events *old_events = current_event_hooks;
  if (vector == NULL)
    current_event_hooks = &queue_event_hooks;
  else
    current_event_hooks = vector;
  return old_events;
}

void
clear_gdb_event_hooks (void)
{
  deprecated_set_gdb_event_hooks (&null_event_hooks);
}

enum gdb_event
{
  breakpoint_create,
  breakpoint_delete,
  breakpoint_modify,
  tracepoint_create,
  tracepoint_delete,
  tracepoint_modify,
  architecture_changed,
  nr_gdb_events
};

struct breakpoint_create
  {
    int b;
  };

struct breakpoint_delete
  {
    int b;
  };

struct breakpoint_modify
  {
    int b;
  };

struct tracepoint_create
  {
    int number;
  };

struct tracepoint_delete
  {
    int number;
  };

struct tracepoint_modify
  {
    int number;
  };

struct event
  {
    enum gdb_event type;
    struct event *next;
    union
      {
	struct breakpoint_create breakpoint_create;
	struct breakpoint_delete breakpoint_delete;
	struct breakpoint_modify breakpoint_modify;
	struct tracepoint_create tracepoint_create;
	struct tracepoint_delete tracepoint_delete;
	struct tracepoint_modify tracepoint_modify;
      }
    data;
  };
struct event *pending_events;
struct event *delivering_events;

static void
append (struct event *new_event)
{
  struct event **event = &pending_events;
  while ((*event) != NULL)
    event = &((*event)->next);
  (*event) = new_event;
  (*event)->next = NULL;
}

static void
queue_breakpoint_create (int b)
{
  struct event *event = XMALLOC (struct event);
  event->type = breakpoint_create;
  event->data.breakpoint_create.b = b;
  append (event);
}

static void
queue_breakpoint_delete (int b)
{
  struct event *event = XMALLOC (struct event);
  event->type = breakpoint_delete;
  event->data.breakpoint_delete.b = b;
  append (event);
}

static void
queue_breakpoint_modify (int b)
{
  struct event *event = XMALLOC (struct event);
  event->type = breakpoint_modify;
  event->data.breakpoint_modify.b = b;
  append (event);
}

static void
queue_tracepoint_create (int number)
{
  struct event *event = XMALLOC (struct event);
  event->type = tracepoint_create;
  event->data.tracepoint_create.number = number;
  append (event);
}

static void
queue_tracepoint_delete (int number)
{
  struct event *event = XMALLOC (struct event);
  event->type = tracepoint_delete;
  event->data.tracepoint_delete.number = number;
  append (event);
}

static void
queue_tracepoint_modify (int number)
{
  struct event *event = XMALLOC (struct event);
  event->type = tracepoint_modify;
  event->data.tracepoint_modify.number = number;
  append (event);
}

static void
queue_architecture_changed (void)
{
  struct event *event = XMALLOC (struct event);
  event->type = architecture_changed;
  append (event);
}

void
gdb_events_deliver (struct gdb_events *vector)
{
  /* Just zap any events left around from last time. */
  while (delivering_events != NULL)
    {
      struct event *event = delivering_events;
      delivering_events = event->next;
      xfree (event);
    }
  /* Process any pending events.  Because one of the deliveries could
     bail out we move everything off of the pending queue onto an
     in-progress queue where it can, later, be cleaned up if
     necessary. */
  delivering_events = pending_events;
  pending_events = NULL;
  while (delivering_events != NULL)
    {
      struct event *event = delivering_events;
      switch (event->type)
	{
	case breakpoint_create:
	  vector->breakpoint_create
	    (event->data.breakpoint_create.b);
	  break;
	case breakpoint_delete:
	  vector->breakpoint_delete
	    (event->data.breakpoint_delete.b);
	  break;
	case breakpoint_modify:
	  vector->breakpoint_modify
	    (event->data.breakpoint_modify.b);
	  break;
	case tracepoint_create:
	  vector->tracepoint_create
	    (event->data.tracepoint_create.number);
	  break;
	case tracepoint_delete:
	  vector->tracepoint_delete
	    (event->data.tracepoint_delete.number);
	  break;
	case tracepoint_modify:
	  vector->tracepoint_modify
	    (event->data.tracepoint_modify.number);
	  break;
	case architecture_changed:
	  vector->architecture_changed ();
	  break;
	}
      delivering_events = event->next;
      xfree (event);
    }
}

void _initialize_gdb_events (void);
void
_initialize_gdb_events (void)
{
  struct cmd_list_element *c;
  queue_event_hooks.breakpoint_create = queue_breakpoint_create;
  queue_event_hooks.breakpoint_delete = queue_breakpoint_delete;
  queue_event_hooks.breakpoint_modify = queue_breakpoint_modify;
  queue_event_hooks.tracepoint_create = queue_tracepoint_create;
  queue_event_hooks.tracepoint_delete = queue_tracepoint_delete;
  queue_event_hooks.tracepoint_modify = queue_tracepoint_modify;
  queue_event_hooks.architecture_changed = queue_architecture_changed;

  add_setshow_zinteger_cmd ("event", class_maintenance,
			    &gdb_events_debug, _("\
Set event debugging."), _("\
Show event debugging."), _("\
When non-zero, event/notify debugging is enabled."),
			    NULL,
			    NULL, /* FIXME: i18n: */
			    &setdebuglist, &showdebuglist);
}
Commit	Line	Data
	1	/* User Interface Events.
	2
	3	Copyright 1999, 2001, 2002, 2004, 2005 Free Software Foundation,
	4	Inc.
	5
	6	Contributed by Cygnus Solutions.
	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
	12	the Free Software Foundation; either version 2 of the License, or
	13	(at your option) any later version.
	14
	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.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with this program; if not, write to the Free Software
	22	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	23
	24	/* Work in progress */
	25
	26	/* This file was created with the aid of ``gdb-events.sh''.
	27
	28	The bourn shell script ``gdb-events.sh'' creates the files
	29	``new-gdb-events.c'' and ``new-gdb-events.h and then compares
	30	them against the existing ``gdb-events.[hc]''. Any differences
	31	found being reported.
	32
	33	If editing this file, please also run gdb-events.sh and merge any
	34	changes into that script. Conversely, when making sweeping changes
	35	to this file, modifying gdb-events.sh and using its output may
	36	prove easier. */
	37
	38
	39	#include "defs.h"
	40	#include "gdb-events.h"
	41	#include "gdbcmd.h"
	42
	43	static struct gdb_events null_event_hooks;
	44	static struct gdb_events queue_event_hooks;
	45	static struct gdb_events *current_event_hooks = &null_event_hooks;
	46
	47	int gdb_events_debug;
	48
	49	void
	50	breakpoint_create_event (int b)
	51	{
	52	if (gdb_events_debug)
	53	fprintf_unfiltered (gdb_stdlog, "breakpoint_create_event\n");
	54	if (!current_event_hooks->breakpoint_create)
	55	return;
	56	current_event_hooks->breakpoint_create (b);
	57	}
	58
	59	void
	60	breakpoint_delete_event (int b)
	61	{
	62	if (gdb_events_debug)
	63	fprintf_unfiltered (gdb_stdlog, "breakpoint_delete_event\n");
	64	if (!current_event_hooks->breakpoint_delete)
	65	return;
	66	current_event_hooks->breakpoint_delete (b);
	67	}
	68
	69	void
	70	breakpoint_modify_event (int b)
	71	{
	72	if (gdb_events_debug)
	73	fprintf_unfiltered (gdb_stdlog, "breakpoint_modify_event\n");
	74	if (!current_event_hooks->breakpoint_modify)
	75	return;
	76	current_event_hooks->breakpoint_modify (b);
	77	}
	78
	79	void
	80	tracepoint_create_event (int number)
	81	{
	82	if (gdb_events_debug)
	83	fprintf_unfiltered (gdb_stdlog, "tracepoint_create_event\n");
	84	if (!current_event_hooks->tracepoint_create)
	85	return;
	86	current_event_hooks->tracepoint_create (number);
	87	}
	88
	89	void
	90	tracepoint_delete_event (int number)
	91	{
	92	if (gdb_events_debug)
	93	fprintf_unfiltered (gdb_stdlog, "tracepoint_delete_event\n");
	94	if (!current_event_hooks->tracepoint_delete)
	95	return;
	96	current_event_hooks->tracepoint_delete (number);
	97	}
	98
	99	void
	100	tracepoint_modify_event (int number)
	101	{
	102	if (gdb_events_debug)
	103	fprintf_unfiltered (gdb_stdlog, "tracepoint_modify_event\n");
	104	if (!current_event_hooks->tracepoint_modify)
	105	return;
	106	current_event_hooks->tracepoint_modify (number);
	107	}
	108
	109	void
	110	architecture_changed_event (void)
	111	{
	112	if (gdb_events_debug)
	113	fprintf_unfiltered (gdb_stdlog, "architecture_changed_event\n");
	114	if (!current_event_hooks->architecture_changed)
	115	return;
	116	current_event_hooks->architecture_changed ();
	117	}
	118
	119	struct gdb_events *
	120	deprecated_set_gdb_event_hooks (struct gdb_events *vector)
	121	{
	122	struct gdb_events *old_events = current_event_hooks;
	123	if (vector == NULL)
	124	current_event_hooks = &queue_event_hooks;
	125	else
	126	current_event_hooks = vector;
	127	return old_events;
	128	}
	129
	130	void
	131	clear_gdb_event_hooks (void)
	132	{
	133	deprecated_set_gdb_event_hooks (&null_event_hooks);
	134	}
	135
	136	enum gdb_event
	137	{
	138	breakpoint_create,
	139	breakpoint_delete,
	140	breakpoint_modify,
	141	tracepoint_create,
	142	tracepoint_delete,
	143	tracepoint_modify,
	144	architecture_changed,
	145	nr_gdb_events
	146	};
	147
	148	struct breakpoint_create
	149	{
	150	int b;
	151	};
	152
	153	struct breakpoint_delete
	154	{
	155	int b;
	156	};
	157
	158	struct breakpoint_modify
	159	{
	160	int b;
	161	};
	162
	163	struct tracepoint_create
	164	{
	165	int number;
	166	};
	167
	168	struct tracepoint_delete
	169	{
	170	int number;
	171	};
	172
	173	struct tracepoint_modify
	174	{
	175	int number;
	176	};
	177
	178	struct event
	179	{
	180	enum gdb_event type;
	181	struct event *next;
	182	union
	183	{
	184	struct breakpoint_create breakpoint_create;
	185	struct breakpoint_delete breakpoint_delete;
	186	struct breakpoint_modify breakpoint_modify;
	187	struct tracepoint_create tracepoint_create;
	188	struct tracepoint_delete tracepoint_delete;
	189	struct tracepoint_modify tracepoint_modify;
	190	}
	191	data;
	192	};
	193	struct event *pending_events;
	194	struct event *delivering_events;
	195
	196	static void
	197	append (struct event *new_event)
	198	{
	199	struct event **event = &pending_events;
	200	while ((*event) != NULL)
	201	event = &((*event)->next);
	202	(*event) = new_event;
	203	(*event)->next = NULL;
	204	}
	205
	206	static void
	207	queue_breakpoint_create (int b)
	208	{
	209	struct event *event = XMALLOC (struct event);
	210	event->type = breakpoint_create;
	211	event->data.breakpoint_create.b = b;
	212	append (event);
	213	}
	214
	215	static void
	216	queue_breakpoint_delete (int b)
	217	{
	218	struct event *event = XMALLOC (struct event);
	219	event->type = breakpoint_delete;
	220	event->data.breakpoint_delete.b = b;
	221	append (event);
	222	}
	223
	224	static void
	225	queue_breakpoint_modify (int b)
	226	{
	227	struct event *event = XMALLOC (struct event);
	228	event->type = breakpoint_modify;
	229	event->data.breakpoint_modify.b = b;
	230	append (event);
	231	}
	232
	233	static void
	234	queue_tracepoint_create (int number)
	235	{
	236	struct event *event = XMALLOC (struct event);
	237	event->type = tracepoint_create;
	238	event->data.tracepoint_create.number = number;
	239	append (event);
	240	}
	241
	242	static void
	243	queue_tracepoint_delete (int number)
	244	{
	245	struct event *event = XMALLOC (struct event);
	246	event->type = tracepoint_delete;
	247	event->data.tracepoint_delete.number = number;
	248	append (event);
	249	}
	250
	251	static void
	252	queue_tracepoint_modify (int number)
	253	{
	254	struct event *event = XMALLOC (struct event);
	255	event->type = tracepoint_modify;
	256	event->data.tracepoint_modify.number = number;
	257	append (event);
	258	}
	259
	260	static void
	261	queue_architecture_changed (void)
	262	{
	263	struct event *event = XMALLOC (struct event);
	264	event->type = architecture_changed;
	265	append (event);
	266	}
	267
	268	void
	269	gdb_events_deliver (struct gdb_events *vector)
	270	{
	271	/* Just zap any events left around from last time. */
	272	while (delivering_events != NULL)
	273	{
	274	struct event *event = delivering_events;
	275	delivering_events = event->next;
	276	xfree (event);
	277	}
	278	/* Process any pending events. Because one of the deliveries could
	279	bail out we move everything off of the pending queue onto an
	280	in-progress queue where it can, later, be cleaned up if
	281	necessary. */
	282	delivering_events = pending_events;
	283	pending_events = NULL;
	284	while (delivering_events != NULL)
	285	{
	286	struct event *event = delivering_events;
	287	switch (event->type)
	288	{
	289	case breakpoint_create:
	290	vector->breakpoint_create
	291	(event->data.breakpoint_create.b);
	292	break;
	293	case breakpoint_delete:
	294	vector->breakpoint_delete
	295	(event->data.breakpoint_delete.b);
	296	break;
	297	case breakpoint_modify:
	298	vector->breakpoint_modify
	299	(event->data.breakpoint_modify.b);
	300	break;
	301	case tracepoint_create:
	302	vector->tracepoint_create
	303	(event->data.tracepoint_create.number);
	304	break;
	305	case tracepoint_delete:
	306	vector->tracepoint_delete
	307	(event->data.tracepoint_delete.number);
	308	break;
	309	case tracepoint_modify:
	310	vector->tracepoint_modify
	311	(event->data.tracepoint_modify.number);
	312	break;
	313	case architecture_changed:
	314	vector->architecture_changed ();
	315	break;
	316	}
	317	delivering_events = event->next;
	318	xfree (event);
	319	}
	320	}
	321
	322	void _initialize_gdb_events (void);
	323	void
	324	_initialize_gdb_events (void)
	325	{
	326	struct cmd_list_element *c;
	327	queue_event_hooks.breakpoint_create = queue_breakpoint_create;
	328	queue_event_hooks.breakpoint_delete = queue_breakpoint_delete;
	329	queue_event_hooks.breakpoint_modify = queue_breakpoint_modify;
	330	queue_event_hooks.tracepoint_create = queue_tracepoint_create;
	331	queue_event_hooks.tracepoint_delete = queue_tracepoint_delete;
	332	queue_event_hooks.tracepoint_modify = queue_tracepoint_modify;
	333	queue_event_hooks.architecture_changed = queue_architecture_changed;
	334
	335	add_setshow_zinteger_cmd ("event", class_maintenance,
	336	&gdb_events_debug, _("\
	337	Set event debugging."), _("\
	338	Show event debugging."), _("\
	339	When non-zero, event/notify debugging is enabled."),
	340	NULL,
	341	NULL, /* FIXME: i18n: */
	342	&setdebuglist, &showdebuglist);
	343	}