gdb/mi/mi-parse.c

   1 /* MI Command Set - MI parser.
   2
   3    Copyright (C) 2000-2013 Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Solutions (a Red Hat company).
   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
  11    the Free Software Foundation; either version 3 of the License, or
  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
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "mi-cmds.h"
  24 #include "mi-parse.h"
  25 #include "charset.h"
  26
  27 #include <ctype.h>
  28 #include "gdb_string.h"
  29 #include "cli/cli-utils.h"
  30
  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";
  34
  35 /* Like parse_escape, but leave the results as a host char, not a
  36    target char.  */
  37
  38 static int
  39 mi_parse_escape (const char **string_ptr)
  40 {
  41   int c = *(*string_ptr)++;
  42
  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;
  62
  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
 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 *));
 115
 116   argv[argc] = NULL;
 117   while (1)
 118     {
 119       char *arg;
 120
 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;
 135
 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;
 192
 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 }
 210
 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 }
 226
 227 /* A cleanup that calls mi_parse_free.  */
 228
 229 static void
 230 mi_parse_cleanup (void *arg)
 231 {
 232   mi_parse_free (arg);
 233 }
 234
 235 struct mi_parse *
 236 mi_parse (const char *cmd, char **token)
 237 {
 238   const char *chp;
 239   struct mi_parse *parse = XMALLOC (struct mi_parse);
 240   struct cleanup *cleanup;
 241
 242   memset (parse, 0, sizeof (*parse));
 243   parse->all = 0;
 244   parse->thread_group = -1;
 245   parse->thread = -1;
 246   parse->frame = -1;
 247
 248   cleanup = make_cleanup (mi_parse_cleanup, parse);
 249
 250   /* Before starting, skip leading white space.  */
 251   cmd = skip_spaces_const (cmd);
 252
 253   /* Find/skip any token and then extract it.  */
 254   for (chp = cmd; *chp >= '0' && *chp <= '9'; chp++)
 255     ;
 256   *token = xmalloc (chp - cmd + 1);
 257   memcpy (*token, cmd, (chp - cmd));
 258   (*token)[chp - cmd] = '\0';
 259
 260   /* This wasn't a real MI command.  Return it as a CLI_COMMAND.  */
 261   if (*chp != '-')
 262     {
 263       chp = skip_spaces_const (chp);
 264       parse->command = xstrdup (chp);
 265       parse->op = CLI_COMMAND;
 266
 267       discard_cleanups (cleanup);
 268
 269       return parse;
 270     }
 271
 272   /* Extract the command.  */
 273   {
 274     const char *tmp = chp + 1;  /* discard ``-'' */
 275
 276     for (; *chp && !isspace (*chp); chp++)
 277       ;
 278     parse->command = xmalloc (chp - tmp + 1);
 279     memcpy (parse->command, tmp, chp - tmp);
 280     parse->command[chp - tmp] = '\0';
 281   }
 282
 283   /* Find the command in the MI table.  */
 284   parse->cmd = mi_lookup (parse->command);
 285   if (parse->cmd == NULL)
 286     error (_("Undefined MI command: %s"), parse->command);
 287
 288   /* Skip white space following the command.  */
 289   chp = skip_spaces_const (chp);
 290
 291   /* Parse the --thread and --frame options, if present.  At present,
 292      some important commands, like '-break-*' are implemented by
 293      forwarding to the CLI layer directly.  We want to parse --thread
 294      and --frame here, so as not to leave those option in the string
 295      that will be passed to CLI.  */
 296   for (;;)
 297     {
 298       const char *option;
 299       size_t as = sizeof ("--all ") - 1;
 300       size_t tgs = sizeof ("--thread-group ") - 1;
 301       size_t ts = sizeof ("--thread ") - 1;
 302       size_t fs = sizeof ("--frame ") - 1;
 303
 304       if (strncmp (chp, "--all ", as) == 0)
 305         {
 306           parse->all = 1;
 307           chp += as;
 308         }
 309       /* See if --all is the last token in the input.  */
 310       if (strcmp (chp, "--all") == 0)
 311         {
 312           parse->all = 1;
 313           chp += strlen (chp);
 314         }
 315       if (strncmp (chp, "--thread-group ", tgs) == 0)
 316         {
 317           char *endp;
 318
 319           option = "--thread-group";
 320           if (parse->thread_group != -1)
 321             error (_("Duplicate '--thread-group' option"));
 322           chp += tgs;
 323           if (*chp != 'i')
 324             error (_("Invalid thread group id"));
 325           chp += 1;
 326           parse->thread_group = strtol (chp, &endp, 10);
 327           chp = endp;
 328         }
 329       else if (strncmp (chp, "--thread ", ts) == 0)
 330         {
 331           char *endp;
 332
 333           option = "--thread";
 334           if (parse->thread != -1)
 335             error (_("Duplicate '--thread' option"));
 336           chp += ts;
 337           parse->thread = strtol (chp, &endp, 10);
 338           chp = endp;
 339         }
 340       else if (strncmp (chp, "--frame ", fs) == 0)
 341         {
 342           char *endp;
 343
 344           option = "--frame";
 345           if (parse->frame != -1)
 346             error (_("Duplicate '--frame' option"));
 347           chp += fs;
 348           parse->frame = strtol (chp, &endp, 10);
 349           chp = endp;
 350         }
 351       else
 352         break;
 353
 354       if (*chp != '\0' && !isspace (*chp))
 355         error (_("Invalid value for the '%s' option"), option);
 356       chp = skip_spaces_const (chp);
 357     }
 358
 359   /* For new argv commands, attempt to return the parsed argument
 360      list.  */
 361   if (parse->cmd->argv_func != NULL)
 362     {
 363       mi_parse_argv (chp, parse);
 364       if (parse->argv == NULL)
 365         error (_("Problem parsing arguments: %s %s"), parse->command, chp);
 366     }
 367
 368   /* FIXME: DELETE THIS */
 369   /* For CLI commands, also return the remainder of the
 370      command line as a single string. */
 371   if (parse->cmd->cli.cmd != NULL)
 372     parse->args = xstrdup (chp);
 373
 374   discard_cleanups (cleanup);
 375
 376   /* Fully parsed, flag as an MI command.  */
 377   parse->op = MI_COMMAND;
 378   return parse;
 379 }
 380
 381 enum print_values
 382 mi_parse_print_values (const char *name)
 383 {
 384    if (strcmp (name, "0") == 0
 385        || strcmp (name, mi_no_values) == 0)
 386      return PRINT_NO_VALUES;
 387    else if (strcmp (name, "1") == 0
 388             || strcmp (name, mi_all_values) == 0)
 389      return PRINT_ALL_VALUES;
 390    else if (strcmp (name, "2") == 0
 391             || strcmp (name, mi_simple_values) == 0)
 392      return PRINT_SIMPLE_VALUES;
 393    else
 394      error (_("Unknown value for PRINT_VALUES: must be: \
 395 0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
 396             mi_no_values, mi_all_values, mi_simple_values);
 397 }