gdb/mi/mi-parse.c - binutils-gdb - Git at Google

 /* MI Command Set - MI parser.

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

   /* For new argv commands, attempt to return the parsed argument
      list.  */
   if (parse->cmd->argv_func != NULL)
     {
       mi_parse_argv (chp, parse.get ());
       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);

   /* 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);
 }
	/* MI Command Set - MI parser.

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

	/* For new argv commands, attempt to return the parsed argument
	list. */
	if (parse->cmd->argv_func != NULL)
	{
	mi_parse_argv (chp, parse.get ());
	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);

	/* 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);
	}