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