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

/* MI Command Set - MI parser.

   Copyright (C) 2000-2016 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 "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 = XNEWVEC (char *, argc + 1);

  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 = XNEWVEC (char, len + 1);
	    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 = XNEWVEC (char, len + 1);
	    strncpy (arg, start, len);
	    arg[len] = '\0';
	    break;
	  }
	}
      /* Append arg to argv.  */
      argv = XRESIZEVEC (char *, argv, argc + 2);
      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 ((struct mi_parse *) arg);
}

struct mi_parse *
mi_parse (const char *cmd, char **token)
{
  const char *chp;
  struct mi_parse *parse = XNEW (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 = (char *) 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 = (char *) 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)
    throw_error (UNDEFINED_COMMAND_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
618f726f	3	Copyright (C) 2000-2016 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>
529480d0	28	#include "cli/cli-utils.h"
403cb6b1	29	#include "language.h"
fb40c209	30
44d100c3 TT	31	static const char mi_no_values[] = "--no-values";
	32	static const char mi_simple_values[] = "--simple-values";
	33	static const char mi_all_values[] = "--all-values";
87967e27	34
f870a310 TT	35	/* Like parse_escape, but leave the results as a host char, not a
	36	target char. */
	37
	38	static int
ee047554	39	mi_parse_escape (const char **string_ptr)
f870a310 TT	40	{
f870a310 TT	41	int c = (string_ptr)++;
102040f0	42
f870a310 TT	43	switch (c)
	44	{
	45	case '\n':
	46	return -2;
	47	case 0:
	48	(*string_ptr)--;
	49	return 0;
	50
	51	case '0':
	52	case '1':
	53	case '2':
	54	case '3':
	55	case '4':
	56	case '5':
	57	case '6':
	58	case '7':
	59	{
	60	int i = host_hex_value (c);
	61	int count = 0;
102040f0	62
f870a310 TT	63	while (++count < 3)
	64	{
	65	c = (**string_ptr);
	66	if (isdigit (c) && c != '8' && c != '9')
	67	{
	68	(*string_ptr)++;
	69	i *= 8;
	70	i += host_hex_value (c);
	71	}
	72	else
	73	{
	74	break;
	75	}
	76	}
	77	return i;
	78	}
	79
	80	case 'a':
	81	c = '\a';
	82	break;
	83	case 'b':
	84	c = '\b';
	85	break;
	86	case 'f':
	87	c = '\f';
	88	break;
	89	case 'n':
	90	c = '\n';
	91	break;
	92	case 'r':
	93	c = '\r';
	94	break;
	95	case 't':
	96	c = '\t';
	97	break;
	98	case 'v':
	99	c = '\v';
	100	break;
	101
	102	default:
	103	break;
	104	}
	105
	106	return c;
	107	}
	108
fb40c209	109	static void
ee047554	110	mi_parse_argv (const char args, struct mi_parse parse)
fb40c209	111	{
ee047554	112	const char *chp = args;
fb40c209	113	int argc = 0;
8d749320	114	char *argv = XNEWVEC (char , argc + 1);
102040f0	115
fb40c209 AC	116	argv[argc] = NULL;
	117	while (1)
	118	{
	119	char *arg;
102040f0	120
2b03b41d	121	/* Skip leading white space. */
ee047554	122	chp = skip_spaces_const (chp);
fb40c209 AC	123	/* Three possibilities: EOF, quoted string, or other text. */
	124	switch (*chp)
	125	{
	126	case '\0':
	127	parse->argv = argv;
	128	parse->argc = argc;
	129	return;
	130	case '"':
	131	{
2b03b41d	132	/* A quoted string. */
fb40c209	133	int len;
ee047554	134	const char *start = chp + 1;
102040f0	135
2b03b41d	136	/* Determine the buffer size. */
fb40c209 AC	137	chp = start;
	138	len = 0;
	139	while (chp != '\0' && chp != '"')
	140	{
	141	if (*chp == '\\')
	142	{
	143	chp++;
f870a310	144	if (mi_parse_escape (&chp) <= 0)
fb40c209	145	{
2b03b41d	146	/* Do not allow split lines or "\000". */
fb40c209 AC	147	freeargv (argv);
	148	return;
	149	}
	150	}
	151	else
	152	chp++;
	153	len++;
	154	}
2b03b41d	155	/* Insist on a closing quote. */
fb40c209 AC	156	if (*chp != '"')
	157	{
	158	freeargv (argv);
	159	return;
	160	}
2b03b41d	161	/* Insist on trailing white space. */
fb40c209 AC	162	if (chp[1] != '\0' && !isspace (chp[1]))
	163	{
	164	freeargv (argv);
	165	return;
	166	}
2b03b41d	167	/* Create the buffer and copy characters in. */
224c3ddb	168	arg = XNEWVEC (char, len + 1);
fb40c209 AC	169	chp = start;
	170	len = 0;
	171	while (chp != '\0' && chp != '"')
	172	{
	173	if (*chp == '\\')
	174	{
	175	chp++;
f870a310	176	arg[len] = mi_parse_escape (&chp);
fb40c209 AC	177	}
	178	else
	179	arg[len] = *chp++;
	180	len++;
	181	}
	182	arg[len] = '\0';
2b03b41d	183	chp++; /* That closing quote. */
fb40c209 AC	184	break;
	185	}
	186	default:
	187	{
2b03b41d SS	188	/* An unquoted string. Accumulate all non-blank
2b03b41d SS	189	characters into a buffer. */
fb40c209	190	int len;
ee047554	191	const char *start = chp;
102040f0	192
fb40c209 AC	193	while (chp != '\0' && !isspace (chp))
	194	{
	195	chp++;
	196	}
	197	len = chp - start;
224c3ddb	198	arg = XNEWVEC (char, len + 1);
fb40c209 AC	199	strncpy (arg, start, len);
	200	arg[len] = '\0';
	201	break;
	202	}
	203	}
2b03b41d	204	/* Append arg to argv. */
224c3ddb	205	argv = XRESIZEVEC (char *, argv, argc + 2);
fb40c209 AC	206	argv[argc++] = arg;
	207	argv[argc] = NULL;
	208	}
	209	}
	210
fb40c209 AC	211	void
	212	mi_parse_free (struct mi_parse *parse)
	213	{
	214	if (parse == NULL)
	215	return;
	216	if (parse->command != NULL)
b8c9b27d	217	xfree (parse->command);
fb40c209	218	if (parse->token != NULL)
b8c9b27d	219	xfree (parse->token);
fb40c209	220	if (parse->args != NULL)
b8c9b27d	221	xfree (parse->args);
fb40c209 AC	222	if (parse->argv != NULL)
fb40c209 AC	223	freeargv (parse->argv);
b8c9b27d	224	xfree (parse);
fb40c209 AC	225	}
fb40c209 AC	226
305aeedc TT	227	/* A cleanup that calls mi_parse_free. */
	228
	229	static void
	230	mi_parse_cleanup (void *arg)
	231	{
19ba03f4	232	mi_parse_free ((struct mi_parse *) arg);
305aeedc	233	}
fb40c209 AC	234
fb40c209 AC	235	struct mi_parse *
ee047554	236	mi_parse (const char cmd, char *token)
fb40c209	237	{
ee047554	238	const char *chp;
70ba0933	239	struct mi_parse *parse = XNEW (struct mi_parse);
305aeedc	240	struct cleanup *cleanup;
102040f0	241
fb40c209	242	memset (parse, 0, sizeof (*parse));
a79b8f6e VP	243	parse->all = 0;
a79b8f6e VP	244	parse->thread_group = -1;
1e92afda VP	245	parse->thread = -1;
1e92afda VP	246	parse->frame = -1;
403cb6b1	247	parse->language = language_unknown;
fb40c209	248
305aeedc TT	249	cleanup = make_cleanup (mi_parse_cleanup, parse);
305aeedc TT	250
2b03b41d	251	/* Before starting, skip leading white space. */
ee047554	252	cmd = skip_spaces_const (cmd);
fb40c209	253
2b03b41d	254	/* Find/skip any token and then extract it. */
fb40c209 AC	255	for (chp = cmd; chp >= '0' && chp <= '9'; chp++)
fb40c209 AC	256	;
224c3ddb	257	token = (char ) xmalloc (chp - cmd + 1);
305aeedc TT	258	memcpy (*token, cmd, (chp - cmd));
305aeedc TT	259	(*token)[chp - cmd] = '\0';
fb40c209	260
2b03b41d	261	/* This wasn't a real MI command. Return it as a CLI_COMMAND. */
fb40c209 AC	262	if (*chp != '-')
fb40c209 AC	263	{
ee047554	264	chp = skip_spaces_const (chp);
fb40c209 AC	265	parse->command = xstrdup (chp);
fb40c209 AC	266	parse->op = CLI_COMMAND;
305aeedc TT	267
	268	discard_cleanups (cleanup);
	269
fb40c209 AC	270	return parse;
	271	}
	272
2b03b41d	273	/* Extract the command. */
fb40c209	274	{
ee047554	275	const char tmp = chp + 1; / discard ``-'' */
102040f0	276
fb40c209 AC	277	for (; chp && !isspace (chp); chp++)
fb40c209 AC	278	;
224c3ddb	279	parse->command = (char *) xmalloc (chp - tmp + 1);
fb40c209 AC	280	memcpy (parse->command, tmp, chp - tmp);
	281	parse->command[chp - tmp] = '\0';
	282	}
	283
2b03b41d	284	/* Find the command in the MI table. */
fb40c209 AC	285	parse->cmd = mi_lookup (parse->command);
fb40c209 AC	286	if (parse->cmd == NULL)
2ea126fa JB	287	throw_error (UNDEFINED_COMMAND_ERROR,
2ea126fa JB	288	_("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	}