For typo in documentation wrt. C_PTRDIFF_T constant
[official-gcc.git] / libiberty / argv.c
blob994dd3531c00952f79dbdabf4341cbea85ac22c8
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
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.
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.
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. */
22 /* Create and destroy argument vectors. An argument vector is simply an
23 array of string pointers, terminated by a NULL pointer. */
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28 #include "ansidecl.h"
29 #include "libiberty.h"
30 #include "safe-ctype.h"
32 /* Routines imported from standard C runtime libraries. */
34 #include <stddef.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <stdio.h>
39 #ifndef NULL
40 #define NULL 0
41 #endif
43 #ifndef EOS
44 #define EOS '\0'
45 #endif
47 #define INITIAL_MAXARGC 8 /* Number of args + NULL in initial argv */
52 @deftypefn Extension char** dupargv (char * const *@var{vector})
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.
60 @end deftypefn
64 char **
65 dupargv (char * const *argv)
67 int argc;
68 char **copy;
70 if (argv == NULL)
71 return NULL;
73 /* the vector */
74 for (argc = 0; argv[argc] != NULL; argc++);
75 copy = (char **) xmalloc ((argc + 1) * sizeof (char *));
77 /* the strings */
78 for (argc = 0; argv[argc] != NULL; argc++)
79 copy[argc] = xstrdup (argv[argc]);
80 copy[argc] = NULL;
81 return copy;
86 @deftypefn Extension void freeargv (char **@var{vector})
88 Free an argument vector that was built using @code{buildargv}. Simply
89 scans through @var{vector}, freeing the memory for each argument until
90 the terminating @code{NULL} is found, and then frees @var{vector}
91 itself.
93 @end deftypefn
97 void freeargv (char **vector)
99 register char **scan;
101 if (vector != NULL)
103 for (scan = vector; *scan != NULL; scan++)
105 free (*scan);
107 free (vector);
111 static void
112 consume_whitespace (const char **input)
114 while (ISSPACE (**input))
116 (*input)++;
120 static int
121 only_whitespace (const char* input)
123 while (*input != EOS && ISSPACE (*input))
124 input++;
126 return (*input == EOS);
131 @deftypefn Extension char** buildargv (char *@var{sp})
133 Given a pointer to a string, parse the string extracting fields
134 separated by whitespace and optionally enclosed within either single
135 or double quotes (which are stripped off), and build a vector of
136 pointers to copies of the string for each field. The input string
137 remains unchanged. The last element of the vector is followed by a
138 @code{NULL} element.
140 All of the memory for the pointer array and copies of the string
141 is obtained from @code{xmalloc}. All of the memory can be returned to the
142 system with the single function call @code{freeargv}, which takes the
143 returned result of @code{buildargv}, as it's argument.
145 Returns a pointer to the argument vector if successful. Returns
146 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient
147 memory to complete building the argument vector.
149 If the input is a null string (as opposed to a @code{NULL} pointer),
150 then buildarg returns an argument vector that has one arg, a null
151 string.
153 @end deftypefn
155 The memory for the argv array is dynamically expanded as necessary.
157 In order to provide a working buffer for extracting arguments into,
158 with appropriate stripping of quotes and translation of backslash
159 sequences, we allocate a working buffer at least as long as the input
160 string. This ensures that we always have enough space in which to
161 work, since the extracted arg is never larger than the input string.
163 The argument vector is always kept terminated with a @code{NULL} arg
164 pointer, so it can be passed to @code{freeargv} at any time, or
165 returned, as appropriate.
169 char **buildargv (const char *input)
171 char *arg;
172 char *copybuf;
173 int squote = 0;
174 int dquote = 0;
175 int bsquote = 0;
176 int argc = 0;
177 int maxargc = 0;
178 char **argv = NULL;
179 char **nargv;
181 if (input != NULL)
183 copybuf = (char *) xmalloc (strlen (input) + 1);
184 /* Is a do{}while to always execute the loop once. Always return an
185 argv, even for null strings. See NOTES above, test case below. */
188 /* Pick off argv[argc] */
189 consume_whitespace (&input);
191 if ((maxargc == 0) || (argc >= (maxargc - 1)))
193 /* argv needs initialization, or expansion */
194 if (argv == NULL)
196 maxargc = INITIAL_MAXARGC;
197 nargv = (char **) xmalloc (maxargc * sizeof (char *));
199 else
201 maxargc *= 2;
202 nargv = (char **) xrealloc (argv, maxargc * sizeof (char *));
204 argv = nargv;
205 argv[argc] = NULL;
207 /* Begin scanning arg */
208 arg = copybuf;
209 while (*input != EOS)
211 if (ISSPACE (*input) && !squote && !dquote && !bsquote)
213 break;
215 else
217 if (bsquote)
219 bsquote = 0;
220 *arg++ = *input;
222 else if (*input == '\\')
224 bsquote = 1;
226 else if (squote)
228 if (*input == '\'')
230 squote = 0;
232 else
234 *arg++ = *input;
237 else if (dquote)
239 if (*input == '"')
241 dquote = 0;
243 else
245 *arg++ = *input;
248 else
250 if (*input == '\'')
252 squote = 1;
254 else if (*input == '"')
256 dquote = 1;
258 else
260 *arg++ = *input;
263 input++;
266 *arg = EOS;
267 argv[argc] = xstrdup (copybuf);
268 argc++;
269 argv[argc] = NULL;
271 consume_whitespace (&input);
273 while (*input != EOS);
275 free (copybuf);
277 return (argv);
282 @deftypefn Extension int writeargv (char * const *@var{argv}, FILE *@var{file})
284 Write each member of ARGV, handling all necessary quoting, to the file
285 named by FILE, separated by whitespace. Return 0 on success, non-zero
286 if an error occurred while writing to FILE.
288 @end deftypefn
293 writeargv (char * const *argv, FILE *f)
295 int status = 0;
297 if (f == NULL)
298 return 1;
300 while (*argv != NULL)
302 const char *arg = *argv;
304 while (*arg != EOS)
306 char c = *arg;
308 if (ISSPACE(c) || c == '\\' || c == '\'' || c == '"')
309 if (EOF == fputc ('\\', f))
311 status = 1;
312 goto done;
315 if (EOF == fputc (c, f))
317 status = 1;
318 goto done;
320 arg++;
323 if (EOF == fputc ('\n', f))
325 status = 1;
326 goto done;
328 argv++;
331 done:
332 return status;
337 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
339 The @var{argcp} and @code{argvp} arguments are pointers to the usual
340 @code{argc} and @code{argv} arguments to @code{main}. This function
341 looks for arguments that begin with the character @samp{@@}. Any such
342 arguments are interpreted as ``response files''. The contents of the
343 response file are interpreted as additional command line options. In
344 particular, the file is separated into whitespace-separated strings;
345 each such string is taken as a command-line option. The new options
346 are inserted in place of the option naming the response file, and
347 @code{*argcp} and @code{*argvp} will be updated. If the value of
348 @code{*argvp} is modified by this function, then the new value has
349 been dynamically allocated and can be deallocated by the caller with
350 @code{freeargv}. However, most callers will simply call
351 @code{expandargv} near the beginning of @code{main} and allow the
352 operating system to free the memory when the program exits.
354 @end deftypefn
358 void
359 expandargv (int *argcp, char ***argvp)
361 /* The argument we are currently processing. */
362 int i = 0;
363 /* Non-zero if ***argvp has been dynamically allocated. */
364 int argv_dynamic = 0;
365 /* Limit the number of response files that we parse in order
366 to prevent infinite recursion. */
367 unsigned int iteration_limit = 2000;
368 /* Loop over the arguments, handling response files. We always skip
369 ARGVP[0], as that is the name of the program being run. */
370 while (++i < *argcp)
372 /* The name of the response file. */
373 const char *filename;
374 /* The response file. */
375 FILE *f;
376 /* An upper bound on the number of characters in the response
377 file. */
378 long pos;
379 /* The number of characters in the response file, when actually
380 read. */
381 size_t len;
382 /* A dynamically allocated buffer used to hold options read from a
383 response file. */
384 char *buffer;
385 /* Dynamically allocated storage for the options read from the
386 response file. */
387 char **file_argv;
388 /* The number of options read from the response file, if any. */
389 size_t file_argc;
390 /* We are only interested in options of the form "@file". */
391 filename = (*argvp)[i];
392 if (filename[0] != '@')
393 continue;
394 /* If we have iterated too many times then stop. */
395 if (-- iteration_limit == 0)
397 fprintf (stderr, "%s: error: too many @-files encountered\n", (*argvp)[0]);
398 xexit (1);
400 /* Read the contents of the file. */
401 f = fopen (++filename, "r");
402 if (!f)
403 continue;
404 if (fseek (f, 0L, SEEK_END) == -1)
405 goto error;
406 pos = ftell (f);
407 if (pos == -1)
408 goto error;
409 if (fseek (f, 0L, SEEK_SET) == -1)
410 goto error;
411 buffer = (char *) xmalloc (pos * sizeof (char) + 1);
412 len = fread (buffer, sizeof (char), pos, f);
413 if (len != (size_t) pos
414 /* On Windows, fread may return a value smaller than POS,
415 due to CR/LF->CR translation when reading text files.
416 That does not in-and-of itself indicate failure. */
417 && ferror (f))
418 goto error;
419 /* Add a NUL terminator. */
420 buffer[len] = '\0';
421 /* If the file is empty or contains only whitespace, buildargv would
422 return a single empty argument. In this context we want no arguments,
423 instead. */
424 if (only_whitespace (buffer))
426 file_argv = (char **) xmalloc (sizeof (char *));
427 file_argv[0] = NULL;
429 else
430 /* Parse the string. */
431 file_argv = buildargv (buffer);
432 /* If *ARGVP is not already dynamically allocated, copy it. */
433 if (!argv_dynamic)
434 *argvp = dupargv (*argvp);
435 /* Count the number of arguments. */
436 file_argc = 0;
437 while (file_argv[file_argc])
438 ++file_argc;
439 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
440 NULL terminator at the end of ARGV. */
441 *argvp = ((char **)
442 xrealloc (*argvp,
443 (*argcp + file_argc + 1) * sizeof (char *)));
444 memmove (*argvp + i + file_argc, *argvp + i + 1,
445 (*argcp - i) * sizeof (char *));
446 memcpy (*argvp + i, file_argv, file_argc * sizeof (char *));
447 /* The original option has been replaced by all the new
448 options. */
449 *argcp += file_argc - 1;
450 /* Free up memory allocated to process the response file. We do
451 not use freeargv because the individual options in FILE_ARGV
452 are now in the main ARGV. */
453 free (file_argv);
454 free (buffer);
455 /* Rescan all of the arguments just read to support response
456 files that include other response files. */
457 --i;
458 error:
459 /* We're all done with the file now. */
460 fclose (f);
466 @deftypefn Extension int countargv (char * const *@var{argv})
468 Return the number of elements in @var{argv}.
469 Returns zero if @var{argv} is NULL.
471 @end deftypefn
476 countargv (char * const *argv)
478 int argc;
480 if (argv == NULL)
481 return 0;
482 for (argc = 0; argv[argc] != NULL; argc++)
483 continue;
484 return argc;
487 #ifdef MAIN
489 /* Simple little test driver. */
491 static const char *const tests[] =
493 "a simple command line",
494 "arg 'foo' is single quoted",
495 "arg \"bar\" is double quoted",
496 "arg \"foo bar\" has embedded whitespace",
497 "arg 'Jack said \\'hi\\'' has single quotes",
498 "arg 'Jack said \\\"hi\\\"' has double quotes",
499 "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",
501 /* This should be expanded into only one argument. */
502 "trailing-whitespace ",
505 NULL
509 main (void)
511 char **argv;
512 const char *const *test;
513 char **targs;
515 for (test = tests; *test != NULL; test++)
517 printf ("buildargv(\"%s\")\n", *test);
518 if ((argv = buildargv (*test)) == NULL)
520 printf ("failed!\n\n");
522 else
524 for (targs = argv; *targs != NULL; targs++)
526 printf ("\t\"%s\"\n", *targs);
528 printf ("\n");
530 freeargv (argv);
533 return 0;
536 #endif /* MAIN */