[thirdparty/binutils-gdb.git] / gdb / mi / mi-parse.c

/* MI Command Set - MI parser.

   Copyright (C) 2000-2013 Free Software Foundation, Inc.

   Contributed by Cygnus Solutions (a Red Hat company).

   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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "mi-cmds.h"
#include "mi-parse.h"
#include "charset.h"

#include <ctype.h>
#include <string.h>
#include "cli/cli-utils.h"
#include "language.h"

static const char mi_no_values[] = "--no-values";
static const char mi_simple_values[] = "--simple-values";
static const char mi_all_values[] = "--all-values";

/* Like parse_escape, but leave the results as a host char, not a
   target char.  */

static int
mi_parse_escape (const char **string_ptr)
{
  int c = *(*string_ptr)++;

  switch (c)
    {
      case '\n':
	return -2;
      case 0:
	(*string_ptr)--;
	return 0;

      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
	{
	  int i = host_hex_value (c);
	  int count = 0;

	  while (++count < 3)
	    {
	      c = (**string_ptr);
	      if (isdigit (c) && c != '8' && c != '9')
		{
		  (*string_ptr)++;
		  i *= 8;
		  i += host_hex_value (c);
		}
	      else
		{
		  break;
		}
	    }
	  return i;
	}

    case 'a':
      c = '\a';
      break;
    case 'b':
      c = '\b';
      break;
    case 'f':
      c = '\f';
      break;
    case 'n':
      c = '\n';
      break;
    case 'r':
      c = '\r';
      break;
    case 't':
      c = '\t';
      break;
    case 'v':
      c = '\v';
      break;

    default:
      break;
    }

  return c;
}

static void
mi_parse_argv (const char *args, struct mi_parse *parse)
{
  const char *chp = args;
  int argc = 0;
  char **argv = xmalloc ((argc + 1) * sizeof (char *));

  argv[argc] = NULL;
  while (1)
    {
      char *arg;

      /* Skip leading white space.  */
      chp = skip_spaces_const (chp);
      /* Three possibilities: EOF, quoted string, or other text. */
      switch (*chp)
	{
	case '\0':
	  parse->argv = argv;
	  parse->argc = argc;
	  return;
	case '"':
	  {
	    /* A quoted string.  */
	    int len;
	    const char *start = chp + 1;

	    /* Determine the buffer size.  */
	    chp = start;
	    len = 0;
	    while (*chp != '\0' && *chp != '"')
	      {
		if (*chp == '\\')
		  {
		    chp++;
		    if (mi_parse_escape (&chp) <= 0)
		      {
			/* Do not allow split lines or "\000".  */
			freeargv (argv);
			return;
		      }
		  }
		else
		  chp++;
		len++;
	      }
	    /* Insist on a closing quote.  */
	    if (*chp != '"')
	      {
		freeargv (argv);
		return;
	      }
	    /* Insist on trailing white space.  */
	    if (chp[1] != '\0' && !isspace (chp[1]))
	      {
		freeargv (argv);
		return;
	      }
	    /* Create the buffer and copy characters in.  */
	    arg = xmalloc ((len + 1) * sizeof (char));
	    chp = start;
	    len = 0;
	    while (*chp != '\0' && *chp != '"')
	      {
		if (*chp == '\\')
		  {
		    chp++;
		    arg[len] = mi_parse_escape (&chp);
		  }
		else
		  arg[len] = *chp++;
		len++;
	      }
	    arg[len] = '\0';
	    chp++;		/* That closing quote.  */
	    break;
	  }
	default:
	  {
	    /* An unquoted string.  Accumulate all non-blank
	       characters into a buffer.  */
	    int len;
	    const char *start = chp;

	    while (*chp != '\0' && !isspace (*chp))
	      {
		chp++;
	      }
	    len = chp - start;
	    arg = xmalloc ((len + 1) * sizeof (char));
	    strncpy (arg, start, len);
	    arg[len] = '\0';
	    break;
	  }
	}
      /* Append arg to argv.  */
      argv = xrealloc (argv, (argc + 2) * sizeof (char *));
      argv[argc++] = arg;
      argv[argc] = NULL;
    }
}

void
mi_parse_free (struct mi_parse *parse)
{
  if (parse == NULL)
    return;
  if (parse->command != NULL)
    xfree (parse->command);
  if (parse->token != NULL)
    xfree (parse->token);
  if (parse->args != NULL)
    xfree (parse->args);
  if (parse->argv != NULL)
    freeargv (parse->argv);
  xfree (parse);
}

/* A cleanup that calls mi_parse_free.  */

static void
mi_parse_cleanup (void *arg)
{
  mi_parse_free (arg);
}

struct mi_parse *
mi_parse (const char *cmd, char **token)
{
  const char *chp;
  struct mi_parse *parse = XMALLOC (struct mi_parse);
  struct cleanup *cleanup;

  memset (parse, 0, sizeof (*parse));
  parse->all = 0;
  parse->thread_group = -1;
  parse->thread = -1;
  parse->frame = -1;
  parse->language = language_unknown;

  cleanup = make_cleanup (mi_parse_cleanup, parse);

  /* Before starting, skip leading white space.  */
  cmd = skip_spaces_const (cmd);

  /* Find/skip any token and then extract it.  */
  for (chp = cmd; *chp >= '0' && *chp <= '9'; chp++)
    ;
  *token = xmalloc (chp - cmd + 1);
  memcpy (*token, cmd, (chp - cmd));
  (*token)[chp - cmd] = '\0';

  /* This wasn't a real MI command.  Return it as a CLI_COMMAND.  */
  if (*chp != '-')
    {
      chp = skip_spaces_const (chp);
      parse->command = xstrdup (chp);
      parse->op = CLI_COMMAND;

      discard_cleanups (cleanup);

      return parse;
    }

  /* Extract the command.  */
  {
    const char *tmp = chp + 1;	/* discard ``-'' */

    for (; *chp && !isspace (*chp); chp++)
      ;
    parse->command = xmalloc (chp - tmp + 1);
    memcpy (parse->command, tmp, chp - tmp);
    parse->command[chp - tmp] = '\0';
  }

  /* Find the command in the MI table.  */
  parse->cmd = mi_lookup (parse->command);
  if (parse->cmd == NULL)
    error (_("Undefined MI command: %s"), parse->command);

  /* Skip white space following the command.  */
  chp = skip_spaces_const (chp);

  /* Parse the --thread and --frame options, if present.  At present,
     some important commands, like '-break-*' are implemented by
     forwarding to the CLI layer directly.  We want to parse --thread
     and --frame here, so as not to leave those option in the string
     that will be passed to CLI.

     Same for the --language option.  */

  for (;;)
    {
      const char *option;
      size_t as = sizeof ("--all ") - 1;
      size_t tgs = sizeof ("--thread-group ") - 1;
      size_t ts = sizeof ("--thread ") - 1;
      size_t fs = sizeof ("--frame ") - 1;
      size_t ls = sizeof ("--language ") - 1;

      if (strncmp (chp, "--all ", as) == 0)
	{
	  parse->all = 1;
	  chp += as;
	}
      /* See if --all is the last token in the input.  */
      if (strcmp (chp, "--all") == 0)
	{
          parse->all = 1;
          chp += strlen (chp);
        }
      if (strncmp (chp, "--thread-group ", tgs) == 0)
	{
	  char *endp;

	  option = "--thread-group";
	  if (parse->thread_group != -1)
	    error (_("Duplicate '--thread-group' option"));
	  chp += tgs;
	  if (*chp != 'i')
	    error (_("Invalid thread group id"));
	  chp += 1;
	  parse->thread_group = strtol (chp, &endp, 10);
	  chp = endp;
	}
      else if (strncmp (chp, "--thread ", ts) == 0)
	{
	  char *endp;

	  option = "--thread";
	  if (parse->thread != -1)
	    error (_("Duplicate '--thread' option"));
	  chp += ts;
	  parse->thread = strtol (chp, &endp, 10);
	  chp = endp;
	}
      else if (strncmp (chp, "--frame ", fs) == 0)
	{
	  char *endp;

	  option = "--frame";
	  if (parse->frame != -1)
	    error (_("Duplicate '--frame' option"));
	  chp += fs;
	  parse->frame = strtol (chp, &endp, 10);
	  chp = endp;
	}
      else if (strncmp (chp, "--language ", ls) == 0)
	{
	  char *lang_name;
	  struct cleanup *old_chain;

	  option = "--language";
	  chp += ls;
	  lang_name = extract_arg_const (&chp);
	  old_chain = make_cleanup (xfree, lang_name);

	  parse->language = language_enum (lang_name);
	  if (parse->language == language_unknown
	      || parse->language == language_auto)
	    error (_("Invalid --language argument: %s"), lang_name);

	  do_cleanups (old_chain);
	}
      else
	break;

      if (*chp != '\0' && !isspace (*chp))
	error (_("Invalid value for the '%s' option"), option);
      chp = skip_spaces_const (chp);
    }

  /* For new argv commands, attempt to return the parsed argument
     list.  */
  if (parse->cmd->argv_func != NULL)
    {
      mi_parse_argv (chp, parse);
      if (parse->argv == NULL)
	error (_("Problem parsing arguments: %s %s"), parse->command, chp);
    }

  /* FIXME: DELETE THIS */
  /* For CLI commands, also return the remainder of the
     command line as a single string. */
  if (parse->cmd->cli.cmd != NULL)
    parse->args = xstrdup (chp);

  discard_cleanups (cleanup);

  /* Fully parsed, flag as an MI command.  */
  parse->op = MI_COMMAND;
  return parse;
}

enum print_values
mi_parse_print_values (const char *name)
{
   if (strcmp (name, "0") == 0
       || strcmp (name, mi_no_values) == 0)
     return PRINT_NO_VALUES;
   else if (strcmp (name, "1") == 0
	    || strcmp (name, mi_all_values) == 0)
     return PRINT_ALL_VALUES;
   else if (strcmp (name, "2") == 0
	    || strcmp (name, mi_simple_values) == 0)
     return PRINT_SIMPLE_VALUES;
   else
     error (_("Unknown value for PRINT_VALUES: must be: \
0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	    mi_no_values, mi_all_values, mi_simple_values);
}
Commit	Line	Data
fb40c209	1	/* MI Command Set - MI parser.
349c5d5f	2
28e7fd62	3	Copyright (C) 2000-2013 Free Software Foundation, Inc.
349c5d5f	4
ab91fdd5	5	Contributed by Cygnus Solutions (a Red Hat company).
fb40c209 AC	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
a9762ec7	11	the Free Software Foundation; either version 3 of the License, or
fb40c209 AC	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
a9762ec7	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
fb40c209 AC	21
	22	#include "defs.h"
	23	#include "mi-cmds.h"
	24	#include "mi-parse.h"
f870a310	25	#include "charset.h"
fb40c209 AC	26
fb40c209 AC	27	#include <ctype.h>
0e9f083f	28	#include <string.h>
529480d0	29	#include "cli/cli-utils.h"
403cb6b1	30	#include "language.h"
fb40c209	31
44d100c3 TT	32	static const char mi_no_values[] = "--no-values";
	33	static const char mi_simple_values[] = "--simple-values";
	34	static const char mi_all_values[] = "--all-values";
87967e27	35
f870a310 TT	36	/* Like parse_escape, but leave the results as a host char, not a
	37	target char. */
	38
	39	static int
ee047554	40	mi_parse_escape (const char **string_ptr)
f870a310 TT	41	{
f870a310 TT	42	int c = (string_ptr)++;
102040f0	43
f870a310 TT	44	switch (c)
	45	{
	46	case '\n':
	47	return -2;
	48	case 0:
	49	(*string_ptr)--;
	50	return 0;
	51
	52	case '0':
	53	case '1':
	54	case '2':
	55	case '3':
	56	case '4':
	57	case '5':
	58	case '6':
	59	case '7':
	60	{
	61	int i = host_hex_value (c);
	62	int count = 0;
102040f0	63
f870a310 TT	64	while (++count < 3)
	65	{
	66	c = (**string_ptr);
	67	if (isdigit (c) && c != '8' && c != '9')
	68	{
	69	(*string_ptr)++;
	70	i *= 8;
	71	i += host_hex_value (c);
	72	}
	73	else
	74	{
	75	break;
	76	}
	77	}
	78	return i;
	79	}
	80
	81	case 'a':
	82	c = '\a';
	83	break;
	84	case 'b':
	85	c = '\b';
	86	break;
	87	case 'f':
	88	c = '\f';
	89	break;
	90	case 'n':
	91	c = '\n';
	92	break;
	93	case 'r':
	94	c = '\r';
	95	break;
	96	case 't':
	97	c = '\t';
	98	break;
	99	case 'v':
	100	c = '\v';
	101	break;
	102
	103	default:
	104	break;
	105	}
	106
	107	return c;
	108	}
	109
fb40c209	110	static void
ee047554	111	mi_parse_argv (const char args, struct mi_parse parse)
fb40c209	112	{
ee047554	113	const char *chp = args;
fb40c209 AC	114	int argc = 0;
fb40c209 AC	115	char *argv = xmalloc ((argc + 1) sizeof (char *));
102040f0	116
fb40c209 AC	117	argv[argc] = NULL;
	118	while (1)
	119	{
	120	char *arg;
102040f0	121
2b03b41d	122	/* Skip leading white space. */
ee047554	123	chp = skip_spaces_const (chp);
fb40c209 AC	124	/* Three possibilities: EOF, quoted string, or other text. */
	125	switch (*chp)
	126	{
	127	case '\0':
	128	parse->argv = argv;
	129	parse->argc = argc;
	130	return;
	131	case '"':
	132	{
2b03b41d	133	/* A quoted string. */
fb40c209	134	int len;
ee047554	135	const char *start = chp + 1;
102040f0	136
2b03b41d	137	/* Determine the buffer size. */
fb40c209 AC	138	chp = start;
	139	len = 0;
	140	while (chp != '\0' && chp != '"')
	141	{
	142	if (*chp == '\\')
	143	{
	144	chp++;
f870a310	145	if (mi_parse_escape (&chp) <= 0)
fb40c209	146	{
2b03b41d	147	/* Do not allow split lines or "\000". */
fb40c209 AC	148	freeargv (argv);
	149	return;
	150	}
	151	}
	152	else
	153	chp++;
	154	len++;
	155	}
2b03b41d	156	/* Insist on a closing quote. */
fb40c209 AC	157	if (*chp != '"')
	158	{
	159	freeargv (argv);
	160	return;
	161	}
2b03b41d	162	/* Insist on trailing white space. */
fb40c209 AC	163	if (chp[1] != '\0' && !isspace (chp[1]))
	164	{
	165	freeargv (argv);
	166	return;
	167	}
2b03b41d	168	/* Create the buffer and copy characters in. */
fb40c209	169	arg = xmalloc ((len + 1) * sizeof (char));
fb40c209 AC	170	chp = start;
	171	len = 0;
	172	while (chp != '\0' && chp != '"')
	173	{
	174	if (*chp == '\\')
	175	{
	176	chp++;
f870a310	177	arg[len] = mi_parse_escape (&chp);
fb40c209 AC	178	}
	179	else
	180	arg[len] = *chp++;
	181	len++;
	182	}
	183	arg[len] = '\0';
2b03b41d	184	chp++; /* That closing quote. */
fb40c209 AC	185	break;
	186	}
	187	default:
	188	{
2b03b41d SS	189	/* An unquoted string. Accumulate all non-blank
2b03b41d SS	190	characters into a buffer. */
fb40c209	191	int len;
ee047554	192	const char *start = chp;
102040f0	193
fb40c209 AC	194	while (chp != '\0' && !isspace (chp))
	195	{
	196	chp++;
	197	}
	198	len = chp - start;
	199	arg = xmalloc ((len + 1) * sizeof (char));
	200	strncpy (arg, start, len);
	201	arg[len] = '\0';
	202	break;
	203	}
	204	}
2b03b41d	205	/* Append arg to argv. */
fb40c209 AC	206	argv = xrealloc (argv, (argc + 2) * sizeof (char *));
	207	argv[argc++] = arg;
	208	argv[argc] = NULL;
	209	}
	210	}
	211
fb40c209 AC	212	void
	213	mi_parse_free (struct mi_parse *parse)
	214	{
	215	if (parse == NULL)
	216	return;
	217	if (parse->command != NULL)
b8c9b27d	218	xfree (parse->command);
fb40c209	219	if (parse->token != NULL)
b8c9b27d	220	xfree (parse->token);
fb40c209	221	if (parse->args != NULL)
b8c9b27d	222	xfree (parse->args);
fb40c209 AC	223	if (parse->argv != NULL)
fb40c209 AC	224	freeargv (parse->argv);
b8c9b27d	225	xfree (parse);
fb40c209 AC	226	}
fb40c209 AC	227
305aeedc TT	228	/* A cleanup that calls mi_parse_free. */
	229
	230	static void
	231	mi_parse_cleanup (void *arg)
	232	{
	233	mi_parse_free (arg);
	234	}
fb40c209 AC	235
fb40c209 AC	236	struct mi_parse *
ee047554	237	mi_parse (const char cmd, char *token)
fb40c209	238	{
ee047554	239	const char *chp;
fb40c209	240	struct mi_parse *parse = XMALLOC (struct mi_parse);
305aeedc	241	struct cleanup *cleanup;
102040f0	242
fb40c209	243	memset (parse, 0, sizeof (*parse));
a79b8f6e VP	244	parse->all = 0;
a79b8f6e VP	245	parse->thread_group = -1;
1e92afda VP	246	parse->thread = -1;
1e92afda VP	247	parse->frame = -1;
403cb6b1	248	parse->language = language_unknown;
fb40c209	249
305aeedc TT	250	cleanup = make_cleanup (mi_parse_cleanup, parse);
305aeedc TT	251
2b03b41d	252	/* Before starting, skip leading white space. */
ee047554	253	cmd = skip_spaces_const (cmd);
fb40c209	254
2b03b41d	255	/* Find/skip any token and then extract it. */
fb40c209 AC	256	for (chp = cmd; chp >= '0' && chp <= '9'; chp++)
fb40c209 AC	257	;
38a714bb	258	*token = xmalloc (chp - cmd + 1);
305aeedc TT	259	memcpy (*token, cmd, (chp - cmd));
305aeedc TT	260	(*token)[chp - cmd] = '\0';
fb40c209	261
2b03b41d	262	/* This wasn't a real MI command. Return it as a CLI_COMMAND. */
fb40c209 AC	263	if (*chp != '-')
fb40c209 AC	264	{
ee047554	265	chp = skip_spaces_const (chp);
fb40c209 AC	266	parse->command = xstrdup (chp);
fb40c209 AC	267	parse->op = CLI_COMMAND;
305aeedc TT	268
	269	discard_cleanups (cleanup);
	270
fb40c209 AC	271	return parse;
	272	}
	273
2b03b41d	274	/* Extract the command. */
fb40c209	275	{
ee047554	276	const char tmp = chp + 1; / discard ``-'' */
102040f0	277
fb40c209 AC	278	for (; chp && !isspace (chp); chp++)
fb40c209 AC	279	;
38a714bb	280	parse->command = xmalloc (chp - tmp + 1);
fb40c209 AC	281	memcpy (parse->command, tmp, chp - tmp);
	282	parse->command[chp - tmp] = '\0';
	283	}
	284
2b03b41d	285	/* Find the command in the MI table. */
fb40c209 AC	286	parse->cmd = mi_lookup (parse->command);
fb40c209 AC	287	if (parse->cmd == NULL)
305aeedc	288	error (_("Undefined MI command: %s"), parse->command);
fb40c209	289
2b03b41d	290	/* Skip white space following the command. */
ee047554	291	chp = skip_spaces_const (chp);
fb40c209	292
1e92afda	293	/* Parse the --thread and --frame options, if present. At present,
2b03b41d SS	294	some important commands, like '-break-*' are implemented by
	295	forwarding to the CLI layer directly. We want to parse --thread
	296	and --frame here, so as not to leave those option in the string
403cb6b1 JB	297	that will be passed to CLI.
	298
	299	Same for the --language option. */
	300
1e92afda VP	301	for (;;)
1e92afda VP	302	{
30a7f059	303	const char *option;
a79b8f6e VP	304	size_t as = sizeof ("--all ") - 1;
a79b8f6e VP	305	size_t tgs = sizeof ("--thread-group ") - 1;
1e92afda VP	306	size_t ts = sizeof ("--thread ") - 1;
1e92afda VP	307	size_t fs = sizeof ("--frame ") - 1;
403cb6b1	308	size_t ls = sizeof ("--language ") - 1;
102040f0	309
a79b8f6e VP	310	if (strncmp (chp, "--all ", as) == 0)
	311	{
	312	parse->all = 1;
	313	chp += as;
	314	}
	315	/* See if --all is the last token in the input. */
	316	if (strcmp (chp, "--all") == 0)
	317	{
	318	parse->all = 1;
	319	chp += strlen (chp);
	320	}
	321	if (strncmp (chp, "--thread-group ", tgs) == 0)
	322	{
ee047554 KS	323	char *endp;
ee047554 KS	324
30a7f059	325	option = "--thread-group";
a79b8f6e VP	326	if (parse->thread_group != -1)
	327	error (_("Duplicate '--thread-group' option"));
	328	chp += tgs;
	329	if (*chp != 'i')
	330	error (_("Invalid thread group id"));
	331	chp += 1;
ee047554 KS	332	parse->thread_group = strtol (chp, &endp, 10);
ee047554 KS	333	chp = endp;
a79b8f6e	334	}
8e0e408a	335	else if (strncmp (chp, "--thread ", ts) == 0)
1e92afda	336	{
ee047554 KS	337	char *endp;
ee047554 KS	338
30a7f059	339	option = "--thread";
1e92afda	340	if (parse->thread != -1)
a79b8f6e	341	error (_("Duplicate '--thread' option"));
1e92afda	342	chp += ts;
ee047554 KS	343	parse->thread = strtol (chp, &endp, 10);
ee047554 KS	344	chp = endp;
1e92afda VP	345	}
	346	else if (strncmp (chp, "--frame ", fs) == 0)
	347	{
ee047554 KS	348	char *endp;
ee047554 KS	349
30a7f059	350	option = "--frame";
1e92afda	351	if (parse->frame != -1)
a79b8f6e	352	error (_("Duplicate '--frame' option"));
1e92afda	353	chp += fs;
ee047554 KS	354	parse->frame = strtol (chp, &endp, 10);
ee047554 KS	355	chp = endp;
1e92afda	356	}
403cb6b1 JB	357	else if (strncmp (chp, "--language ", ls) == 0)
	358	{
	359	char *lang_name;
	360	struct cleanup *old_chain;
	361
	362	option = "--language";
	363	chp += ls;
	364	lang_name = extract_arg_const (&chp);
	365	old_chain = make_cleanup (xfree, lang_name);
	366
	367	parse->language = language_enum (lang_name);
	368	if (parse->language == language_unknown
	369	\|\| parse->language == language_auto)
	370	error (_("Invalid --language argument: %s"), lang_name);
	371
	372	do_cleanups (old_chain);
	373	}
1e92afda VP	374	else
	375	break;
	376
	377	if (chp != '\0' && !isspace (chp))
30a7f059	378	error (_("Invalid value for the '%s' option"), option);
ee047554	379	chp = skip_spaces_const (chp);
1e92afda VP	380	}
1e92afda VP	381
fb40c209	382	/* For new argv commands, attempt to return the parsed argument
2b03b41d	383	list. */
fb40c209 AC	384	if (parse->cmd->argv_func != NULL)
	385	{
	386	mi_parse_argv (chp, parse);
	387	if (parse->argv == NULL)
305aeedc	388	error (_("Problem parsing arguments: %s %s"), parse->command, chp);
fb40c209 AC	389	}
	390
	391	/* FIXME: DELETE THIS */
9e22b03a	392	/* For CLI commands, also return the remainder of the
fb40c209	393	command line as a single string. */
9e22b03a VP	394	if (parse->cmd->cli.cmd != NULL)
9e22b03a VP	395	parse->args = xstrdup (chp);
fb40c209	396
305aeedc TT	397	discard_cleanups (cleanup);
305aeedc TT	398
2b03b41d	399	/* Fully parsed, flag as an MI command. */
fb40c209 AC	400	parse->op = MI_COMMAND;
	401	return parse;
	402	}
87967e27 YQ	403
	404	enum print_values
	405	mi_parse_print_values (const char *name)
	406	{
	407	if (strcmp (name, "0") == 0
	408	\|\| strcmp (name, mi_no_values) == 0)
	409	return PRINT_NO_VALUES;
	410	else if (strcmp (name, "1") == 0
	411	\|\| strcmp (name, mi_all_values) == 0)
	412	return PRINT_ALL_VALUES;
	413	else if (strcmp (name, "2") == 0
	414	\|\| strcmp (name, mi_simple_values) == 0)
	415	return PRINT_SIMPLE_VALUES;
	416	else
	417	error (_("Unknown value for PRINT_VALUES: must be: \
	418	0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	419	mi_no_values, mi_all_values, mi_simple_values);
	420	}