daily update
[binutils.git] / libiberty / argv.c
blob11ca549a8ea9bb2add001fb381550082b4db002d
1 /* Create and destroy argument vectors (argv's)
2 Copyright (C) 1992, 2001 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 **@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 **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 **) malloc ((argc + 1) * sizeof (char *));
76 if (copy == NULL)
77 return NULL;
79 /* the strings */
80 for (argc = 0; argv[argc] != NULL; argc++)
82 int len = strlen (argv[argc]);
83 copy[argc] = (char *) malloc (len + 1);
84 if (copy[argc] == NULL)
86 freeargv (copy);
87 return NULL;
89 strcpy (copy[argc], argv[argc]);
91 copy[argc] = NULL;
92 return copy;
97 @deftypefn Extension void freeargv (char **@var{vector})
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.
104 @end deftypefn
108 void freeargv (char **vector)
110 register char **scan;
112 if (vector != NULL)
114 for (scan = vector; *scan != NULL; scan++)
116 free (*scan);
118 free (vector);
124 @deftypefn Extension char** buildargv (char *@var{sp})
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.
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.
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.
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.
146 @end deftypefn
148 The memory for the argv array is dynamically expanded as necessary.
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.
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.
162 char **buildargv (const char *input)
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;
174 if (input != NULL)
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. */
181 /* Pick off argv[argc] */
182 while (ISBLANK (*input))
184 input++;
186 if ((maxargc == 0) || (argc >= (maxargc - 1)))
188 /* argv needs initialization, or expansion */
189 if (argv == NULL)
191 maxargc = INITIAL_MAXARGC;
192 nargv = (char **) malloc (maxargc * sizeof (char *));
194 else
196 maxargc *= 2;
197 nargv = (char **) realloc (argv, maxargc * sizeof (char *));
199 if (nargv == NULL)
201 if (argv != NULL)
203 freeargv (argv);
204 argv = NULL;
206 break;
208 argv = nargv;
209 argv[argc] = NULL;
211 /* Begin scanning arg */
212 arg = copybuf;
213 while (*input != EOS)
215 if (ISSPACE (*input) && !squote && !dquote && !bsquote)
217 break;
219 else
221 if (bsquote)
223 bsquote = 0;
224 *arg++ = *input;
226 else if (*input == '\\')
228 bsquote = 1;
230 else if (squote)
232 if (*input == '\'')
234 squote = 0;
236 else
238 *arg++ = *input;
241 else if (dquote)
243 if (*input == '"')
245 dquote = 0;
247 else
249 *arg++ = *input;
252 else
254 if (*input == '\'')
256 squote = 1;
258 else if (*input == '"')
260 dquote = 1;
262 else
264 *arg++ = *input;
267 input++;
270 *arg = EOS;
271 argv[argc] = strdup (copybuf);
272 if (argv[argc] == NULL)
274 freeargv (argv);
275 argv = NULL;
276 break;
278 argc++;
279 argv[argc] = NULL;
281 while (ISSPACE (*input))
283 input++;
286 while (*input != EOS);
288 return (argv);
293 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
295 The @var{argcp} and @code{argvp} arguments are pointers to the usual
296 @code{argc} and @code{argv} arguments to @code{main}. This function
297 looks for arguments that begin with the character @samp{@@}. Any such
298 arguments are interpreted as ``response files''. The contents of the
299 response file are interpreted as additional command line options. In
300 particular, the file is separated into whitespace-separated strings;
301 each such string is taken as a command-line option. The new options
302 are inserted in place of the option naming the response file, and
303 @code{*argcp} and @code{*argvp} will be updated. If the value of
304 @code{*argvp} is modified by this function, then the new value has
305 been dynamically allocated and can be deallocated by the caller with
306 @code{freeargv}. However, most callers will simply call
307 @code{expandargv} near the beginning of @code{main} and allow the
308 operating system to free the memory when the program exits.
310 @end deftypefn
314 void
315 expandargv (argcp, argvp)
316 int *argcp;
317 char ***argvp;
319 /* The argument we are currently processing. */
320 int i = 0;
321 /* Non-zero if ***argvp has been dynamically allocated. */
322 int argv_dynamic = 0;
323 /* Loop over the arguments, handling response files. We always skip
324 ARGVP[0], as that is the name of the program being run. */
325 while (++i < *argcp)
327 /* The name of the response file. */
328 const char *filename;
329 /* The response file. */
330 FILE *f;
331 /* An upper bound on the number of characters in the response
332 file. */
333 long pos;
334 /* The number of characters in the response file, when actually
335 read. */
336 size_t len;
337 /* A dynamically allocated buffer used to hold options read from a
338 response file. */
339 char *buffer;
340 /* Dynamically allocated storage for the options read from the
341 response file. */
342 char **file_argv;
343 /* The number of options read from the response file, if any. */
344 size_t file_argc;
345 /* We are only interested in options of the form "@file". */
346 filename = (*argvp)[i];
347 if (filename[0] != '@')
348 continue;
349 /* Read the contents of the file. */
350 f = fopen (++filename, "r");
351 if (!f)
352 continue;
353 if (fseek (f, 0L, SEEK_END) == -1)
354 goto error;
355 pos = ftell (f);
356 if (pos == -1)
357 goto error;
358 if (fseek (f, 0L, SEEK_SET) == -1)
359 goto error;
360 buffer = (char *) xmalloc (pos * sizeof (char) + 1);
361 len = fread (buffer, sizeof (char), pos, f);
362 if (len != (size_t) pos
363 /* On Windows, fread may return a value smaller than POS,
364 due to CR/LF->CR translation when reading text files.
365 That does not in-and-of itself indicate failure. */
366 && ferror (f))
367 goto error;
368 /* Add a NUL terminator. */
369 buffer[len] = '\0';
370 /* Parse the string. */
371 file_argv = buildargv (buffer);
372 /* If *ARGVP is not already dynamically allocated, copy it. */
373 if (!argv_dynamic)
375 *argvp = dupargv (*argvp);
376 if (!*argvp)
378 fputs ("\nout of memory\n", stderr);
379 xexit (1);
382 /* Count the number of arguments. */
383 file_argc = 0;
384 while (file_argv[file_argc] && *file_argv[file_argc])
385 ++file_argc;
386 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
387 NULL terminator at the end of ARGV. */
388 *argvp = ((char **)
389 xrealloc (*argvp,
390 (*argcp + file_argc + 1) * sizeof (char *)));
391 memmove (*argvp + i + file_argc, *argvp + i + 1,
392 (*argcp - i) * sizeof (char *));
393 memcpy (*argvp + i, file_argv, file_argc * sizeof (char *));
394 /* The original option has been replaced by all the new
395 options. */
396 *argcp += file_argc - 1;
397 /* Free up memory allocated to process the response file. We do
398 not use freeargv because the individual options in FILE_ARGV
399 are now in the main ARGV. */
400 free (file_argv);
401 free (buffer);
402 /* Rescan all of the arguments just read to support response
403 files that include other response files. */
404 --i;
405 error:
406 /* We're all done with the file now. */
407 fclose (f);
411 #ifdef MAIN
413 /* Simple little test driver. */
415 static const char *const tests[] =
417 "a simple command line",
418 "arg 'foo' is single quoted",
419 "arg \"bar\" is double quoted",
420 "arg \"foo bar\" has embedded whitespace",
421 "arg 'Jack said \\'hi\\'' has single quotes",
422 "arg 'Jack said \\\"hi\\\"' has double quotes",
423 "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",
425 /* This should be expanded into only one argument. */
426 "trailing-whitespace ",
429 NULL
433 main (void)
435 char **argv;
436 const char *const *test;
437 char **targs;
439 for (test = tests; *test != NULL; test++)
441 printf ("buildargv(\"%s\")\n", *test);
442 if ((argv = buildargv (*test)) == NULL)
444 printf ("failed!\n\n");
446 else
448 for (targs = argv; *targs != NULL; targs++)
450 printf ("\t\"%s\"\n", *targs);
452 printf ("\n");
454 freeargv (argv);
457 return 0;
460 #endif /* MAIN */