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. */
29 #include "libiberty.h"
30 #include "safe-ctype.h"
32 /* Routines imported from standard C runtime libraries. */
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
74 for (argc
= 0; argv
[argc
] != NULL
; argc
++);
75 copy
= (char **) malloc ((argc
+ 1) * sizeof (char *));
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
)
89 strcpy (copy
[argc
], argv
[argc
]);
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}
108 void freeargv (char **vector
)
110 register char **scan
;
114 for (scan
= vector
; *scan
!= NULL
; scan
++)
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
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
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
)
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
))
186 if ((maxargc
== 0) || (argc
>= (maxargc
- 1)))
188 /* argv needs initialization, or expansion */
191 maxargc
= INITIAL_MAXARGC
;
192 nargv
= (char **) malloc (maxargc
* sizeof (char *));
197 nargv
= (char **) realloc (argv
, maxargc
* sizeof (char *));
211 /* Begin scanning arg */
213 while (*input
!= EOS
)
215 if (ISSPACE (*input
) && !squote
&& !dquote
&& !bsquote
)
226 else if (*input
== '\\')
258 else if (*input
== '"')
271 argv
[argc
] = strdup (copybuf
);
272 if (argv
[argc
] == NULL
)
281 while (ISSPACE (*input
))
286 while (*input
!= EOS
);
293 @deftypefn Extension int writeargv (const char **@var{argv}, FILE *@var{file})
295 Write each member of ARGV, handling all necessary quoting, to the file
296 named by FILE, separated by whitespace. Return 0 on success, non-zero
297 if an error occurred while writing to FILE.
304 writeargv (char **argv
, FILE *f
)
311 while (*argv
!= NULL
)
313 const char *arg
= *argv
;
319 if (ISSPACE(c
) || c
== '\\' || c
== '\'' || c
== '"')
320 if (EOF
== fputc ('\\', f
))
326 if (EOF
== fputc (c
, f
))
334 if (EOF
== fputc ('\n', f
))
348 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
350 The @var{argcp} and @code{argvp} arguments are pointers to the usual
351 @code{argc} and @code{argv} arguments to @code{main}. This function
352 looks for arguments that begin with the character @samp{@@}. Any such
353 arguments are interpreted as ``response files''. The contents of the
354 response file are interpreted as additional command line options. In
355 particular, the file is separated into whitespace-separated strings;
356 each such string is taken as a command-line option. The new options
357 are inserted in place of the option naming the response file, and
358 @code{*argcp} and @code{*argvp} will be updated. If the value of
359 @code{*argvp} is modified by this function, then the new value has
360 been dynamically allocated and can be deallocated by the caller with
361 @code{freeargv}. However, most callers will simply call
362 @code{expandargv} near the beginning of @code{main} and allow the
363 operating system to free the memory when the program exits.
370 expandargv (int *argcp
, char ***argvp
)
372 /* The argument we are currently processing. */
374 /* Non-zero if ***argvp has been dynamically allocated. */
375 int argv_dynamic
= 0;
376 /* Loop over the arguments, handling response files. We always skip
377 ARGVP[0], as that is the name of the program being run. */
380 /* The name of the response file. */
381 const char *filename
;
382 /* The response file. */
384 /* An upper bound on the number of characters in the response
387 /* The number of characters in the response file, when actually
390 /* A dynamically allocated buffer used to hold options read from a
393 /* Dynamically allocated storage for the options read from the
396 /* The number of options read from the response file, if any. */
398 /* We are only interested in options of the form "@file". */
399 filename
= (*argvp
)[i
];
400 if (filename
[0] != '@')
402 /* Read the contents of the file. */
403 f
= fopen (++filename
, "r");
406 if (fseek (f
, 0L, SEEK_END
) == -1)
411 if (fseek (f
, 0L, SEEK_SET
) == -1)
413 buffer
= (char *) xmalloc (pos
* sizeof (char) + 1);
414 len
= fread (buffer
, sizeof (char), pos
, f
);
415 if (len
!= (size_t) pos
416 /* On Windows, fread may return a value smaller than POS,
417 due to CR/LF->CR translation when reading text files.
418 That does not in-and-of itself indicate failure. */
421 /* Add a NUL terminator. */
423 /* Parse the string. */
424 file_argv
= buildargv (buffer
);
425 /* If *ARGVP is not already dynamically allocated, copy it. */
428 *argvp
= dupargv (*argvp
);
431 fputs ("\nout of memory\n", stderr
);
435 /* Count the number of arguments. */
437 while (file_argv
[file_argc
] && *file_argv
[file_argc
])
439 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
440 NULL terminator at the end of ARGV. */
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
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. */
455 /* Rescan all of the arguments just read to support response
456 files that include other response files. */
459 /* We're all done with the file now. */
466 /* Simple little test driver. */
468 static const char *const tests
[] =
470 "a simple command line",
471 "arg 'foo' is single quoted",
472 "arg \"bar\" is double quoted",
473 "arg \"foo bar\" has embedded whitespace",
474 "arg 'Jack said \\'hi\\'' has single quotes",
475 "arg 'Jack said \\\"hi\\\"' has double quotes",
476 "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",
478 /* This should be expanded into only one argument. */
479 "trailing-whitespace ",
489 const char *const *test
;
492 for (test
= tests
; *test
!= NULL
; test
++)
494 printf ("buildargv(\"%s\")\n", *test
);
495 if ((argv
= buildargv (*test
)) == NULL
)
497 printf ("failed!\n\n");
501 for (targs
= argv
; *targs
!= NULL
; targs
++)
503 printf ("\t\"%s\"\n", *targs
);
This page took 0.039852 seconds and 4 git commands to generate.