Add @file command line support to gcc/g++ (ported from GCC 4.1)

patches/gcc-2.95.3/expandargv.diff

@@ -0,0 +1,228 @@
+diff -Naur gcc-2.95.3/gcc/gcc.c gcc-2.95.3/gcc/gcc.c
+--- gcc-2.95.3/gcc/gcc.c	2001-01-25 15:03:16.000000000 +0100
++++ gcc-2.95.3/gcc/gcc.c	2015-01-08 20:39:10.000000000 +0100
+@@ -4648,11 +4648,14 @@
+   const char *p;
+   struct user_specs *uptr;
+
++
+   p = argv[0] + strlen (argv[0]);
+   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
+     --p;
+   programname = p;
+
++  expandargv (&argc, &argv);
++
+ #ifdef HAVE_LC_MESSAGES
+   setlocale (LC_MESSAGES, "");
+ #endif
+diff -Naur gcc-2.95.3/include/libiberty.h gcc-2.95.3/include/libiberty.h
+--- gcc-2.95.3/include/libiberty.h	1999-04-07 06:24:19.000000000 +0200
++++ gcc-2.95.3/include/libiberty.h	2015-01-08 20:44:33.000000000 +0100
+@@ -16,6 +16,9 @@
+
+ #include "ansidecl.h"
+
++#include <string.h>
++#include <stdlib.h>
++
+ /* Build an argument vector from a string.  Allocates memory using
+    malloc.  Use freeargv to free the vector.  */
+
+@@ -30,6 +33,9 @@
+
+ extern char **dupargv PARAMS ((char **));
+
++/* Expand "@file" arguments in argv.  */
++
++extern void expandargv (int *, char ***);
+
+ /* Return the last component of a path name.  Note that we can't use a
+    prototype here because the parameter is declared inconsistently
+@@ -108,11 +114,7 @@
+
+ /* Exit, calling all the functions registered with xatexit.  */
+
+-#ifndef __GNUC__
+-extern void xexit PARAMS ((int status));
+-#else
+-void xexit PARAMS ((int status)) __attribute__ ((noreturn));
+-#endif
++extern void xexit PARAMS ((int status)) __attribute__ ((__noreturn__));
+
+ /* Set the program name used by xmalloc.  */
+
+diff -Naur gcc-2.95.3/libiberty/argv.c gcc-2.95.3/libiberty/argv.c
+--- gcc-2.95.3/libiberty/argv.c	1998-12-22 07:57:12.000000000 +0100
++++ gcc-2.95.3/libiberty/argv.c	2015-01-08 20:39:10.000000000 +0100
+@@ -35,12 +35,15 @@
+ #ifdef __STDC__
+
+ #include <stddef.h>
++#include <string.h>
++#include <stdio.h>
++#ifndef __APPLE__
+ extern void *memcpy (void *s1, const void *s2, size_t n);	/* 4.11.2.1 */
+ extern size_t strlen (const char *s);				/* 4.11.6.3 */
+ extern void *malloc (size_t size);				/* 4.10.3.3 */
+ extern void *realloc (void *ptr, size_t size);			/* 4.10.3.4 */
+ extern void free (void *ptr);					/* 4.10.3.2 */
+-extern char *strdup (const char *s);				/* Non-ANSI */
++#endif
+
+ #else	/* !__STDC__ */
+
+@@ -163,6 +166,16 @@
+     }
+ }
+
++static int
++only_whitespace (const char* input)
++{
++  while (*input != EOS && isspace (*input))
++    input++;
++
++  return (*input == EOS);
++}
++
++
+ /*
+
+ NAME
+@@ -340,6 +353,136 @@
+   return (argv);
+ }
+
++/*
++
++@deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
++
++The @var{argcp} and @code{argvp} arguments are pointers to the usual
++@code{argc} and @code{argv} arguments to @code{main}.  This function
++looks for arguments that begin with the character @samp{@@}.  Any such
++arguments are interpreted as ``response files''.  The contents of the
++response file are interpreted as additional command line options.  In
++particular, the file is separated into whitespace-separated strings;
++each such string is taken as a command-line option.  The new options
++are inserted in place of the option naming the response file, and
++@code{*argcp} and @code{*argvp} will be updated.  If the value of
++@code{*argvp} is modified by this function, then the new value has
++been dynamically allocated and can be deallocated by the caller with
++@code{freeargv}.  However, most callers will simply call
++@code{expandargv} near the beginning of @code{main} and allow the
++operating system to free the memory when the program exits.
++
++@end deftypefn
++
++*/
++
++void
++expandargv (int *argcp, char ***argvp)
++{
++  /* The argument we are currently processing.  */
++  int i = 0;
++  /* Non-zero if ***argvp has been dynamically allocated.  */
++  int argv_dynamic = 0;
++  /* 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)
++    {
++      /* The name of the response file.  */
++      const char *filename;
++      /* The response file.  */
++      FILE *f;
++      /* An upper bound on the number of characters in the response
++	 file.  */
++      long pos;
++      /* The number of characters in the response file, when actually
++	 read.  */
++      size_t len;
++      /* A dynamically allocated buffer used to hold options read from a
++	 response file.  */
++      char *buffer;
++      /* Dynamically allocated storage for the options read from the
++	 response file.  */
++      char **file_argv;
++      /* The number of options read from the response file, if any.  */
++      size_t file_argc;
++      /* 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);
++	}
++      /* Read the contents of the file.  */
++      f = fopen (++filename, "r");
++      if (!f)
++	continue;
++      if (fseek (f, 0L, SEEK_END) == -1)
++	goto error;
++      pos = ftell (f);
++      if (pos == -1)
++	goto error;
++      if (fseek (f, 0L, SEEK_SET) == -1)
++	goto error;
++      buffer = (char *) xmalloc (pos * sizeof (char) + 1);
++      len = fread (buffer, sizeof (char), pos, f);
++      if (len != (size_t) pos
++	  /* On Windows, fread may return a value smaller than POS,
++	     due to CR/LF->CR translation when reading text files.
++	     That does not in-and-of itself indicate failure.  */
++	  && ferror (f))
++	goto error;
++      /* Add a NUL terminator.  */
++      buffer[len] = '\0';
++      /* If the file is empty or contains only whitespace, buildargv would
++	 return a single empty argument.  In this context we want no arguments,
++	 instead.  */
++      if (only_whitespace (buffer))
++	{
++	  file_argv = (char **) xmalloc (sizeof (char *));
++	  file_argv[0] = NULL;
++	}
++      else
++	/* Parse the string.  */
++	file_argv = buildargv (buffer);
++      /* If *ARGVP is not already dynamically allocated, copy it.  */
++      if (!argv_dynamic)
++	*argvp = dupargv (*argvp);
++      /* Count the number of arguments.  */
++      file_argc = 0;
++      while (file_argv[file_argc])
++	++file_argc;
++      /* Now, insert FILE_ARGV into ARGV.  The "+1" below handles the
++	 NULL terminator at the end of ARGV.  */ 
++      *argvp = ((char **) 
++		xrealloc (*argvp, 
++			  (*argcp + file_argc + 1) * sizeof (char *)));
++      memmove (*argvp + i + file_argc, *argvp + i + 1, 
++	       (*argcp - i) * sizeof (char *));
++      memcpy (*argvp + i, file_argv, file_argc * sizeof (char *));
++      /* The original option has been replaced by all the new
++	 options.  */
++      *argcp += file_argc - 1;
++      /* Free up memory allocated to process the response file.  We do
++	 not use freeargv because the individual options in FILE_ARGV
++	 are now in the main ARGV.  */
++      free (file_argv);
++      free (buffer);
++      /* Rescan all of the arguments just read to support response
++	 files that include other response files.  */
++      --i;
++    error:
++      /* We're all done with the file now.  */
++      fclose (f);
++    }
++}
++
++
+ #ifdef MAIN
+
+ /* Simple little test driver. */