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

/* User Interface Events.

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