/* Create and destroy argument vectors (argv's)
- Copyright (C) 1992, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1992-2019 Free Software Foundation, Inc.
Written by Fred Fish @ Cygnus Support
This file is part of the libiberty library.
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
#ifndef NULL
#define NULL 0
/*
-@deftypefn Extension char** dupargv (char **@var{vector})
+@deftypefn Extension char** dupargv (char * const *@var{vector})
Duplicate an argument vector. Simply scans through @var{vector},
duplicating each argument until the terminating @code{NULL} is found.
*/
char **
-dupargv (char **argv)
+dupargv (char * const *argv)
{
int argc;
char **copy;
/* the vector */
for (argc = 0; argv[argc] != NULL; argc++);
- copy = (char **) malloc ((argc + 1) * sizeof (char *));
- if (copy == NULL)
- return NULL;
-
+ copy = (char **) xmalloc ((argc + 1) * sizeof (char *));
+
/* the strings */
for (argc = 0; argv[argc] != NULL; argc++)
- {
- int len = strlen (argv[argc]);
- copy[argc] = (char *) malloc (len + 1);
- if (copy[argc] == NULL)
- {
- freeargv (copy);
- return NULL;
- }
- strcpy (copy[argc], argv[argc]);
- }
+ copy[argc] = xstrdup (argv[argc]);
copy[argc] = NULL;
return copy;
}
@code{NULL} element.
All of the memory for the pointer array and copies of the string
-is obtained from @code{malloc}. All of the memory can be returned to the
+is obtained from @code{xmalloc}. All of the memory can be returned to the
system with the single function call @code{freeargv}, which takes the
returned result of @code{buildargv}, as it's argument.
if (input != NULL)
{
- copybuf = (char *) alloca (strlen (input) + 1);
+ copybuf = (char *) xmalloc (strlen (input) + 1);
/* Is a do{}while to always execute the loop once. Always return an
argv, even for null strings. See NOTES above, test case below. */
do
if (argv == NULL)
{
maxargc = INITIAL_MAXARGC;
- nargv = (char **) malloc (maxargc * sizeof (char *));
+ nargv = (char **) xmalloc (maxargc * sizeof (char *));
}
else
{
maxargc *= 2;
- nargv = (char **) realloc (argv, maxargc * sizeof (char *));
- }
- if (nargv == NULL)
- {
- if (argv != NULL)
- {
- freeargv (argv);
- argv = NULL;
- }
- break;
+ nargv = (char **) xrealloc (argv, maxargc * sizeof (char *));
}
argv = nargv;
argv[argc] = NULL;
}
}
*arg = EOS;
- argv[argc] = strdup (copybuf);
- if (argv[argc] == NULL)
- {
- freeargv (argv);
- argv = NULL;
- break;
- }
+ argv[argc] = xstrdup (copybuf);
argc++;
argv[argc] = NULL;
consume_whitespace (&input);
}
while (*input != EOS);
+
+ free (copybuf);
}
return (argv);
}
/*
-@deftypefn Extension int writeargv (const char **@var{argv}, FILE *@var{file})
+@deftypefn Extension int writeargv (char * const *@var{argv}, FILE *@var{file})
Write each member of ARGV, handling all necessary quoting, to the file
named by FILE, separated by whitespace. Return 0 on success, non-zero
*/
int
-writeargv (char **argv, FILE *f)
+writeargv (char * const *argv, FILE *f)
{
int status = 0;
{
/* The argument we are currently processing. */
int i = 0;
- /* Non-zero if ***argvp has been dynamically allocated. */
- int argv_dynamic = 0;
+ /* To check if ***argvp has been dynamically allocated. */
+ char ** const original_argv = *argvp;
+ /* Limit the number of response files that we parse in order
+ to prevent infinite recursion. */
+ unsigned int iteration_limit = 2000;
/* Loop over the arguments, handling response files. We always skip
ARGVP[0], as that is the name of the program being run. */
while (++i < *argcp)
char **file_argv;
/* The number of options read from the response file, if any. */
size_t file_argc;
+#ifdef S_ISDIR
+ struct stat sb;
+#endif
/* We are only interested in options of the form "@file". */
filename = (*argvp)[i];
if (filename[0] != '@')
continue;
+ /* If we have iterated too many times then stop. */
+ if (-- iteration_limit == 0)
+ {
+ fprintf (stderr, "%s: error: too many @-files encountered\n", (*argvp)[0]);
+ xexit (1);
+ }
+#ifdef S_ISDIR
+ if (stat (filename+1, &sb) < 0)
+ continue;
+ if (S_ISDIR(sb.st_mode))
+ {
+ fprintf (stderr, "%s: error: @-file refers to a directory\n", (*argvp)[0]);
+ xexit (1);
+ }
+#endif
/* Read the contents of the file. */
f = fopen (++filename, "r");
if (!f)
/* Parse the string. */
file_argv = buildargv (buffer);
/* If *ARGVP is not already dynamically allocated, copy it. */
- if (!argv_dynamic)
- {
- *argvp = dupargv (*argvp);
- if (!*argvp)
- {
- fputs ("\nout of memory\n", stderr);
- xexit (1);
- }
- }
+ if (*argvp == original_argv)
+ *argvp = dupargv (*argvp);
/* Count the number of arguments. */
file_argc = 0;
while (file_argv[file_argc])
++file_argc;
+ /* Free the original option's memory. */
+ free ((*argvp)[i]);
/* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
NULL terminator at the end of ARGV. */
*argvp = ((char **)
}
}
+/*
+
+@deftypefn Extension int countargv (char * const *@var{argv})
+
+Return the number of elements in @var{argv}.
+Returns zero if @var{argv} is NULL.
+
+@end deftypefn
+
+*/
+
+int
+countargv (char * const *argv)
+{
+ int argc;
+
+ if (argv == NULL)
+ return 0;
+ for (argc = 0; argv[argc] != NULL; argc++)
+ continue;
+ return argc;
+}
+
#ifdef MAIN
/* Simple little test driver. */
projects / external / binutils.git / blobdiff