1 /* Create and destroy argument vectors (argv's)
2 Copyright (C) 1992-2018 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. */
29 #include "libiberty.h"
30 #include "safe-ctype.h"
32 /* Routines imported from standard C runtime libraries. */
38 #include <sys/types.h>
54 #define INITIAL_MAXARGC 8 /* Number of args + NULL in initial argv */
59 @deftypefn Extension char** dupargv (char * const *@var{vector})
61 Duplicate an argument vector. Simply scans through @var{vector},
62 duplicating each argument until the terminating @code{NULL} is found.
63 Returns a pointer to the argument vector if successful. Returns
64 @code{NULL} if there is insufficient memory to complete building the
72 dupargv (char * const *argv
)
81 for (argc
= 0; argv
[argc
] != NULL
; argc
++);
82 copy
= (char **) xmalloc ((argc
+ 1) * sizeof (char *));
85 for (argc
= 0; argv
[argc
] != NULL
; argc
++)
86 copy
[argc
] = xstrdup (argv
[argc
]);
93 @deftypefn Extension void freeargv (char **@var{vector})
95 Free an argument vector that was built using @code{buildargv}. Simply
96 scans through @var{vector}, freeing the memory for each argument until
97 the terminating @code{NULL} is found, and then frees @var{vector}
104 void freeargv (char **vector
)
106 register char **scan
;
110 for (scan
= vector
; *scan
!= NULL
; scan
++)
119 consume_whitespace (const char **input
)
121 while (ISSPACE (**input
))
128 only_whitespace (const char* input
)
130 while (*input
!= EOS
&& ISSPACE (*input
))
133 return (*input
== EOS
);
138 @deftypefn Extension char** buildargv (char *@var{sp})
140 Given a pointer to a string, parse the string extracting fields
141 separated by whitespace and optionally enclosed within either single
142 or double quotes (which are stripped off), and build a vector of
143 pointers to copies of the string for each field. The input string
144 remains unchanged. The last element of the vector is followed by a
147 All of the memory for the pointer array and copies of the string
148 is obtained from @code{xmalloc}. All of the memory can be returned to the
149 system with the single function call @code{freeargv}, which takes the
150 returned result of @code{buildargv}, as it's argument.
152 Returns a pointer to the argument vector if successful. Returns
153 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient
154 memory to complete building the argument vector.
156 If the input is a null string (as opposed to a @code{NULL} pointer),
157 then buildarg returns an argument vector that has one arg, a null
162 The memory for the argv array is dynamically expanded as necessary.
164 In order to provide a working buffer for extracting arguments into,
165 with appropriate stripping of quotes and translation of backslash
166 sequences, we allocate a working buffer at least as long as the input
167 string. This ensures that we always have enough space in which to
168 work, since the extracted arg is never larger than the input string.
170 The argument vector is always kept terminated with a @code{NULL} arg
171 pointer, so it can be passed to @code{freeargv} at any time, or
172 returned, as appropriate.
176 char **buildargv (const char *input
)
190 copybuf
= (char *) xmalloc (strlen (input
) + 1);
191 /* Is a do{}while to always execute the loop once. Always return an
192 argv, even for null strings. See NOTES above, test case below. */
195 /* Pick off argv[argc] */
196 consume_whitespace (&input
);
198 if ((maxargc
== 0) || (argc
>= (maxargc
- 1)))
200 /* argv needs initialization, or expansion */
203 maxargc
= INITIAL_MAXARGC
;
204 nargv
= (char **) xmalloc (maxargc
* sizeof (char *));
209 nargv
= (char **) xrealloc (argv
, maxargc
* sizeof (char *));
214 /* Begin scanning arg */
216 while (*input
!= EOS
)
218 if (ISSPACE (*input
) && !squote
&& !dquote
&& !bsquote
)
229 else if (*input
== '\\')
261 else if (*input
== '"')
274 argv
[argc
] = xstrdup (copybuf
);
278 consume_whitespace (&input
);
280 while (*input
!= EOS
);
289 @deftypefn Extension int writeargv (char * const *@var{argv}, FILE *@var{file})
291 Write each member of ARGV, handling all necessary quoting, to the file
292 named by FILE, separated by whitespace. Return 0 on success, non-zero
293 if an error occurred while writing to FILE.
300 writeargv (char * const *argv
, FILE *f
)
307 while (*argv
!= NULL
)
309 const char *arg
= *argv
;
315 if (ISSPACE(c
) || c
== '\\' || c
== '\'' || c
== '"')
316 if (EOF
== fputc ('\\', f
))
322 if (EOF
== fputc (c
, f
))
330 if (EOF
== fputc ('\n', f
))
344 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
346 The @var{argcp} and @code{argvp} arguments are pointers to the usual
347 @code{argc} and @code{argv} arguments to @code{main}. This function
348 looks for arguments that begin with the character @samp{@@}. Any such
349 arguments are interpreted as ``response files''. The contents of the
350 response file are interpreted as additional command line options. In
351 particular, the file is separated into whitespace-separated strings;
352 each such string is taken as a command-line option. The new options
353 are inserted in place of the option naming the response file, and
354 @code{*argcp} and @code{*argvp} will be updated. If the value of
355 @code{*argvp} is modified by this function, then the new value has
356 been dynamically allocated and can be deallocated by the caller with
357 @code{freeargv}. However, most callers will simply call
358 @code{expandargv} near the beginning of @code{main} and allow the
359 operating system to free the memory when the program exits.
366 expandargv (int *argcp
, char ***argvp
)
368 /* The argument we are currently processing. */
370 /* Non-zero if ***argvp has been dynamically allocated. */
371 int argv_dynamic
= 0;
372 /* Limit the number of response files that we parse in order
373 to prevent infinite recursion. */
374 unsigned int iteration_limit
= 2000;
375 /* Loop over the arguments, handling response files. We always skip
376 ARGVP[0], as that is the name of the program being run. */
379 /* The name of the response file. */
380 const char *filename
;
381 /* The response file. */
383 /* An upper bound on the number of characters in the response
386 /* The number of characters in the response file, when actually
389 /* A dynamically allocated buffer used to hold options read from a
392 /* Dynamically allocated storage for the options read from the
395 /* The number of options read from the response file, if any. */
400 /* We are only interested in options of the form "@file". */
401 filename
= (*argvp
)[i
];
402 if (filename
[0] != '@')
404 /* If we have iterated too many times then stop. */
405 if (-- iteration_limit
== 0)
407 fprintf (stderr
, "%s: error: too many @-files encountered\n", (*argvp
)[0]);
411 if (stat (filename
+1, &sb
) < 0)
413 if (S_ISDIR(sb
.st_mode
))
415 fprintf (stderr
, "%s: error: @-file refers to a directory\n", (*argvp
)[0]);
419 /* Read the contents of the file. */
420 f
= fopen (++filename
, "r");
423 if (fseek (f
, 0L, SEEK_END
) == -1)
428 if (fseek (f
, 0L, SEEK_SET
) == -1)
430 buffer
= (char *) xmalloc (pos
* sizeof (char) + 1);
431 len
= fread (buffer
, sizeof (char), pos
, f
);
432 if (len
!= (size_t) pos
433 /* On Windows, fread may return a value smaller than POS,
434 due to CR/LF->CR translation when reading text files.
435 That does not in-and-of itself indicate failure. */
438 /* Add a NUL terminator. */
440 /* If the file is empty or contains only whitespace, buildargv would
441 return a single empty argument. In this context we want no arguments,
443 if (only_whitespace (buffer
))
445 file_argv
= (char **) xmalloc (sizeof (char *));
449 /* Parse the string. */
450 file_argv
= buildargv (buffer
);
451 /* If *ARGVP is not already dynamically allocated, copy it. */
453 *argvp
= dupargv (*argvp
);
454 /* Count the number of arguments. */
456 while (file_argv
[file_argc
])
458 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
459 NULL terminator at the end of ARGV. */
462 (*argcp
+ file_argc
+ 1) * sizeof (char *)));
463 memmove (*argvp
+ i
+ file_argc
, *argvp
+ i
+ 1,
464 (*argcp
- i
) * sizeof (char *));
465 memcpy (*argvp
+ i
, file_argv
, file_argc
* sizeof (char *));
466 /* The original option has been replaced by all the new
468 *argcp
+= file_argc
- 1;
469 /* Free up memory allocated to process the response file. We do
470 not use freeargv because the individual options in FILE_ARGV
471 are now in the main ARGV. */
474 /* Rescan all of the arguments just read to support response
475 files that include other response files. */
478 /* We're all done with the file now. */
485 @deftypefn Extension int countargv (char * const *@var{argv})
487 Return the number of elements in @var{argv}.
488 Returns zero if @var{argv} is NULL.
495 countargv (char * const *argv
)
501 for (argc
= 0; argv
[argc
] != NULL
; argc
++)
508 /* Simple little test driver. */
510 static const char *const tests
[] =
512 "a simple command line",
513 "arg 'foo' is single quoted",
514 "arg \"bar\" is double quoted",
515 "arg \"foo bar\" has embedded whitespace",
516 "arg 'Jack said \\'hi\\'' has single quotes",
517 "arg 'Jack said \\\"hi\\\"' has double quotes",
518 "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",
520 /* This should be expanded into only one argument. */
521 "trailing-whitespace ",
531 const char *const *test
;
534 for (test
= tests
; *test
!= NULL
; test
++)
536 printf ("buildargv(\"%s\")\n", *test
);
537 if ((argv
= buildargv (*test
)) == NULL
)
539 printf ("failed!\n\n");
543 for (targs
= argv
; *targs
!= NULL
; targs
++)
545 printf ("\t\"%s\"\n", *targs
);
This page took 0.03979 seconds and 4 git commands to generate.