libiberty/argv.c

   1 /* Create and destroy argument vectors (argv's)
   2    Copyright (C) 1992, 2001 Free Software Foundation, Inc.
   3    Written by Fred Fish @ Cygnus Support
   4
   5 This file is part of the libiberty library.
   6 Libiberty is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at your option) any later version.
  10
  11 Libiberty is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with libiberty; see the file COPYING.LIB.  If
  18 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  19 Boston, MA 02110-1301, USA.  */
  20
  21
  22 /*  Create and destroy argument vectors.  An argument vector is simply an
  23     array of string pointers, terminated by a NULL pointer. */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28 #include "ansidecl.h"
  29 #include "libiberty.h"
  30 #include "safe-ctype.h"
  31
  32 /*  Routines imported from standard C runtime libraries. */
  33
  34 #include <stddef.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38
  39 #ifndef NULL
  40 #define NULL 0
  41 #endif
  42
  43 #ifndef EOS
  44 #define EOS '\0'
  45 #endif
  46
  47 #define INITIAL_MAXARGC 8       /* Number of args + NULL in initial argv */
  48
  49
  50 /*
  51
  52 @deftypefn Extension char** dupargv (char **@var{vector})
  53
  54 Duplicate an argument vector.  Simply scans through @var{vector},
  55 duplicating each argument until the terminating @code{NULL} is found.
  56 Returns a pointer to the argument vector if successful.  Returns
  57 @code{NULL} if there is insufficient memory to complete building the
  58 argument vector.
  59
  60 @end deftypefn
  61
  62 */
  63
  64 char **
  65 dupargv (char **argv)
  66 {
  67   int argc;
  68   char **copy;
  69
  70   if (argv == NULL)
  71     return NULL;
  72
  73   /* the vector */
  74   for (argc = 0; argv[argc] != NULL; argc++);
  75   copy = (char **) malloc ((argc + 1) * sizeof (char *));
  76   if (copy == NULL)
  77     return NULL;
  78
  79   /* the strings */
  80   for (argc = 0; argv[argc] != NULL; argc++)
  81     {
  82       int len = strlen (argv[argc]);
  83       copy[argc] = (char *) malloc (len + 1);
  84       if (copy[argc] == NULL)
  85         {
  86           freeargv (copy);
  87           return NULL;
  88         }
  89       strcpy (copy[argc], argv[argc]);
  90     }
  91   copy[argc] = NULL;
  92   return copy;
  93 }
  94
  95 /*
  96
  97 @deftypefn Extension void freeargv (char **@var{vector})
  98
  99 Free an argument vector that was built using @code{buildargv}.  Simply
 100 scans through @var{vector}, freeing the memory for each argument until
 101 the terminating @code{NULL} is found, and then frees @var{vector}
 102 itself.
 103
 104 @end deftypefn
 105
 106 */
 107
 108 void freeargv (char **vector)
 109 {
 110   register char **scan;
 111
 112   if (vector != NULL)
 113     {
 114       for (scan = vector; *scan != NULL; scan++)
 115         {
 116           free (*scan);
 117         }
 118       free (vector);
 119     }
 120 }
 121
 122 /*
 123
 124 @deftypefn Extension char** buildargv (char *@var{sp})
 125
 126 Given a pointer to a string, parse the string extracting fields
 127 separated by whitespace and optionally enclosed within either single
 128 or double quotes (which are stripped off), and build a vector of
 129 pointers to copies of the string for each field.  The input string
 130 remains unchanged.  The last element of the vector is followed by a
 131 @code{NULL} element.
 132
 133 All of the memory for the pointer array and copies of the string
 134 is obtained from @code{malloc}.  All of the memory can be returned to the
 135 system with the single function call @code{freeargv}, which takes the
 136 returned result of @code{buildargv}, as it's argument.
 137
 138 Returns a pointer to the argument vector if successful.  Returns
 139 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient
 140 memory to complete building the argument vector.
 141
 142 If the input is a null string (as opposed to a @code{NULL} pointer),
 143 then buildarg returns an argument vector that has one arg, a null
 144 string.
 145
 146 @end deftypefn
 147
 148 The memory for the argv array is dynamically expanded as necessary.
 149
 150 In order to provide a working buffer for extracting arguments into,
 151 with appropriate stripping of quotes and translation of backslash
 152 sequences, we allocate a working buffer at least as long as the input
 153 string.  This ensures that we always have enough space in which to
 154 work, since the extracted arg is never larger than the input string.
 155
 156 The argument vector is always kept terminated with a @code{NULL} arg
 157 pointer, so it can be passed to @code{freeargv} at any time, or
 158 returned, as appropriate.
 159
 160 */
 161
 162 char **buildargv (const char *input)
 163 {
 164   char *arg;
 165   char *copybuf;
 166   int squote = 0;
 167   int dquote = 0;
 168   int bsquote = 0;
 169   int argc = 0;
 170   int maxargc = 0;
 171   char **argv = NULL;
 172   char **nargv;
 173
 174   if (input != NULL)
 175     {
 176       copybuf = (char *) alloca (strlen (input) + 1);
 177       /* Is a do{}while to always execute the loop once.  Always return an
 178          argv, even for null strings.  See NOTES above, test case below. */
 179       do
 180         {
 181           /* Pick off argv[argc] */
 182           while (ISBLANK (*input))
 183             {
 184               input++;
 185             }
 186           if ((maxargc == 0) || (argc >= (maxargc - 1)))
 187             {
 188               /* argv needs initialization, or expansion */
 189               if (argv == NULL)
 190                 {
 191                   maxargc = INITIAL_MAXARGC;
 192                   nargv = (char **) malloc (maxargc * sizeof (char *));
 193                 }
 194               else
 195                 {
 196                   maxargc *= 2;
 197                   nargv = (char **) realloc (argv, maxargc * sizeof (char *));
 198                 }
 199               if (nargv == NULL)
 200                 {
 201                   if (argv != NULL)
 202                     {
 203                       freeargv (argv);
 204                       argv = NULL;
 205                     }
 206                   break;
 207                 }
 208               argv = nargv;
 209               argv[argc] = NULL;
 210             }
 211           /* Begin scanning arg */
 212           arg = copybuf;
 213           while (*input != EOS)
 214             {
 215               if (ISSPACE (*input) && !squote && !dquote && !bsquote)
 216                 {
 217                   break;
 218                 }
 219               else
 220                 {
 221                   if (bsquote)
 222                     {
 223                       bsquote = 0;
 224                       *arg++ = *input;
 225                     }
 226                   else if (*input == '\\')
 227                     {
 228                       bsquote = 1;
 229                     }
 230                   else if (squote)
 231                     {
 232                       if (*input == '\'')
 233                         {
 234                           squote = 0;
 235                         }
 236                       else
 237                         {
 238                           *arg++ = *input;
 239                         }
 240                     }
 241                   else if (dquote)
 242                     {
 243                       if (*input == '"')
 244                         {
 245                           dquote = 0;
 246                         }
 247                       else
 248                         {
 249                           *arg++ = *input;
 250                         }
 251                     }
 252                   else
 253                     {
 254                       if (*input == '\'')
 255                         {
 256                           squote = 1;
 257                         }
 258                       else if (*input == '"')
 259                         {
 260                           dquote = 1;
 261                         }
 262                       else
 263                         {
 264                           *arg++ = *input;
 265                         }
 266                     }
 267                   input++;
 268                 }
 269             }
 270           *arg = EOS;
 271           argv[argc] = strdup (copybuf);
 272           if (argv[argc] == NULL)
 273             {
 274               freeargv (argv);
 275               argv = NULL;
 276               break;
 277             }
 278           argc++;
 279           argv[argc] = NULL;
 280
 281           while (ISSPACE (*input))
 282             {
 283               input++;
 284             }
 285         }
 286       while (*input != EOS);
 287     }
 288   return (argv);
 289 }
 290
 291 /*
 292
 293 @deftypefn Extension int writeargv (const char **@var{argv}, FILE *@{file})
 294
 295 Write each member of ARGV, handling all necessary quoting, to the file
 296 named by FILE, separated by whitespace.  Return 0 on success, non-zero
 297 if an error occurred while writing to FILE.
 298
 299 @end deftypefn
 300
 301 */
 302
 303 int
 304 writeargv (char **argv, FILE *f)
 305 {
 306   int status = 0;
 307
 308   if (f == NULL)
 309     return 1;
 310
 311   while (*argv != NULL)
 312     {
 313       int ret;
 314       const char *arg = *argv;
 315
 316       while (*arg != EOS)
 317         {
 318           char c = *arg;
 319
 320           if (ISSPACE(c) || c == '\\' || c == '\'' || c == '"')
 321             if (EOF == fputc ('\\', f))
 322               {
 323                 status = 1;
 324                 goto done;
 325               }
 326
 327           if (EOF == fputc (c, f))
 328             {
 329               status = 1;
 330               goto done;
 331             }
 332           arg++;
 333         }
 334
 335       if (EOF == fputc ('\n', f))
 336         {
 337           status = 1;
 338           goto done;
 339         }
 340       argv++;
 341     }
 342
 343  done:
 344   return status;
 345 }
 346
 347 /*
 348
 349 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
 350
 351 The @var{argcp} and @code{argvp} arguments are pointers to the usual
 352 @code{argc} and @code{argv} arguments to @code{main}.  This function
 353 looks for arguments that begin with the character @samp{@@}.  Any such
 354 arguments are interpreted as ``response files''.  The contents of the
 355 response file are interpreted as additional command line options.  In
 356 particular, the file is separated into whitespace-separated strings;
 357 each such string is taken as a command-line option.  The new options
 358 are inserted in place of the option naming the response file, and
 359 @code{*argcp} and @code{*argvp} will be updated.  If the value of
 360 @code{*argvp} is modified by this function, then the new value has
 361 been dynamically allocated and can be deallocated by the caller with
 362 @code{freeargv}.  However, most callers will simply call
 363 @code{expandargv} near the beginning of @code{main} and allow the
 364 operating system to free the memory when the program exits.
 365
 366 @end deftypefn
 367
 368 */
 369
 370 void
 371 expandargv (int *argcp, char ***argvp)
 372 {
 373   /* The argument we are currently processing.  */
 374   int i = 0;
 375   /* Non-zero if ***argvp has been dynamically allocated.  */
 376   int argv_dynamic = 0;
 377   /* Loop over the arguments, handling response files.  We always skip
 378      ARGVP[0], as that is the name of the program being run.  */
 379   while (++i < *argcp)
 380     {
 381       /* The name of the response file.  */
 382       const char *filename;
 383       /* The response file.  */
 384       FILE *f;
 385       /* An upper bound on the number of characters in the response
 386          file.  */
 387       long pos;
 388       /* The number of characters in the response file, when actually
 389          read.  */
 390       size_t len;
 391       /* A dynamically allocated buffer used to hold options read from a
 392          response file.  */
 393       char *buffer;
 394       /* Dynamically allocated storage for the options read from the
 395          response file.  */
 396       char **file_argv;
 397       /* The number of options read from the response file, if any.  */
 398       size_t file_argc;
 399       /* We are only interested in options of the form "@file".  */
 400       filename = (*argvp)[i];
 401       if (filename[0] != '@')
 402         continue;
 403       /* Read the contents of the file.  */
 404       f = fopen (++filename, "r");
 405       if (!f)
 406         continue;
 407       if (fseek (f, 0L, SEEK_END) == -1)
 408         goto error;
 409       pos = ftell (f);
 410       if (pos == -1)
 411         goto error;
 412       if (fseek (f, 0L, SEEK_SET) == -1)
 413         goto error;
 414       buffer = (char *) xmalloc (pos * sizeof (char) + 1);
 415       len = fread (buffer, sizeof (char), pos, f);
 416       if (len != (size_t) pos
 417           /* On Windows, fread may return a value smaller than POS,
 418              due to CR/LF->CR translation when reading text files.
 419              That does not in-and-of itself indicate failure.  */
 420           && ferror (f))
 421         goto error;
 422       /* Add a NUL terminator.  */
 423       buffer[len] = '\0';
 424       /* Parse the string.  */
 425       file_argv = buildargv (buffer);
 426       /* If *ARGVP is not already dynamically allocated, copy it.  */
 427       if (!argv_dynamic)
 428         {
 429           *argvp = dupargv (*argvp);
 430           if (!*argvp)
 431             {
 432               fputs ("\nout of memory\n", stderr);
 433               xexit (1);
 434             }
 435         }
 436       /* Count the number of arguments.  */
 437       file_argc = 0;
 438       while (file_argv[file_argc] && *file_argv[file_argc])
 439         ++file_argc;
 440       /* Now, insert FILE_ARGV into ARGV.  The "+1" below handles the
 441          NULL terminator at the end of ARGV.  */
 442       *argvp = ((char **)
 443                 xrealloc (*argvp,
 444                           (*argcp + file_argc + 1) * sizeof (char *)));
 445       memmove (*argvp + i + file_argc, *argvp + i + 1,
 446                (*argcp - i) * sizeof (char *));
 447       memcpy (*argvp + i, file_argv, file_argc * sizeof (char *));
 448       /* The original option has been replaced by all the new
 449          options.  */
 450       *argcp += file_argc - 1;
 451       /* Free up memory allocated to process the response file.  We do
 452          not use freeargv because the individual options in FILE_ARGV
 453          are now in the main ARGV.  */
 454       free (file_argv);
 455       free (buffer);
 456       /* Rescan all of the arguments just read to support response
 457          files that include other response files.  */
 458       --i;
 459     error:
 460       /* We're all done with the file now.  */
 461       fclose (f);
 462     }
 463 }
 464
 465 #ifdef MAIN
 466
 467 /* Simple little test driver. */
 468
 469 static const char *const tests[] =
 470 {
 471   "a simple command line",
 472   "arg 'foo' is single quoted",
 473   "arg \"bar\" is double quoted",
 474   "arg \"foo bar\" has embedded whitespace",
 475   "arg 'Jack said \\'hi\\'' has single quotes",
 476   "arg 'Jack said \\\"hi\\\"' has double quotes",
 477   "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9",
 478
 479   /* This should be expanded into only one argument.  */
 480   "trailing-whitespace ",
 481
 482   "",
 483   NULL
 484 };
 485
 486 int
 487 main (void)
 488 {
 489   char **argv;
 490   const char *const *test;
 491   char **targs;
 492
 493   for (test = tests; *test != NULL; test++)
 494     {
 495       printf ("buildargv(\"%s\")\n", *test);
 496       if ((argv = buildargv (*test)) == NULL)
 497         {
 498           printf ("failed!\n\n");
 499         }
 500       else
 501         {
 502           for (targs = argv; *targs != NULL; targs++)
 503             {
 504               printf ("\t\"%s\"\n", *targs);
 505             }
 506           printf ("\n");
 507         }
 508       freeargv (argv);
 509     }
 510
 511   return 0;
 512 }
 513
 514 #endif  /* MAIN */