GDB 7.6.50

libiberty/argv.c

 /* Create and destroy argument vectors (argv's)
-   Copyright (C) 1992, 2001, 2010 Free Software Foundation, Inc.
+   Copyright (C) 1992, 2001, 2010, 2012 Free Software Foundation, Inc.
    Written by Fred Fish @ Cygnus Support
 
 This file is part of the libiberty library.
 Libiberty is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 Libiberty is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 52 matching lines @@
 dupargv (char **argv)
 {
   int argc;
   char **copy;
   
   if (argv == NULL)
     return NULL;
   
   /* the vector */
   for (argc = 0; argv[argc] != NULL; argc++);
-  copy = (char **) malloc ((argc + 1) * sizeof (char *));
-  if (copy == NULL)
-    return NULL;
-  
+  copy = (char **) xmalloc ((argc + 1) * sizeof (char *));
+
   /* the strings */
   for (argc = 0; argv[argc] != NULL; argc++)
     {
       int len = strlen (argv[argc]);
-      copy[argc] = (char *) malloc (len + 1);
-      if (copy[argc] == NULL)
-        {
-          freeargv (copy);
-          return NULL;
-        }
+      copy[argc] = (char *) xmalloc (len + 1);
       strcpy (copy[argc], argv[argc]);
     }
   copy[argc] = NULL;
   return copy;
 }
 
 /*
 
 @deftypefn Extension void freeargv (char **@var{vector})
 
@@ skipping 43 matching lines @@
 @deftypefn Extension char** buildargv (char *@var{sp})
 
 Given a pointer to a string, parse the string extracting fields
 separated by whitespace and optionally enclosed within either single
 or double quotes (which are stripped off), and build a vector of
 pointers to copies of the string for each field.  The input string
 remains unchanged.  The last element of the vector is followed by a
 @code{NULL} element.
 
 All of the memory for the pointer array and copies of the string
-is obtained from @code{malloc}.  All of the memory can be returned to the
+is obtained from @code{xmalloc}.  All of the memory can be returned to the
 system with the single function call @code{freeargv}, which takes the
 returned result of @code{buildargv}, as it's argument.
 
 Returns a pointer to the argument vector if successful.  Returns
 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient
 memory to complete building the argument vector.
 
 If the input is a null string (as opposed to a @code{NULL} pointer),
 then buildarg returns an argument vector that has one arg, a null
 string.
@@ skipping 21 matching lines @@
   int squote = 0;
   int dquote = 0;
   int bsquote = 0;
   int argc = 0;
   int maxargc = 0;
   char **argv = NULL;
   char **nargv;
 
   if (input != NULL)
     {
-      copybuf = (char *) alloca (strlen (input) + 1);
+      copybuf = (char *) xmalloc (strlen (input) + 1);
       /* Is a do{}while to always execute the loop once.  Always return an
          argv, even for null strings.  See NOTES above, test case below. */
       do
         {
           /* Pick off argv[argc] */
           consume_whitespace (&input);
 
           if ((maxargc == 0) || (argc >= (maxargc - 1)))
             {
               /* argv needs initialization, or expansion */
               if (argv == NULL)
                 {
                   maxargc = INITIAL_MAXARGC;
-                  nargv = (char **) malloc (maxargc * sizeof (char *));
+                  nargv = (char **) xmalloc (maxargc * sizeof (char *));
                 }
               else
                 {
                   maxargc *= 2;
-                  nargv = (char **) realloc (argv, maxargc * sizeof (char *));
-                }
-              if (nargv == NULL)
-                {
-                  if (argv != NULL)
-                    {
-                      freeargv (argv);
-                      argv = NULL;
-                    }
-                  break;
+                  nargv = (char **) xrealloc (argv, maxargc * sizeof (char *));
                 }
               argv = nargv;
               argv[argc] = NULL;
             }
           /* Begin scanning arg */
           arg = copybuf;
           while (*input != EOS)
             {
               if (ISSPACE (*input) && !squote && !dquote && !bsquote)
                 {
@@ skipping 44 matching lines @@
                         }
                       else
                         {
                           *arg++ = *input;
                         }
                     }
                   input++;
                 }
             }
           *arg = EOS;
-          argv[argc] = strdup (copybuf);
-          if (argv[argc] == NULL)
-            {
-              freeargv (argv);
-              argv = NULL;
-              break;
-            }
+          argv[argc] = xstrdup (copybuf);
           argc++;
           argv[argc] = NULL;
 
           consume_whitespace (&input);
         }
       while (*input != EOS);
+
+      free (copybuf);
     }
   return (argv);
 }
 
 /*
 
 @deftypefn Extension int writeargv (const char **@var{argv}, FILE *@var{file})
 
 Write each member of ARGV, handling all necessary quoting, to the file
 named by FILE, separated by whitespace.  Return 0 on success, non-zero
@@ skipping 138 matching lines @@
       if (only_whitespace (buffer))
         {
           file_argv = (char **) xmalloc (sizeof (char *));
           file_argv[0] = NULL;
         }
       else
         /* Parse the string.  */
         file_argv = buildargv (buffer);
       /* If *ARGVP is not already dynamically allocated, copy it.  */
       if (!argv_dynamic)
-        {
-          *argvp = dupargv (*argvp);
-          if (!*argvp)
-            {
-              fputs ("\nout of memory\n", stderr);
-              xexit (1);
-            }
-        }
+        *argvp = dupargv (*argvp);
       /* Count the number of arguments.  */
       file_argc = 0;
       while (file_argv[file_argc])
         ++file_argc;
       /* Now, insert FILE_ARGV into ARGV.  The "+1" below handles the
          NULL terminator at the end of ARGV.  */ 
       *argvp = ((char **) 
                 xrealloc (*argvp, 
                           (*argcp + file_argc + 1) * sizeof (char *)));
       memmove (*argvp + i + file_argc, *argvp + i + 1, 
@@ skipping 82 matching lines @@
             }
           printf ("\n");
         }
       freeargv (argv);
     }
 
   return 0;
 }
 
 #endif  /* MAIN */