[RFC] GDB interpreters

[RFC] GDB interpreters

[Keith Seitz]

Hi,

Well, here it is. This is the first really big contribution from Apple.
The two files below implement several functions for setting, getting,
defining, and querying interpreters. It is pretty much verbatim from
Apple, but I've run it through gdb_indent.sh and I've modified a few
things.

I will be adding documentation for the MI part of the GDB manual and I
will be writing testsuites to cover all this. That aside, it is a
non-trivial change to all sorts of things in gdb to get this working. I
thought I would start with this and work my way out to other, more
invasive changes.

interpreter.c (do I need to edit config/djgpp/fnchange.lst?) adds a couple
of new commands:

(gdb) help set interpreter
Set the interpreter for gdb.
(gdb) info interpreters
  * mi
  * mi0
  * console
(gdb) help interpreter-exec
Execute a command in an interpreter.  It takes two arguments:
The first argument is the name of the interpreter to use.
The second argument is the command to execute.

I would appreciate any comments.
Keith

/* Manages interpreters for gdb.
   Copyright 2000,2002 Free Software Foundation, Inc.
   Written by Jim Ingham <jingham@apple.com> of Apple Computer, 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 GDB_INTERPRETER_H
#define GDB_INTERPRETER_H

typedef int (*interp_init_ftype) (void *data);
typedef int (*interp_resume_ftype) (void *data);
typedef int (*interp_do_one_event_ftype) (void *data);
typedef int (*interp_suspend_ftype) (void *data);
typedef int (*interp_delete_ftype) (void *data);
typedef int (*interp_prompt_ftype) (void *data, char *new_prompt);
typedef int (*interp_exec_ftype) (void *data, char *command);

struct ui_out;

struct gdb_interpreter_procs
{
  interp_init_ftype init_proc;
  interp_resume_ftype resume_proc;
  interp_do_one_event_ftype do_one_event_proc;
  interp_suspend_ftype suspend_proc;
  interp_delete_ftype delete_proc;
  interp_exec_ftype exec_proc;
  interp_prompt_ftype prompt_proc;
};

struct gdb_interpreter
{
  char *name;			/* This is the name in "-i=" and set interpreter. */
  struct gdb_interpreter *next;	/* Interpreters are stored in a linked list,
				   this is the next one... */
  void *data;			/* This is a cookie that the instance of the
				   interpreter can use, for instance to call
				   itself in hook functions */
  int inited;			/* Has the init_proc been run? */
  struct ui_out *interpreter_out;	/* This is the ui_out used to collect
					   results for this interpreter.  It can
					   be a formatter for stdout, as is the
					   case for the console & mi outputs, or it
					   might be a result formatter. */
  struct gdb_interpreter_procs procs;
  int quiet_p;
};

extern struct gdb_interpreter
  *gdb_new_interpreter (char *name, void *data, struct ui_out *uiout,
			struct gdb_interpreter_procs *procs);

extern int gdb_add_interpreter (struct gdb_interpreter *interp);
extern int gdb_delete_interpreter (struct gdb_interpreter *interp);
extern int gdb_set_interpreter (struct gdb_interpreter *interp);
extern struct gdb_interpreter *gdb_lookup_interpreter (char *name);
extern struct gdb_interpreter *gdb_current_interpreter ();
extern struct ui_out *gdb_interpreter_ui_out (struct gdb_interpreter *interp);
extern int gdb_current_interpreter_is_named (char *interp_name);
extern int gdb_interpreter_exec (char *command_str);
extern int gdb_interpreter_display_prompt (char *new_prompt);
extern int gdb_interpreter_set_quiet (struct gdb_interpreter *interp,
				      int quiet);
extern int gdb_interpreter_is_quiet (struct gdb_interpreter *interp);
extern int interpreter_do_one_event ();

void clear_interpreter_hooks ();

/* well-known interpreters */
#define GDB_INTERPRETER_CONSOLE		"console"
#define GDB_INTERPRETER_MI		"mi"
#define GDB_INTERPRETER_MI0		"mi0"

#endif /* GDB_INTERPRETER_H */
/* Manages interpreters for gdb.
   Copyright 2000, 2002 Free Software Foundation, Inc.
   Written by Jim Ingham <jingham@apple.com> of Apple Computer, 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. */

/* This is just a first cut at separating out the "interpreter" functions
   of gdb into self-contained modules.  There are a couple of open areas that
   need to be sorted out:

   1) The interpreter explicitly contains a UI_OUT, and can insert itself
   into the event loop, but it doesn't explicitly contain hooks for readline.
   I did this because it seems to me many interpreters won't want to use
   the readline command interface, and it is probably simpler to just let
   them take over the input in their resume proc.

   2) The event loop insertion is probably wrong.  I just inserted a
   do_one_event alongside gdb's do_one_event.  This probably will lead
   to one or the other event loop getting starved.  It would be better
   to provide conversion functions for the gdb file handlers, and when
   an interpreter starts up, it grabs all the gdb created file handlers
   and inserts them into its select.  This is more complicated, however,
   and I have run out of time for now.
*/

#include "defs.h"
#include "gdbcmd.h"
#include "ui-out.h"
#include "event-loop.h"
#include "event-top.h"
#include "interpreter.h"

/* Functions local to this file. */
static void initialize_interps (void);

static void set_interpreter_cmd (char *args, int from_tty,
				 struct cmd_list_element *c);
static void list_interpreter_cmd (char *args, int from_tty);
static void do_set_interpreter (int not_an_fd);

/* The magic initialization routine for this module. */

void _initialize_interpreter (void);

/* Variables local to this file: */

static struct gdb_interpreter *interp_list = NULL;
static struct gdb_interpreter *current = NULL;

static int initialized = 0;

/* gdb_new_interpreter - This allocates space for a new interpreter,
 * fills the fields from the inputs, and returns a pointer to the
 * interpreter. */

struct gdb_interpreter *
gdb_new_interpreter (char *name,
		     void *data,
		     struct ui_out *uiout,
		     struct gdb_interpreter_procs *procs)
{
  struct gdb_interpreter *new_interp;

  new_interp =
    (struct gdb_interpreter *) xmalloc (sizeof (struct gdb_interpreter));

  new_interp->name = xstrdup (name);
  new_interp->data = data;
  new_interp->interpreter_out = uiout;
  new_interp->quiet_p = 0;
  new_interp->procs.init_proc = procs->init_proc;
  new_interp->procs.resume_proc = procs->resume_proc;
  new_interp->procs.do_one_event_proc = procs->do_one_event_proc;
  new_interp->procs.suspend_proc = procs->suspend_proc;
  new_interp->procs.delete_proc = procs->delete_proc;
  new_interp->procs.exec_proc = procs->exec_proc;
  new_interp->procs.prompt_proc = procs->prompt_proc;
  new_interp->inited = 0;

  return new_interp;
}

/*
 * gdb_add_interpreter
 *
 * Add interpreter INTERP to the gdb interpreter list.  If an
 * interpreter of the same name is already on the list, then
 * the new one is NOT added, and the function returns 0.  Otherwise
 * it returns 1.
 */

int
gdb_add_interpreter (struct gdb_interpreter *interp)
{
  if (!initialized)
    initialize_interps ();

  if (gdb_lookup_interpreter (interp->name) != NULL)
    return 0;

  interp->next = interp_list;
  interp_list = interp;

  return 1;
}

/*
 * gdb_delete_interpreter
 *
 * Looks for the interpreter INTERP in the interpreter list.  If it exists,
 * runs the delete_proc, and if this is successful, the INTERP is deleted from
 * the interpreter list and the function returns 1.  If the delete_proc fails, the
 * function returns -1 and the interpreter is NOT removed from the list.  If the
 * interp is not found, 0 is returned.
 */

int
gdb_delete_interpreter (struct gdb_interpreter *interp)
{
  struct gdb_interpreter *cur_ptr, *prev_ptr;

  if (!initialized)
    {
      ui_out_message (uiout, 0,
		      "You can't delete an interp before you have added one!");
      return -1;
    }

  if (interp_list == NULL)
    {
      ui_out_message (uiout, 0, "No interpreters to delete.");
      return -1;
    }

  if (interp_list->next == NULL)
    {
      ui_out_message (uiout, 0, "You can't delete gdb's only intepreter.");
      return -1;
    }

  for (cur_ptr = interp_list, prev_ptr = NULL;
       cur_ptr != NULL; prev_ptr = cur_ptr, cur_ptr = cur_ptr->next)
    {
      if (cur_ptr == interp)
	{
	  /* Can't currently delete the console interpreter... */
	  if (strcmp (interp->name, "console") == 0)
	    {
	      ui_out_message (uiout, 0,
			      "You can't delete the console interpreter.");
	      return -1;
	    }

	  /* If the interpreter is the current interpreter, switch
	     back to the console interpreter */

	  if (interp == current)
	    {
	      gdb_set_interpreter (gdb_lookup_interpreter ("console"));
	    }

	  /* Don't delete the interpreter if its delete proc fails */

	  if ((interp->procs.delete_proc != NULL)
	      && (!interp->procs.delete_proc (interp->data)))
	    return -1;

	  if (cur_ptr == interp_list)
	    interp_list = cur_ptr->next;
	  else
	    prev_ptr->next = cur_ptr->next;

	  break;
	}
    }

  if (cur_ptr == NULL)
    return 0;
  else
    return 1;
}

/*
 * gdb_set_interpreter
 *
 * This sets the current interpreter to be INTERP.  If INTERP has not
 * been initialized, then this will also run the init proc.  If the
 * init proc is successful, return 1, if it fails, set the old
 * interpreter back in place and return 0.  If we can't restore the
 * old interpreter, then raise an internal error, since we are in
 * pretty bad shape at this point.
*/

int
gdb_set_interpreter (struct gdb_interpreter *interp)
{
  struct gdb_interpreter *old_interp = current;
  int first_time = 0;


  char buffer[64];

  if (current != NULL)
    {
      do_all_continuations ();
      ui_out_flush (uiout);
      if (current->procs.suspend_proc &&
	  !current->procs.suspend_proc (current->data))
	{
	  error ("Could not suspend interpreter \"%s\"\n", current->name);
	}
    }
  else
    {
      first_time = 1;
    }

  current = interp;

  /* We use interpreter_p for the "set interpreter" variable, so we need
     to make sure we have a malloc'ed copy for the set command to free. */
  if (interpreter_p != NULL && strcmp (current->name, interpreter_p) != 0)
    {
      xfree (interpreter_p);

      interpreter_p = xstrdup (current->name);
    }

  uiout = interp->interpreter_out;

  /* Run the init proc.  If it fails, try to restore the old interp. */

  if (!interp->inited)
    {
      if (interp->procs.init_proc != NULL)
	{
	  if (!interp->procs.init_proc (interp->data))
	    {
	      if (!gdb_set_interpreter (old_interp))
		internal_error (__FILE__, __LINE__,
				"Failed to initialize new interp \"%s\" %s",
				interp->name,
				"and could not restore old interp!\n");
	      return 0;
	    }
	  else
	    {
	      interp->inited = 1;
	    }
	}
      else
	{
	  interp->inited = 1;
	}
    }

  if (interp->procs.resume_proc != NULL
      && (!interp->procs.resume_proc (interp->data)))
    {
      if (!gdb_set_interpreter (old_interp))
	internal_error (__FILE__, __LINE__,
			"Failed to initialize new interp \"%s\" %s",
			interp->name, "and could not restore old interp!\n");
      return 0;
    }

  /* Finally, put up the new prompt to show that we are indeed here.
     Also, display_gdb_prompt for the console does some readline magic
     which is needed for the console interpreter, at least... */

  if (!first_time)
    {
      if (!gdb_interpreter_is_quiet (interp))
	{
	  sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
		   interp->name);
	  ui_out_text (uiout, buffer);
	}
      display_gdb_prompt (NULL);
    }

  return 1;
}

/*
 * gdb_lookup_interpreter - Looks up the interpreter for NAME.  If
 * no such interpreter exists, return NULL, otherwise return a pointer
 * to the interpreter.
 */

struct gdb_interpreter *
gdb_lookup_interpreter (char *name)
{
  struct gdb_interpreter *interp;

  if (name == NULL || strlen (name) == 0)
    return NULL;

  for (interp = interp_list; interp != NULL; interp = interp->next)
    {
      if (strcmp (interp->name, name) == 0)
	return interp;
    }

  return NULL;
}

/*
 * gdb_current_interpreter - Returns the current interpreter.
 */

struct gdb_interpreter *
gdb_current_interpreter ()
{
  return current;
}

struct ui_out *
gdb_interpreter_ui_out (struct gdb_interpreter *interp)
{
  return interp->interpreter_out;
}

/*
 * gdb_current_interpreter_is -- returns true if the current interp is
 *   the passed in name.
 */
int
gdb_current_interpreter_is_named (char *interp_name)
{
  struct gdb_interpreter *current_interp = gdb_current_interpreter ();

  if (current_interp)
    return (strcmp (current_interp->name, interp_name) == 0);

  return 0;
}

/*
 * gdb_interpreter_display_prompt - This is called in display_gdb_prompt.
 * If the current interpreter defines a prompt_proc, then that proc is
 * run.  If the proc returns a non-zero value, display_gdb_prompt will
 * return without itself displaying the prompt.
 */

int
gdb_interpreter_display_prompt (char *new_prompt)
{
  if (current->procs.prompt_proc == NULL)
    return 0;
  else
    return current->procs.prompt_proc (current->data, new_prompt);
}

int
gdb_interpreter_is_quiet (struct gdb_interpreter *interp)
{
  if (interp != NULL)
    return interp->quiet_p;
  else
    return current->quiet_p;
}

int
gdb_interpreter_set_quiet (struct gdb_interpreter *interp, int quiet)
{
  int old_val = interp->quiet_p;
  interp->quiet_p = quiet;
  return old_val;
}

/* gdb_interpreter_exec - This executes COMMAND_STR in the current
   interpreter. */

int
gdb_interpreter_exec (char *command_str)
{
  if (current->procs.exec_proc != NULL)
    {
      return current->procs.exec_proc (current->data, command_str);
    }

  return 0;
}

int
interpreter_do_one_event ()
{
  if (current->procs.do_one_event_proc == NULL)
    return 0;

  return current->procs.do_one_event_proc (current->data);
}

/* clear_interpreter_hooks - A convenience routine that nulls out all the
 * common command hooks.  Use it when removing your interpreter in its
 * suspend proc.
 */

void
clear_interpreter_hooks ()
{
  init_ui_hook = 0;
  print_frame_info_listing_hook = 0;
  /*print_frame_more_info_hook = 0; */
  query_hook = 0;
  warning_hook = 0;
  create_breakpoint_hook = 0;
  delete_breakpoint_hook = 0;
  modify_breakpoint_hook = 0;
  interactive_hook = 0;
  registers_changed_hook = 0;
  readline_begin_hook = 0;
  readline_hook = 0;
  readline_end_hook = 0;
  register_changed_hook = 0;
  memory_changed_hook = 0;
  context_hook = 0;
  target_wait_hook = 0;
  call_command_hook = 0;
  error_hook = 0;
  error_begin_hook = 0;
  command_loop_hook = 0;
}

/*
 * initialize_interps - This is a lazy init routine, called the first time
 * the interpreter module is used.  I put it here just in case, but I haven't
 * thought of a use for it yet.  I will probably bag it soon, since I don't
 * think it will be necessary.
 */

static void
initialize_interps (void)
{
  initialized = 1;
  /* Don't know if anything needs to be done here... */
}

/* set_interpreter_cmd - This implements "set interpreter foo". */

static void
set_interpreter_cmd (char *args, int from_tty, struct cmd_list_element *c)
{
  struct gdb_interpreter *interp_ptr;

  dont_repeat ();

  if (cmd_type (c) != set_cmd)
    return;

  interp_ptr = gdb_lookup_interpreter (interpreter_p);
  if (interp_ptr != NULL)
    {
      if (!gdb_set_interpreter (interp_ptr))
	error ("\nCould not switch to interpreter \"%s\", %s%s\".\n",
	       interp_ptr->name, "reverting to interpreter \"",
	       current->name);
    }
  else
    {
      char *bad_name = interpreter_p;
      interpreter_p = xstrdup (current->name);
      error ("Could not find interpreter \"%s\".", bad_name);
    }
}

/* list_interpreter_cmd - This implements "info interpreters".
 */

void
list_interpreter_cmd (char *args, int from_tty)
{
  struct gdb_interpreter *interp_ptr;

  ui_out_list_begin (uiout, "interpreters");
  for (interp_ptr = interp_list; interp_ptr != NULL;
       interp_ptr = interp_ptr->next)
    {
      ui_out_text (uiout, "  * ");
      ui_out_field_string (uiout, "interpreter", interp_ptr->name);
      ui_out_text (uiout, "\n");
    }
  ui_out_list_end (uiout);
}

void
interpreter_exec_cmd (char *args, int from_tty)
{
  struct gdb_interpreter *old_interp, *interp_to_use;
  char **prules = NULL;
  char **trule = NULL;
  unsigned int nrules;
  unsigned int i;
  int old_quiet;

  prules = buildargv (args);
  if (prules == NULL)
    {
      error ("unable to parse arguments");
    }

  nrules = 0;
  if (prules != NULL)
    {
      for (trule = prules; *trule != NULL; trule++)
	{
	  nrules++;
	}
    }

  if (nrules < 2)
    error ("usage: interpreter-exec <interpreter> [ <command> ... ]");

  old_interp = gdb_current_interpreter ();

  interp_to_use = gdb_lookup_interpreter (prules[0]);
  if (interp_to_use == NULL)
    error ("Could not find interpreter \"%s\".", prules[0]);

  old_quiet = gdb_interpreter_set_quiet (interp_to_use, 1);

  if (!gdb_set_interpreter (interp_to_use))
    error ("Could not switch to interpreter \"%s\".", prules[0]);

  for (i = 1; i < nrules; i++)
    {
      if (!gdb_interpreter_exec (prules[i]))
	{
	  gdb_set_interpreter (old_interp);
	  gdb_interpreter_set_quiet (interp_to_use, old_quiet);
	  error
	    ("interpreter-exec: mi_interpreter_execute: error in command: \"%s\".",
	     prules[i]);
	  break;
	}
    }

  gdb_set_interpreter (old_interp);
  gdb_interpreter_set_quiet (interp_to_use, old_quiet);
}

/* _initialize_interpreter - This just adds the "set interpreter" and
 * "info interpreters" commands.
 */

void
_initialize_interpreter (void)
{
  struct cmd_list_element *c;

  c = add_set_cmd ("interpreter", class_support,
		   var_string,
		   &interpreter_p, "Set the interpreter for gdb.", &setlist);
  set_cmd_sfunc (c, set_interpreter_cmd);
  add_show_from_set (c, &showlist);

  add_cmd ("interpreters", class_support,
	   list_interpreter_cmd,
	   "List the interpreters currently available in gdb.", &infolist);

  add_cmd ("interpreter-exec", class_support,
	   interpreter_exec_cmd,
	   "Execute a command in an interpreter.  It takes two arguments:\n\
The first argument is the name of the interpreter to use.\n\
The second argument is the command to execute.\n", &cmdlist);
}

Re: [RFC] GDB interpreters

[Eli Zaretskii]

On Mon, 20 May 2002, Keith Seitz wrote:

> Well, here it is. This is the first really big contribution from Apple.
> The two files below implement several functions for setting, getting,
> defining, and querying interpreters.

Thanks!

> I will be adding documentation for the MI part of the GDB manual

Thanks in advance.

However, it sounds, at least for the commands you included in this 
patch, like they should be documented in gdb.texinfo, not in the MI part, 
since they are not parts of the MI.  Or did I miss something?

> interpreter.c (do I need to edit config/djgpp/fnchange.lst?)

I don't think so: you only need to do that if there is another file in 
the same directory whose name will clash with interpreter.c after 
truncation to 8+3 limits.  In this case, I don't see any other files 
whose names would clash.

> void
> _initialize_interpreter (void)
> {
>   struct cmd_list_element *c;
> 
>   c = add_set_cmd ("interpreter", class_support,
> 		   var_string,
> 		   &interpreter_p, "Set the interpreter for gdb.", &setlist);
>   set_cmd_sfunc (c, set_interpreter_cmd);
>   add_show_from_set (c, &showlist);
> 
>   add_cmd ("interpreters", class_support,
> 	   list_interpreter_cmd,
> 	   "List the interpreters currently available in gdb.", &infolist);
> 
>   add_cmd ("interpreter-exec", class_support,
> 	   interpreter_exec_cmd,
> 	   "Execute a command in an interpreter.  It takes two arguments:\n\
> The first argument is the name of the interpreter to use.\n\
> The second argument is the command to execute.\n", &cmdlist);
> }

Can we have completion on known interpreter names in these commands?  The 
default completer function completes on symbols from the inferior, which 
is really not a good idea in this case ;-)

Re: [RFC] GDB interpreters

[Keith Seitz]

On Tue, 21 May 2002, Eli Zaretskii wrote:

> However, it sounds, at least for the commands you included in this
> patch, like they should be documented in gdb.texinfo, not in the MI part,
> since they are not parts of the MI.  Or did I miss something?

Doh! You're right: my brain wasn't fully functional. Let me revise: I will
document whatever I remember to document. Someone should scream at me if I
miss anything else! :-)

> Can we have completion on known interpreter names in these commands?  The
> default completer function completes on symbols from the inferior, which
> is really not a good idea in this case ;-)

I can certainly look into that...

Keith

Re: [RFC] GDB interpreters

[Keith Seitz]

On Tue, 21 May 2002, Eli Zaretskii wrote:

> However, it sounds, at least for the commands you included in this
> patch, like they should be documented in gdb.texinfo, not in the MI part,
> since they are not parts of the MI.  Or did I miss something?

Doh! You're right: my brain wasn't fully functional. Let me revise: I will
document whatever I remember to document. Someone should scream at me if I
miss anything else! :-)

> Can we have completion on known interpreter names in these commands?  The
> default completer function completes on symbols from the inferior, which
> is really not a good idea in this case ;-)

I can certainly look into that...

Keith

Re: [RFC] GDB interpreters

[Keith Seitz]

On Tue, 21 May 2002, Keith Seitz wrote:

> Eli Zaretskii wrote:
>
> > Can we have completion on known interpreter names in these commands?  The
> > default completer function completes on symbols from the inferior, which
> > is really not a good idea in this case ;-)
>
> I can certainly look into that...

Ok, I admit, I know very little about the completer. However, I can copy
code as well as the next guy! :-)

How does this look? (This would be a patch for the file I posted
yesterday.)

Keith

*** interpreter.c.orig	Tue May 21 11:35:42 2002
--- interpreter.c	Tue May 21 11:35:46 2002
***************
*** 44,49 ****
--- 44,51 ----
  #include "event-loop.h"
  #include "event-top.h"
  #include "interpreter.h"
+ #include "completer.h"
+ #include "gdb_string.h"

  /* Functions local to this file. */
  static void initialize_interps (void);
*************** static void set_interpreter_cmd (char *a
*** 52,57 ****
--- 54,60 ----
  				 struct cmd_list_element *c);
  static void list_interpreter_cmd (char *args, int from_tty);
  static void do_set_interpreter (int not_an_fd);
+ static char **interpreter_completer (char *text, char *word);

  /* The magic initialization routine for this module. */

*************** interpreter_exec_cmd (char *args, int fr
*** 555,560 ****
--- 558,620 ----
    gdb_interpreter_set_quiet (interp_to_use, old_quiet);
  }

+ /* List the possible interpreters which could complete the given text. */
+
+ static char **
+ interpreter_completer (char *text, char *word)
+ {
+   int alloced, textlen;
+   int num_matches;
+   char **matches;
+   struct gdb_interpreter *interp;
+
+   /* We expect only a very limited number of interpreters, so just
+      allocate room for all of them. */
+   for (interp = interp_list; interp != NULL; interp = interp->next)
+     ++alloced;
+   matches = (char **) xmalloc (alloced * sizeof (char *));
+
+   num_matches = 0;
+   textlen = strlen (text);
+   for (interp = interp_list; interp != NULL; interp = interp->next)
+     {
+       if (strncmp (interp->name, text, textlen) == 0)
+ 	{
+ 	  matches[num_matches] =
+ 	    (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
+ 	  if (word == text)
+ 	    strcpy (matches[num_matches], interp->name);
+ 	  else if (word > text)
+ 	    {
+ 	      /* Return some portion of interp->name */
+ 	      strcpy (matches[num_matches], interp->name + (word - text));
+ 	    }
+ 	  else
+ 	    {
+ 	      /* Return some of text plus interp->name */
+ 	      strncpy (matches[num_matches], word, text - word);
+ 	      matches[num_matches][text - word] = '\0';
+ 	      strcat (matches[num_matches], interp->name);
+ 	    }
+ 	  ++num_matches;
+ 	}
+     }
+
+   if (num_matches == 0)
+     {
+       xfree (matches);
+       matches = NULL;
+     }
+   else if (num_matches < alloced)
+     {
+       matches = (char **) xrealloc ((char *) matches, ((num_matches + 1)
+ 						       * sizeof (char *)));
+       matches[num_matches] = NULL;
+     }
+
+   return matches;
+ }
+
  /* _initialize_interpreter - This just adds the "set interpreter" and
   * "info interpreters" commands.
   */
*************** _initialize_interpreter (void)
*** 574,582 ****
  	   list_interpreter_cmd,
  	   "List the interpreters currently available in gdb.", &infolist);

!   add_cmd ("interpreter-exec", class_support,
  	   interpreter_exec_cmd,
  	   "Execute a command in an interpreter.  It takes two arguments:\n\
  The first argument is the name of the interpreter to use.\n\
  The second argument is the command to execute.\n", &cmdlist);
  }
--- 634,643 ----
  	   list_interpreter_cmd,
  	   "List the interpreters currently available in gdb.", &infolist);

!   c = add_cmd ("interpreter-exec", class_support,
  	       interpreter_exec_cmd,
  	       "Execute a command in an interpreter.  It takes two arguments:\n\
  The first argument is the name of the interpreter to use.\n\
  The second argument is the command to execute.\n", &cmdlist);
+   set_cmd_completer (c, interpreter_completer);
  }

Re: [RFC] GDB interpreters

[Eli Zaretskii]

> Date: Tue, 21 May 2002 11:34:29 -0700 (PDT)
> From: Keith Seitz <keiths@redhat.com>
> 
> How does this look?

It looks good to me, but unfortunately I cannot really apply the patch
and try it.  I truist that you've tested it, and that it works,
though.

Thanks!

Re: [RFC] GDB interpreters

[Andrew Cagney]

> On Tue, 21 May 2002, Keith Seitz wrote:
> 
> 
>> Eli Zaretskii wrote:
>>
> 
>> > Can we have completion on known interpreter names in these commands?  The
>> > default completer function completes on symbols from the inferior, which
>> > is really not a good idea in this case ;-)
> 
>>
>> I can certainly look into that...
> 
> 
> Ok, I admit, I know very little about the completer. However, I can copy
> code as well as the next guy! :-)
> 
> How does this look? (This would be a patch for the file I posted
> yesterday.)

Hmm, I've now twice seen the same problem - a completer for a changing 
(growing) list of options.  (JimI had it with a C++ command he was adding).

Can I suggest creating a bug report noteing this limitation in the cli 
interface.

enjoy,
Andrew

Re: [RFC] GDB interpreters

[Andrew Cagney]

> I will be adding documentation for the MI part of the GDB manual and I
> will be writing testsuites to cover all this. That aside, it is a
> non-trivial change to all sorts of things in gdb to get this working. I
> thought I would start with this and work my way out to other, more
> invasive changes.

Do you have a [working] draft?  It is hard to see how it hangs together 
with out some additional context.  Consider doing what I did and drop 
the work in progress onto a branch.

The things I'm wondering about are:

- how the ``struct gdb_interpreter'' gets called (can it be opaque?). 
There is a comment talking about how it is tied into the event loop.

- what goes with hooks (I get the feeling that it is caught in the 
middle between ..._hook and gdb-event*)

I think, though, it is basicly fine.

Andrew

BTW: Some quick coding cleanups you've had handed down.  I'll try to get 
the comment one added to the ARI.

Perhaphs consider a name other than interpreter.[hc].  Something to 
reflect that this isn't ``the'' interpreter but rather a part of the 
interpreters.  terps? :-^  interps?


> static struct gdb_interpreter *interp_list = NULL;
> static struct gdb_interpreter *current = NULL;

Suggest ``current_interpreter''.

> static int initialized = 0;

Same.

> /* gdb_new_interpreter - This allocates space for a new interpreter,
>  * fills the fields from the inputs, and returns a pointer to the
>  * interpreter. */

I think it is ment to be:

/* .....
    ..... */

i.e. no `*' on each line.

--

Re: [RFC] GDB interpreters

[Keith Seitz]

On Fri, 24 May 2002, Andrew Cagney wrote:

> Do you have a [working] draft?  It is hard to see how it hangs together
> with out some additional context.  Consider doing what I did and drop
> the work in progress onto a branch.

Yeah, I've got a massive set of changes that a compilation of this from
Apple and some of my own changes. (Most of my own changes are just
cosmetic: move things to separate files and whatnot. Apple crammed
everything in mi-main.c)

> The things I'm wondering about are:
>
> - how the ``struct gdb_interpreter'' gets called (can it be opaque?).
> There is a comment talking about how it is tied into the event loop.

These are completely opaque. Although Apple has a public definition of it
in interpreter.h, I was going to move it into interpreter.c. The only way
the code accessing this structure is via accessor functions
(gdb_interpreter_display_prompt, gdb_interpreter_set_quiet, etc).

> - what goes with hooks (I get the feeling that it is caught in the
> middle between ..._hook and gdb-event*)

Apple is using only hooks. It was my intent to swap it all to events, so
that all of the events/hooks are located in one place.

> Perhaphs consider a name other than interpreter.[hc].  Something to
> reflect that this isn't ``the'' interpreter but rather a part of the
> interpreters.  terps? :-^  interps?

Ok, I think that's valid: interps.h and interps.c (unless I hear
otherwise).

> > static struct gdb_interpreter *interp_list = NULL;
> > static struct gdb_interpreter *current = NULL;
>
> Suggest ``current_interpreter''.

Very good.

> > static int initialized = 0;
>
> Same.

Ok.

>
> > /* gdb_new_interpreter - This allocates space for a new interpreter,
> >  * fills the fields from the inputs, and returns a pointer to the
> >  * interpreter. */
>
> I think it is ment to be:
>
> /* .....
>     ..... */
>
> i.e. no `*' on each line.

Yes. Hmm. Does gdb_indent.sh catch this? I though I ran it on the files
before submitting them. Oh well, no matter. I'll double check for this.

Thanks for the comments.
Keith

Re: [RFC] GDB interpreters

[Keith Seitz]

On Fri, 24 May 2002, Andrew Cagney wrote:

> Do you have a [working] draft?  It is hard to see how it hangs together
> with out some additional context.  Consider doing what I did and drop
> the work in progress onto a branch.

I've checked everything into a branch, kseitz_interps-20020528-branch. You
can simply check it out and try to play with it.

Keith