1 /* Create and destroy argument vectors (argv's) 2 Copyright (C) 1992, 2001, 2010, 2012 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 **) xmalloc ((argc + 1) * sizeof (char *)); 76 77 /* the strings */ 78 for (argc = 0; argv[argc] != NULL; argc++) 79 { 80 int len = strlen (argv[argc]); 81 copy[argc] = (char *) xmalloc (len + 1); 82 strcpy (copy[argc], argv[argc]); 83 } 84 copy[argc] = NULL; 85 return copy; 86 } 87 88 /* 89 90 @deftypefn Extension void freeargv (char **@var{vector}) 91 92 Free an argument vector that was built using @code{buildargv}. Simply 93 scans through @var{vector}, freeing the memory for each argument until 94 the terminating @code{NULL} is found, and then frees @var{vector} 95 itself. 96 97 @end deftypefn 98 99 */ 100 101 void freeargv (char **vector) 102 { 103 register char **scan; 104 105 if (vector != NULL) 106 { 107 for (scan = vector; *scan != NULL; scan++) 108 { 109 free (*scan); 110 } 111 free (vector); 112 } 113 } 114 115 static void 116 consume_whitespace (const char **input) 117 { 118 while (ISSPACE (**input)) 119 { 120 (*input)++; 121 } 122 } 123 124 static int 125 only_whitespace (const char* input) 126 { 127 while (*input != EOS && ISSPACE (*input)) 128 input++; 129 130 return (*input == EOS); 131 } 132 133 /* 134 135 @deftypefn Extension char** buildargv (char *@var{sp}) 136 137 Given a pointer to a string, parse the string extracting fields 138 separated by whitespace and optionally enclosed within either single 139 or double quotes (which are stripped off), and build a vector of 140 pointers to copies of the string for each field. The input string 141 remains unchanged. The last element of the vector is followed by a 142 @code{NULL} element. 143 144 All of the memory for the pointer array and copies of the string 145 is obtained from @code{xmalloc}. All of the memory can be returned to the 146 system with the single function call @code{freeargv}, which takes the 147 returned result of @code{buildargv}, as it's argument. 148 149 Returns a pointer to the argument vector if successful. Returns 150 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient 151 memory to complete building the argument vector. 152 153 If the input is a null string (as opposed to a @code{NULL} pointer), 154 then buildarg returns an argument vector that has one arg, a null 155 string. 156 157 @end deftypefn 158 159 The memory for the argv array is dynamically expanded as necessary. 160 161 In order to provide a working buffer for extracting arguments into, 162 with appropriate stripping of quotes and translation of backslash 163 sequences, we allocate a working buffer at least as long as the input 164 string. This ensures that we always have enough space in which to 165 work, since the extracted arg is never larger than the input string. 166 167 The argument vector is always kept terminated with a @code{NULL} arg 168 pointer, so it can be passed to @code{freeargv} at any time, or 169 returned, as appropriate. 170 171 */ 172 173 char **buildargv (const char *input) 174 { 175 char *arg; 176 char *copybuf; 177 int squote = 0; 178 int dquote = 0; 179 int bsquote = 0; 180 int argc = 0; 181 int maxargc = 0; 182 char **argv = NULL; 183 char **nargv; 184 185 if (input != NULL) 186 { 187 copybuf = (char *) xmalloc (strlen (input) + 1); 188 /* Is a do{}while to always execute the loop once. Always return an 189 argv, even for null strings. See NOTES above, test case below. */ 190 do 191 { 192 /* Pick off argv[argc] */ 193 consume_whitespace (&input); 194 195 if ((maxargc == 0) || (argc >= (maxargc - 1))) 196 { 197 /* argv needs initialization, or expansion */ 198 if (argv == NULL) 199 { 200 maxargc = INITIAL_MAXARGC; 201 nargv = (char **) xmalloc (maxargc * sizeof (char *)); 202 } 203 else 204 { 205 maxargc *= 2; 206 nargv = (char **) xrealloc (argv, maxargc * sizeof (char *)); 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] = xstrdup (copybuf); 272 argc++; 273 argv[argc] = NULL; 274 275 consume_whitespace (&input); 276 } 277 while (*input != EOS); 278 279 free (copybuf); 280 } 281 return (argv); 282 } 283 284 /* 285 286 @deftypefn Extension int writeargv (const char **@var{argv}, FILE *@var{file}) 287 288 Write each member of ARGV, handling all necessary quoting, to the file 289 named by FILE, separated by whitespace. Return 0 on success, non-zero 290 if an error occurred while writing to FILE. 291 292 @end deftypefn 293 294 */ 295 296 int 297 writeargv (char **argv, FILE *f) 298 { 299 int status = 0; 300 301 if (f == NULL) 302 return 1; 303 304 while (*argv != NULL) 305 { 306 const char *arg = *argv; 307 308 while (*arg != EOS) 309 { 310 char c = *arg; 311 312 if (ISSPACE(c) || c == '\\' || c == '\'' || c == '"') 313 if (EOF == fputc ('\\', f)) 314 { 315 status = 1; 316 goto done; 317 } 318 319 if (EOF == fputc (c, f)) 320 { 321 status = 1; 322 goto done; 323 } 324 arg++; 325 } 326 327 if (EOF == fputc ('\n', f)) 328 { 329 status = 1; 330 goto done; 331 } 332 argv++; 333 } 334 335 done: 336 return status; 337 } 338 339 /* 340 341 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp}) 342 343 The @var{argcp} and @code{argvp} arguments are pointers to the usual 344 @code{argc} and @code{argv} arguments to @code{main}. This function 345 looks for arguments that begin with the character @samp{@@}. Any such 346 arguments are interpreted as ``response files''. The contents of the 347 response file are interpreted as additional command line options. In 348 particular, the file is separated into whitespace-separated strings; 349 each such string is taken as a command-line option. The new options 350 are inserted in place of the option naming the response file, and 351 @code{*argcp} and @code{*argvp} will be updated. If the value of 352 @code{*argvp} is modified by this function, then the new value has 353 been dynamically allocated and can be deallocated by the caller with 354 @code{freeargv}. However, most callers will simply call 355 @code{expandargv} near the beginning of @code{main} and allow the 356 operating system to free the memory when the program exits. 357 358 @end deftypefn 359 360 */ 361 362 void 363 expandargv (int *argcp, char ***argvp) 364 { 365 /* The argument we are currently processing. */ 366 int i = 0; 367 /* Non-zero if ***argvp has been dynamically allocated. */ 368 int argv_dynamic = 0; 369 /* Limit the number of response files that we parse in order 370 to prevent infinite recursion. */ 371 unsigned int iteration_limit = 2000; 372 /* Loop over the arguments, handling response files. We always skip 373 ARGVP[0], as that is the name of the program being run. */ 374 while (++i < *argcp) 375 { 376 /* The name of the response file. */ 377 const char *filename; 378 /* The response file. */ 379 FILE *f; 380 /* An upper bound on the number of characters in the response 381 file. */ 382 long pos; 383 /* The number of characters in the response file, when actually 384 read. */ 385 size_t len; 386 /* A dynamically allocated buffer used to hold options read from a 387 response file. */ 388 char *buffer; 389 /* Dynamically allocated storage for the options read from the 390 response file. */ 391 char **file_argv; 392 /* The number of options read from the response file, if any. */ 393 size_t file_argc; 394 /* We are only interested in options of the form "@file". */ 395 filename = (*argvp)[i]; 396 if (filename[0] != '@') 397 continue; 398 /* If we have iterated too many times then stop. */ 399 if (-- iteration_limit == 0) 400 { 401 fprintf (stderr, "%s: error: too many @-files encountered\n", (*argvp)[0]); 402 xexit (1); 403 } 404 /* Read the contents of the file. */ 405 f = fopen (++filename, "r"); 406 if (!f) 407 continue; 408 if (fseek (f, 0L, SEEK_END) == -1) 409 goto error; 410 pos = ftell (f); 411 if (pos == -1) 412 goto error; 413 if (fseek (f, 0L, SEEK_SET) == -1) 414 goto error; 415 buffer = (char *) xmalloc (pos * sizeof (char) + 1); 416 len = fread (buffer, sizeof (char), pos, f); 417 if (len != (size_t) pos 418 /* On Windows, fread may return a value smaller than POS, 419 due to CR/LF->CR translation when reading text files. 420 That does not in-and-of itself indicate failure. */ 421 && ferror (f)) 422 goto error; 423 /* Add a NUL terminator. */ 424 buffer[len] = '\0'; 425 /* If the file is empty or contains only whitespace, buildargv would 426 return a single empty argument. In this context we want no arguments, 427 instead. */ 428 if (only_whitespace (buffer)) 429 { 430 file_argv = (char **) xmalloc (sizeof (char *)); 431 file_argv[0] = NULL; 432 } 433 else 434 /* Parse the string. */ 435 file_argv = buildargv (buffer); 436 /* If *ARGVP is not already dynamically allocated, copy it. */ 437 if (!argv_dynamic) 438 *argvp = dupargv (*argvp); 439 /* Count the number of arguments. */ 440 file_argc = 0; 441 while (file_argv[file_argc]) 442 ++file_argc; 443 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the 444 NULL terminator at the end of ARGV. */ 445 *argvp = ((char **) 446 xrealloc (*argvp, 447 (*argcp + file_argc + 1) * sizeof (char *))); 448 memmove (*argvp + i + file_argc, *argvp + i + 1, 449 (*argcp - i) * sizeof (char *)); 450 memcpy (*argvp + i, file_argv, file_argc * sizeof (char *)); 451 /* The original option has been replaced by all the new 452 options. */ 453 *argcp += file_argc - 1; 454 /* Free up memory allocated to process the response file. We do 455 not use freeargv because the individual options in FILE_ARGV 456 are now in the main ARGV. */ 457 free (file_argv); 458 free (buffer); 459 /* Rescan all of the arguments just read to support response 460 files that include other response files. */ 461 --i; 462 error: 463 /* We're all done with the file now. */ 464 fclose (f); 465 } 466 } 467 468 /* 469 470 @deftypefn Extension int countargv (char **@var{argv}) 471 472 Return the number of elements in @var{argv}. 473 Returns zero if @var{argv} is NULL. 474 475 @end deftypefn 476 477 */ 478 479 int 480 countargv (char **argv) 481 { 482 int argc; 483 484 if (argv == NULL) 485 return 0; 486 for (argc = 0; argv[argc] != NULL; argc++) 487 continue; 488 return argc; 489 } 490 491 #ifdef MAIN 492 493 /* Simple little test driver. */ 494 495 static const char *const tests[] = 496 { 497 "a simple command line", 498 "arg 'foo' is single quoted", 499 "arg \"bar\" is double quoted", 500 "arg \"foo bar\" has embedded whitespace", 501 "arg 'Jack said \\'hi\\'' has single quotes", 502 "arg 'Jack said \\\"hi\\\"' has double quotes", 503 "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", 504 505 /* This should be expanded into only one argument. */ 506 "trailing-whitespace ", 507 508 "", 509 NULL 510 }; 511 512 int 513 main (void) 514 { 515 char **argv; 516 const char *const *test; 517 char **targs; 518 519 for (test = tests; *test != NULL; test++) 520 { 521 printf ("buildargv(\"%s\")\n", *test); 522 if ((argv = buildargv (*test)) == NULL) 523 { 524 printf ("failed!\n\n"); 525 } 526 else 527 { 528 for (targs = argv; *targs != NULL; targs++) 529 { 530 printf ("\t\"%s\"\n", *targs); 531 } 532 printf ("\n"); 533 } 534 freeargv (argv); 535 } 536 537 return 0; 538 } 539 540 #endif /* MAIN */ 541
