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

/* MI Command Set - MI parser.

   Copyright (C) 2000-2022 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;
}

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 (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;
    }
}

mi_parse::mi_parse ()
  : op (MI_COMMAND),
    command (NULL),
    token (NULL),
    cmd (NULL),
    cmd_start (NULL),
    args (NULL),
    argv (NULL),
    argc (0),
    all (0),
    thread_group (-1),
    thread (-1),
    frame (-1),
    language (language_unknown)
{
}

mi_parse::~mi_parse ()
{
  xfree (command);
  xfree (token);
  xfree (args);
  freeargv (argv);
}

std::unique_ptr<struct mi_parse>
mi_parse (const char *cmd, char **token)
{
  const char *chp;

  std::unique_ptr<struct mi_parse> parse (new struct mi_parse);

  /* Before starting, skip leading white space.  */
  cmd = skip_spaces (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 (chp);
      parse->command = xstrdup (chp);
      parse->op = CLI_COMMAND;

      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_cmd_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 (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)
	{
	  option = "--language";
	  chp += ls;
	  std::string lang_name = extract_arg (&chp);

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

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

  /* Save the rest of the arguments for the command.  */
  parse->args = xstrdup (chp);

  /* 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
4a94e368	3	Copyright (C) 2000-2022 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
1f6c8c33	109	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. */
f1735a53	122	chp = skip_spaces (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
4d89769a TT	211	mi_parse::mi_parse ()
	212	: op (MI_COMMAND),
	213	command (NULL),
	214	token (NULL),
	215	cmd (NULL),
	216	cmd_start (NULL),
	217	args (NULL),
	218	argv (NULL),
	219	argc (0),
	220	all (0),
	221	thread_group (-1),
	222	thread (-1),
	223	frame (-1),
	224	language (language_unknown)
fb40c209	225	{
fb40c209 AC	226	}
fb40c209 AC	227
4d89769a	228	mi_parse::~mi_parse ()
305aeedc	229	{
4d89769a TT	230	xfree (command);
	231	xfree (token);
	232	xfree (args);
	233	freeargv (argv);
305aeedc	234	}
fb40c209	235
4d89769a	236	std::unique_ptr<struct mi_parse>
ee047554	237	mi_parse (const char cmd, char *token)
fb40c209	238	{
ee047554	239	const char *chp;
102040f0	240
4d89769a	241	std::unique_ptr<struct mi_parse> parse (new struct mi_parse);
305aeedc	242
2b03b41d	243	/* Before starting, skip leading white space. */
f1735a53	244	cmd = skip_spaces (cmd);
fb40c209	245
2b03b41d	246	/* Find/skip any token and then extract it. */
fb40c209 AC	247	for (chp = cmd; chp >= '0' && chp <= '9'; chp++)
fb40c209 AC	248	;
224c3ddb	249	token = (char ) xmalloc (chp - cmd + 1);
305aeedc TT	250	memcpy (*token, cmd, (chp - cmd));
305aeedc TT	251	(*token)[chp - cmd] = '\0';
fb40c209	252
2b03b41d	253	/* This wasn't a real MI command. Return it as a CLI_COMMAND. */
fb40c209 AC	254	if (*chp != '-')
fb40c209 AC	255	{
f1735a53	256	chp = skip_spaces (chp);
fb40c209 AC	257	parse->command = xstrdup (chp);
fb40c209 AC	258	parse->op = CLI_COMMAND;
305aeedc	259
fb40c209 AC	260	return parse;
	261	}
	262
2b03b41d	263	/* Extract the command. */
fb40c209	264	{
ee047554	265	const char tmp = chp + 1; / discard ``-'' */
102040f0	266
fb40c209 AC	267	for (; chp && !isspace (chp); chp++)
fb40c209 AC	268	;
224c3ddb	269	parse->command = (char *) xmalloc (chp - tmp + 1);
fb40c209 AC	270	memcpy (parse->command, tmp, chp - tmp);
	271	parse->command[chp - tmp] = '\0';
	272	}
	273
2b03b41d	274	/* Find the command in the MI table. */
3524a83e	275	parse->cmd = mi_cmd_lookup (parse->command);
fb40c209	276	if (parse->cmd == NULL)
2ea126fa JB	277	throw_error (UNDEFINED_COMMAND_ERROR,
2ea126fa JB	278	_("Undefined MI command: %s"), parse->command);
fb40c209	279
2b03b41d	280	/* Skip white space following the command. */
f1735a53	281	chp = skip_spaces (chp);
fb40c209	282
1e92afda	283	/* Parse the --thread and --frame options, if present. At present,
2b03b41d SS	284	some important commands, like '-break-*' are implemented by
	285	forwarding to the CLI layer directly. We want to parse --thread
	286	and --frame here, so as not to leave those option in the string
403cb6b1 JB	287	that will be passed to CLI.
	288
	289	Same for the --language option. */
	290
1e92afda VP	291	for (;;)
1e92afda VP	292	{
30a7f059	293	const char *option;
a79b8f6e VP	294	size_t as = sizeof ("--all ") - 1;
a79b8f6e VP	295	size_t tgs = sizeof ("--thread-group ") - 1;
1e92afda VP	296	size_t ts = sizeof ("--thread ") - 1;
1e92afda VP	297	size_t fs = sizeof ("--frame ") - 1;
403cb6b1	298	size_t ls = sizeof ("--language ") - 1;
102040f0	299
a79b8f6e VP	300	if (strncmp (chp, "--all ", as) == 0)
	301	{
	302	parse->all = 1;
	303	chp += as;
	304	}
	305	/* See if --all is the last token in the input. */
	306	if (strcmp (chp, "--all") == 0)
	307	{
dda83cd7 SM	308	parse->all = 1;
	309	chp += strlen (chp);
	310	}
a79b8f6e VP	311	if (strncmp (chp, "--thread-group ", tgs) == 0)
a79b8f6e VP	312	{
ee047554 KS	313	char *endp;
ee047554 KS	314
30a7f059	315	option = "--thread-group";
a79b8f6e VP	316	if (parse->thread_group != -1)
	317	error (_("Duplicate '--thread-group' option"));
	318	chp += tgs;
	319	if (*chp != 'i')
	320	error (_("Invalid thread group id"));
	321	chp += 1;
ee047554 KS	322	parse->thread_group = strtol (chp, &endp, 10);
ee047554 KS	323	chp = endp;
a79b8f6e	324	}
8e0e408a	325	else if (strncmp (chp, "--thread ", ts) == 0)
1e92afda	326	{
ee047554 KS	327	char *endp;
ee047554 KS	328
30a7f059	329	option = "--thread";
1e92afda	330	if (parse->thread != -1)
a79b8f6e	331	error (_("Duplicate '--thread' option"));
1e92afda	332	chp += ts;
ee047554 KS	333	parse->thread = strtol (chp, &endp, 10);
ee047554 KS	334	chp = endp;
1e92afda VP	335	}
	336	else if (strncmp (chp, "--frame ", fs) == 0)
	337	{
ee047554 KS	338	char *endp;
ee047554 KS	339
30a7f059	340	option = "--frame";
1e92afda	341	if (parse->frame != -1)
a79b8f6e	342	error (_("Duplicate '--frame' option"));
1e92afda	343	chp += fs;
ee047554 KS	344	parse->frame = strtol (chp, &endp, 10);
ee047554 KS	345	chp = endp;
1e92afda	346	}
403cb6b1 JB	347	else if (strncmp (chp, "--language ", ls) == 0)
403cb6b1 JB	348	{
403cb6b1 JB	349	option = "--language";
403cb6b1 JB	350	chp += ls;
cb791d59	351	std::string lang_name = extract_arg (&chp);
403cb6b1	352
cb791d59	353	parse->language = language_enum (lang_name.c_str ());
403cb6b1 JB	354	if (parse->language == language_unknown
403cb6b1 JB	355	\|\| parse->language == language_auto)
cb791d59	356	error (_("Invalid --language argument: %s"), lang_name.c_str ());
403cb6b1	357	}
1e92afda VP	358	else
	359	break;
	360
	361	if (chp != '\0' && !isspace (chp))
30a7f059	362	error (_("Invalid value for the '%s' option"), option);
f1735a53	363	chp = skip_spaces (chp);
1e92afda VP	364	}
1e92afda VP	365
1f6c8c33 JV	366	/* Save the rest of the arguments for the command. */
1f6c8c33 JV	367	parse->args = xstrdup (chp);
fb40c209	368
2b03b41d	369	/* Fully parsed, flag as an MI command. */
fb40c209 AC	370	parse->op = MI_COMMAND;
	371	return parse;
	372	}
87967e27 YQ	373
	374	enum print_values
	375	mi_parse_print_values (const char *name)
	376	{
	377	if (strcmp (name, "0") == 0
	378	\|\| strcmp (name, mi_no_values) == 0)
	379	return PRINT_NO_VALUES;
	380	else if (strcmp (name, "1") == 0
	381	\|\| strcmp (name, mi_all_values) == 0)
	382	return PRINT_ALL_VALUES;
	383	else if (strcmp (name, "2") == 0
	384	\|\| strcmp (name, mi_simple_values) == 0)
	385	return PRINT_SIMPLE_VALUES;
	386	else
	387	error (_("Unknown value for PRINT_VALUES: must be: \
	388	0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	389	mi_no_values, mi_all_values, mi_simple_values);
	390	}