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

/* User Interface Events.

   Copyright (C) 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., 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
	1	/* User Interface Events.
	2
	3	Copyright (C) 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., 51 Franklin Street, Fifth Floor,
	23	Boston, MA 02110-1301, USA. */
	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
	37	prove easier. */
	38
	39
	40	#include "defs.h"
	41	#include "gdb-events.h"
	42	#include "gdbcmd.h"
	43
	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;
	47
	48	int gdb_events_debug;
	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
	56
	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
	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
	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
	127	struct gdb_events *
	128	deprecated_set_gdb_event_hooks (struct gdb_events *vector)
	129	{
	130	struct gdb_events *old_events = current_event_hooks;
	131	if (vector == NULL)
	132	current_event_hooks = &queue_event_hooks;
	133	else
	134	current_event_hooks = vector;
	135	return old_events;
	136	}
	137
	138	void
	139	clear_gdb_event_hooks (void)
	140	{
	141	deprecated_set_gdb_event_hooks (&null_event_hooks);
	142	}
	143
	144	enum gdb_event
	145	{
	146	breakpoint_create,
	147	breakpoint_delete,
	148	breakpoint_modify,
	149	tracepoint_create,
	150	tracepoint_delete,
	151	tracepoint_modify,
	152	architecture_changed,
	153	nr_gdb_events
	154	};
	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
	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
	186	struct event
	187	{
	188	enum gdb_event type;
	189	struct event *next;
	190	union
	191	{
	192	struct breakpoint_create breakpoint_create;
	193	struct breakpoint_delete breakpoint_delete;
	194	struct breakpoint_modify breakpoint_modify;
	195	struct tracepoint_create tracepoint_create;
	196	struct tracepoint_delete tracepoint_delete;
	197	struct tracepoint_modify tracepoint_modify;
	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
	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
	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
	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;
	284	xfree (event);
	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)
	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;
	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;
	321	case architecture_changed:
	322	vector->architecture_changed ();
	323	break;
	324	}
	325	delivering_events = event->next;
	326	xfree (event);
	327	}
	328	}
	329
	330	void _initialize_gdb_events (void);
	331	void
	332	_initialize_gdb_events (void)
	333	{
	334	struct cmd_list_element *c;
	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;
	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;
	341	queue_event_hooks.architecture_changed = queue_architecture_changed;
	342
	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,
	349	show_gdb_events_debug,
	350	&setdebuglist, &showdebuglist);
	351	}