[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;
static void
show_gdb_events_debug (struct ui_file *file, int from_tty,
		       struct cmd_list_element *c, const char *value)
{
  fprintf_filtered (file, _("Event debugging is %s.\n"), value);
}


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