gdb/mi/mi-parse.c - gdb

Global variables defined

Functions defined

Source code

  1. /* MI Command Set - MI parser.

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

  5.    Contributed by Cygnus Solutions (a Red Hat company).

  7.    This file is part of GDB.

  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
  11.    the Free Software Foundation; either version 3 of the License, or
  12.    (at your option) any later version.

  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.

  19.    You should have received a copy of the GNU General Public License
  20.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  22. #include "defs.h"
  23. #include "mi-cmds.h"
  24. #include "mi-parse.h"
  25. #include "charset.h"

  27. #include <ctype.h>
  28. #include "cli/cli-utils.h"
  29. #include "language.h"

  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";

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

  38. static int
  39. ‌mi_parse_escape (const char **string_ptr)
  40. {
  41.   int c = *(*string_ptr)++;

  43.   switch (c)
  44.     {
  45.       case '\n':
  46.         return -2;
  47.       case 0:
  48.         (*string_ptr)--;
  49.         return 0;

  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;

  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.         }

  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;

  102.     default:
  103.       break;
  104.     }

  106.   return c;
  107. }

  109. static void
  110. ‌mi_parse_argv (const char *args, struct mi_parse *parse)
  111. {
  112.   const char *chp = args;
  113.   int argc = 0;
  114.   char **argv = xmalloc ((argc + 1) * sizeof (char *));

  116.   argv[argc] = NULL;
  117.   while (1)
  118.     {
  119.       char *arg;

  121.       /* Skip leading white space.  */
  122.       chp = skip_spaces_const (chp);
  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.           {
  132.             /* A quoted string.  */
  133.             int len;
  134.             const char *start = chp + 1;

  136.             /* Determine the buffer size.  */
  137.             chp = start;
  138.             len = 0;
  139.             while (*chp != '\0' && *chp != '"')
  140.               {
  141.                 if (*chp == '\\')
  142.                   {
  143.                     chp++;
  144.                     if (mi_parse_escape (&chp) <= 0)
  145.                       {
  146.                         /* Do not allow split lines or "\000".  */
  147.                         freeargv (argv);
  148.                         return;
  149.                       }
  150.                   }
  151.                 else
  152.                   chp++;
  153.                 len++;
  154.               }
  155.             /* Insist on a closing quote.  */
  156.             if (*chp != '"')
  157.               {
  158.                 freeargv (argv);
  159.                 return;
  160.               }
  161.             /* Insist on trailing white space.  */
  162.             if (chp[1] != '\0' && !isspace (chp[1]))
  163.               {
  164.                 freeargv (argv);
  165.                 return;
  166.               }
  167.             /* Create the buffer and copy characters in.  */
  168.             arg = xmalloc ((len + 1) * sizeof (char));
  169.             chp = start;
  170.             len = 0;
  171.             while (*chp != '\0' && *chp != '"')
  172.               {
  173.                 if (*chp == '\\')
  174.                   {
  175.                     chp++;
  176.                     arg[len] = mi_parse_escape (&chp);
  177.                   }
  178.                 else
  179.                   arg[len] = *chp++;
  180.                 len++;
  181.               }
  182.             arg[len] = '\0';
  183.             chp++;                /* That closing quote.  */
  184.             break;
  185.           }
  186.         default:
  187.           {
  188.             /* An unquoted string.  Accumulate all non-blank
  189.                characters into a buffer.  */
  190.             int len;
  191.             const char *start = chp;

  193.             while (*chp != '\0' && !isspace (*chp))
  194.               {
  195.                 chp++;
  196.               }
  197.             len = chp - start;
  198.             arg = xmalloc ((len + 1) * sizeof (char));
  199.             strncpy (arg, start, len);
  200.             arg[len] = '\0';
  201.             break;
  202.           }
  203.         }
  204.       /* Append arg to argv.  */
  205.       argv = xrealloc (argv, (argc + 2) * sizeof (char *));
  206.       argv[argc++] = arg;
  207.       argv[argc] = NULL;
  208.     }
  209. }

  211. void
  212. ‌mi_parse_free (struct mi_parse *parse)
  213. {
  214.   if (parse == NULL)
  215.     return;
  216.   if (parse->command != NULL)
  217.     xfree (parse->command);
  218.   if (parse->token != NULL)
  219.     xfree (parse->token);
  220.   if (parse->args != NULL)
  221.     xfree (parse->args);
  222.   if (parse->argv != NULL)
  223.     freeargv (parse->argv);
  224.   xfree (parse);
  225. }

  227. /* A cleanup that calls mi_parse_free.  */

  229. static void
  230. ‌mi_parse_cleanup (void *arg)
  231. {
  232.   mi_parse_free (arg);
  233. }

  235. struct mi_parse *
  236. ‌mi_parse (const char *cmd, char **token)
  237. {
  238.   const char *chp;
  239.   struct mi_parse *parse = XNEW (struct mi_parse);
  240.   struct cleanup *cleanup;

  242.   memset (parse, 0, sizeof (*parse));
  243.   parse->all = 0;
  244.   parse->thread_group = -1;
  245.   parse->thread = -1;
  246.   parse->frame = -1;
  247.   parse->language = language_unknown;

  249.   cleanup = make_cleanup (mi_parse_cleanup, parse);

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

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

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

  268.       discard_cleanups (cleanup);

  270.       return parse;
  271.     }

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

  277.     for (; *chp && !isspace (*chp); chp++)
  278.       ;
  279.     parse->command = xmalloc (chp - tmp + 1);
  280.     memcpy (parse->command, tmp, chp - tmp);
  281.     parse->command[chp - tmp] = '\0';
  282.   }

  284.   /* Find the command in the MI table.  */
  285.   parse->cmd = mi_lookup (parse->command);
  286.   if (parse->cmd == NULL)
  287.     throw_error (UNDEFINED_COMMAND_ERROR,
  288.                  _("Undefined MI command: %s"), parse->command);

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

  293.   /* Parse the --thread and --frame options, if present.  At present,
  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
  297.      that will be passed to CLI.

  299.      Same for the --language option.  */

  301.   for (;;)
  302.     {
  303.       const char *option;
  304.       size_t as = sizeof ("--all ") - 1;
  305.       size_t tgs = sizeof ("--thread-group ") - 1;
  306.       size_t ts = sizeof ("--thread ") - 1;
  307.       size_t fs = sizeof ("--frame ") - 1;
  308.       size_t ls = sizeof ("--language ") - 1;

  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.         {
  323.           char *endp;

  325.           option = "--thread-group";
  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;
  332.           parse->thread_group = strtol (chp, &endp, 10);
  333.           chp = endp;
  334.         }
  335.       else if (strncmp (chp, "--thread ", ts) == 0)
  336.         {
  337.           char *endp;

  339.           option = "--thread";
  340.           if (parse->thread != -1)
  341.             error (_("Duplicate '--thread' option"));
  342.           chp += ts;
  343.           parse->thread = strtol (chp, &endp, 10);
  344.           chp = endp;
  345.         }
  346.       else if (strncmp (chp, "--frame ", fs) == 0)
  347.         {
  348.           char *endp;

  350.           option = "--frame";
  351.           if (parse->frame != -1)
  352.             error (_("Duplicate '--frame' option"));
  353.           chp += fs;
  354.           parse->frame = strtol (chp, &endp, 10);
  355.           chp = endp;
  356.         }
  357.       else if (strncmp (chp, "--language ", ls) == 0)
  358.         {
  359.           char *lang_name;
  360.           struct cleanup *old_chain;

  362.           option = "--language";
  363.           chp += ls;
  364.           lang_name = extract_arg_const (&chp);
  365.           old_chain = make_cleanup (xfree, lang_name);

  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);

  372.           do_cleanups (old_chain);
  373.         }
  374.       else
  375.         break;

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

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

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

  397.   discard_cleanups (cleanup);

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

  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. }