Merge GDB 7.5.1

gdb/mi/mi-parse.c

 /* MI Command Set - MI parser.
 
    Copyright (C) 2000-2002, 2007-2012 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
@@ skipping 95 matching lines @@
 {
   char *chp = args;
   int argc = 0;
   char **argv = xmalloc ((argc + 1) * sizeof (char *));
 
   argv[argc] = NULL;
   while (1)
     {
       char *arg;
 
-      /* skip leading white space */
+      /* Skip leading white space.  */
       while (isspace (*chp))
         chp++;
       /* Three possibilities: EOF, quoted string, or other text. */
       switch (*chp)
         {
         case '\0':
           parse->argv = argv;
           parse->argc = argc;
           return;
         case '"':
           {
-            /* A quoted string. */
+            /* A quoted string.  */
             int len;
             char *start = chp + 1;
 
-            /* Determine the buffer size. */
+            /* 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" */
+                        /* Do not allow split lines or "\000".  */
                         freeargv (argv);
                         return;
                       }
                   }
                 else
                   chp++;
                 len++;
               }
-            /* Insist on a closing quote. */
+            /* Insist on a closing quote.  */
             if (*chp != '"')
               {
                 freeargv (argv);
                 return;
               }
-            /* Insist on trailing white space. */
+            /* Insist on trailing white space.  */
             if (chp[1] != '\0' && !isspace (chp[1]))
               {
                 freeargv (argv);
                 return;
               }
-            /* create the buffer. */
+            /* Create the buffer and copy characters in.  */
             arg = xmalloc ((len + 1) * sizeof (char));
-            /* And copy the characters in. */
             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. */
+            chp++;              /* That closing quote.  */
             break;
           }
         default:
           {
-            /* An unquoted string.  Accumulate all non blank
-               characters into a buffer. */
+            /* An unquoted string.  Accumulate all non-blank
+               characters into a buffer.  */
             int len;
             char *start = chp;
 
             while (*chp != '\0' && !isspace (*chp))
               {
                 chp++;
               }
             len = chp - start;
             arg = xmalloc ((len + 1) * sizeof (char));
             strncpy (arg, start, len);
             arg[len] = '\0';
             break;
           }
         }
-      /* Append arg to argv. */
+      /* Append arg to argv.  */
       argv = xrealloc (argv, (argc + 2) * sizeof (char *));
       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)
@@ skipping 19 matching lines @@
   struct cleanup *cleanup;
 
   memset (parse, 0, sizeof (*parse));
   parse->all = 0;
   parse->thread_group = -1;
   parse->thread = -1;
   parse->frame = -1;
 
   cleanup = make_cleanup (mi_parse_cleanup, parse);
 
-  /* Before starting, skip leading white space. */
+  /* Before starting, skip leading white space.  */
   while (isspace (*cmd))
     cmd++;
 
-  /* Find/skip any token and then extract it. */
+  /* Find/skip any token and then extract it.  */
   for (chp = cmd; *chp >= '0' && *chp <= '9'; chp++)
     ;
   *token = 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. */
+  /* This wasn't a real MI command.  Return it as a CLI_COMMAND.  */
   if (*chp != '-')
     {
       while (isspace (*chp))
         chp++;
       parse->command = xstrdup (chp);
       parse->op = CLI_COMMAND;
 
       discard_cleanups (cleanup);
 
       return parse;
     }
 
-  /* Extract the command. */
+  /* Extract the command.  */
   {
     char *tmp = chp + 1;        /* discard ``-'' */
 
     for (; *chp && !isspace (*chp); chp++)
       ;
     parse->command = xmalloc (chp - tmp + 1);
     memcpy (parse->command, tmp, chp - tmp);
     parse->command[chp - tmp] = '\0';
   }
 
-  /* Find the command in the MI table. */
+  /* Find the command in the MI table.  */
   parse->cmd = mi_lookup (parse->command);
   if (parse->cmd == NULL)
     error (_("Undefined MI command: %s"), parse->command);
 
-  /* Skip white space following the command. */
+  /* Skip white space following the command.  */
   while (isspace (*chp))
     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.  */
+     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.  */
   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;
 
       if (strncmp (chp, "--all ", as) == 0)
         {
@@ skipping 36 matching lines @@
       else
         break;
 
       if (*chp != '\0' && !isspace (*chp))
         error (_("Invalid value for the '%s' option"), option);
       while (isspace (*chp))
         chp++;
     }
 
   /* For new argv commands, attempt to return the parsed argument
-     list. */
+     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. */
+  /* Fully parsed, flag as an MI command.  */
   parse->op = MI_COMMAND;
   return parse;
 }