GCC 4.2.0 release.

1 files changed, 384 insertions, 115 deletions

diff --git a/contrib/gcc/pretty-print.c b/contrib/gcc/pretty-print.c
index 9e3fbba..82df53b 100644
--- a/contrib/gcc/pretty-print.c
+++ b/contrib/gcc/pretty-print.c
@@ -1,5 +1,5 @@
 /* Various declarations for language-independent pretty-print subroutines.
-   Copyright (C) 2003 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 
 This file is part of GCC.
@@ -16,22 +16,24 @@ for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 
 #include "config.h"
 #undef FLOAT /* This is for hpux. They should change hpux.  */
 #undef FFS  /* Some systems define this in param.h.  */
 #include "system.h"
 #include "coretypes.h"
+#include "intl.h"
 #include "pretty-print.h"
+#include "tree.h"
 
 #define obstack_chunk_alloc xmalloc
 #define obstack_chunk_free  free
 
 /* A pointer to the formatted diagnostic message.  */
 #define pp_formatted_text_data(PP) \
-   ((const char *) obstack_base (&pp_base (PP)->buffer->obstack))
+   ((const char *) obstack_base (pp_base (PP)->buffer->obstack))
 
 /* Format an integer given by va_arg (ARG, type-specifier T) where
    type-specifier is a precision modifier as indicated by PREC.  F is
@@ -91,7 +93,7 @@ pp_clear_state (pretty_printer *pp)
 }
 
 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream.  */
-static inline void
+void
 pp_write_text_to_stream (pretty_printer *pp)
 {
   const char *text = pp_formatted_text (pp);
@@ -147,7 +149,7 @@ pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
 static inline void
 pp_append_r (pretty_printer *pp, const char *start, int length)
 {
-  obstack_grow (&pp->buffer->obstack, start, length);
+  obstack_grow (pp->buffer->obstack, start, length);
   pp->buffer->line_length += length;
 }
 
@@ -164,8 +166,7 @@ pp_base_indent (pretty_printer *pp)
     pp_space (pp);
 }
 
-/* Format a message pointed to by TEXT.  The following format specifiers are
-   recognized as being client independent:
+/* The following format specifiers are recognized as being client independent:
    %d, %i: (signed) integer in base ten.
    %u: unsigned integer in base ten.
    %o: unsigned integer in base eight.
@@ -177,51 +178,250 @@ pp_base_indent (pretty_printer *pp)
    %s: string.
    %p: pointer.
    %m: strerror(text->err_no) - does not consume a value from args_ptr.
-   %%: `%'.
-   %.*s: a substring the length of which is specified by an integer.
-   %H: location_t.  */
+   %%: '%'.
+   %<: opening quote.
+   %>: closing quote.
+   %': apostrophe (should only be used in untranslated messages;
+       translations should use appropriate punctuation directly).
+   %.*s: a substring the length of which is specified by an argument
+	 integer.
+   %Ns: likewise, but length specified as constant in the format string.
+   %H: location_t.
+   %J: a decl tree, from which DECL_SOURCE_LOCATION will be recorded.
+   Flag 'q': quote formatted text (must come immediately after '%').
+
+   Arguments can be used sequentially, or through %N$ resp. *N$
+   notation Nth argument after the format string.  If %N$ / *N$
+   notation is used, it must be used for all arguments, except %m, %%,
+   %<, %> and %', which may not have a number, as they do not consume
+   an argument.  When %M$.*N$s is used, M must be N + 1.  (This may
+   also be written %M$.*s, provided N is not otherwise used.)  The
+   format string must have conversion specifiers with argument numbers
+   1 up to highest argument; each argument may only be used once.
+   A format string can have at most 30 arguments.  */
+
+/* Formatting phases 1 and 2: render TEXT->format_spec plus
+   TEXT->args_ptr into a series of chunks in PP->buffer->args[].
+   Phase 3 is in pp_base_format_text.  */
+
 void
-pp_base_format_text (pretty_printer *pp, text_info *text)
+pp_base_format (pretty_printer *pp, text_info *text)
 {
-  for (; *text->format_spec; ++text->format_spec)
+  output_buffer *buffer = pp->buffer;
+  const char *p;
+  const char **args;
+  struct chunk_info *new_chunk_array;
+
+  unsigned int curarg = 0, chunk = 0, argno;
+  pp_wrapping_mode_t old_wrapping_mode;
+  bool any_unnumbered = false, any_numbered = false;
+  const char **formatters[PP_NL_ARGMAX];
+
+  /* Allocate a new chunk structure.  */
+  new_chunk_array = XOBNEW (&buffer->chunk_obstack, struct chunk_info);
+  new_chunk_array->prev = buffer->cur_chunk_array;
+  buffer->cur_chunk_array = new_chunk_array;
+  args = new_chunk_array->args;
+
+  /* Formatting phase 1: split up TEXT->format_spec into chunks in
+     PP->buffer->args[].  Even-numbered chunks are to be output
+     verbatim, odd-numbered chunks are format specifiers.
+     %m, %%, %<, %>, and %' are replaced with the appropriate text at
+     this point.  */
+
+  memset (formatters, 0, sizeof formatters);
+  
+  for (p = text->format_spec; *p; )
+    {
+      while (*p != '\0' && *p != '%')
+	{
+	  obstack_1grow (&buffer->chunk_obstack, *p);
+	  p++;
+	}
+
+      if (*p == '\0')
+	break;
+
+      switch (*++p)
+	{
+	case '\0':
+	  gcc_unreachable ();
+	  
+	case '%':
+	  obstack_1grow (&buffer->chunk_obstack, '%');
+	  p++;
+	  continue;
+
+	case '<':
+	  obstack_grow (&buffer->chunk_obstack,
+			open_quote, strlen (open_quote));
+	  p++;
+	  continue;
+
+	case '>':
+	case '\'':
+	  obstack_grow (&buffer->chunk_obstack,
+			close_quote, strlen (close_quote));
+	  p++;
+	  continue;
+
+	case 'm':
+	  {
+	    const char *errstr = xstrerror (text->err_no);
+	    obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
+	  }
+	  p++;
+	  continue;
+
+	default:
+	  /* Handled in phase 2.  Terminate the plain chunk here.  */
+	  obstack_1grow (&buffer->chunk_obstack, '\0');
+	  gcc_assert (chunk < PP_NL_ARGMAX * 2);
+	  args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
+	  break;
+	}
+
+      if (ISDIGIT (*p))
+	{
+	  char *end;
+	  argno = strtoul (p, &end, 10) - 1;
+	  p = end;
+	  gcc_assert (*p == '$');
+	  p++;
+
+	  any_numbered = true;
+	  gcc_assert (!any_unnumbered);
+	}
+      else
+	{
+	  argno = curarg++;
+	  any_unnumbered = true;
+	  gcc_assert (!any_numbered);
+	}
+      gcc_assert (argno < PP_NL_ARGMAX);
+      gcc_assert (!formatters[argno]);
+      formatters[argno] = &args[chunk];
+      do
+	{
+	  obstack_1grow (&buffer->chunk_obstack, *p);
+	  p++;
+	}
+      while (strchr ("qwl+#", p[-1]));
+
+      if (p[-1] == '.')
+	{
+	  /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
+	     (where M == N + 1).  */
+	  if (ISDIGIT (*p))
+	    {
+	      do
+		{
+		  obstack_1grow (&buffer->chunk_obstack, *p);
+		  p++;
+		}
+	      while (ISDIGIT (p[-1]));
+	      gcc_assert (p[-1] == 's');
+	    }
+	  else
+	    {
+	      gcc_assert (*p == '*');
+	      obstack_1grow (&buffer->chunk_obstack, '*');
+	      p++;
+
+	      if (ISDIGIT (*p))
+		{
+		  char *end;
+		  unsigned int argno2 = strtoul (p, &end, 10) - 1;
+		  p = end;
+		  gcc_assert (argno2 == argno - 1);
+		  gcc_assert (!any_unnumbered);
+		  gcc_assert (*p == '$');
+
+		  p++;
+		  formatters[argno2] = formatters[argno];
+		}
+	      else
+		{
+		  gcc_assert (!any_numbered);
+		  formatters[argno+1] = formatters[argno];
+		  curarg++;
+		}
+	      gcc_assert (*p == 's');
+	      obstack_1grow (&buffer->chunk_obstack, 's');
+	      p++;
+	    }
+	}
+      if (*p == '\0')
+	break;
+
+      obstack_1grow (&buffer->chunk_obstack, '\0');
+      gcc_assert (chunk < PP_NL_ARGMAX * 2);
+      args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
+    }
+
+  obstack_1grow (&buffer->chunk_obstack, '\0');
+  gcc_assert (chunk < PP_NL_ARGMAX * 2);
+  args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
+  args[chunk] = 0;
+		  
+  /* Set output to the argument obstack, and switch line-wrapping and
+     prefixing off.  */
+  buffer->obstack = &buffer->chunk_obstack;
+  old_wrapping_mode = pp_set_verbatim_wrapping (pp);
+
+  /* Second phase.  Replace each formatter with the formatted text it
+     corresponds to.  */
+
+  for (argno = 0; formatters[argno]; argno++)
     {
       int precision = 0;
       bool wide = false;
+      bool plus = false;
+      bool hash = false;
+      bool quote = false;
 
-      /* Ignore text.  */
-      {
-	const char *p = text->format_spec;
-	while (*p && *p != '%')
-	  ++p;
-	pp_wrap_text (pp, text->format_spec, p);
-        text->format_spec = p;
-      }
+      /* We do not attempt to enforce any ordering on the modifier
+	 characters.  */
 
-      if (*text->format_spec == '\0')
-	break;
+      for (p = *formatters[argno];; p++)
+	{
+	  switch (*p)
+	    {
+	    case 'q':
+	      gcc_assert (!quote);
+	      quote = true;
+	      continue;
+
+	    case '+':
+	      gcc_assert (!plus);
+	      plus = true;
+	      continue;
+
+	    case '#':
+	      gcc_assert (!hash);
+	      hash = true;
+	      continue;
+
+	    case 'w':
+	      gcc_assert (!wide);
+	      wide = true;
+	      continue;
+
+	    case 'l':
+	      /* We don't support precision beyond that of "long long".  */
+	      gcc_assert (precision < 2);
+	      precision++;
+	      continue;
+	    }
+	  break;
+	}
+
+      gcc_assert (!wide || precision == 0);
+
+      if (quote)
+	pp_string (pp, open_quote);
 
-      /* We got a '%'.  Parse precision modifiers, if any.  */
-      switch (*++text->format_spec)
-        {
-        case 'w':
-          wide = true;
-          ++text->format_spec;
-          break;
-
-        case 'l':
-          do
-            ++precision;
-          while (*++text->format_spec == 'l');
-          break;
-
-        default:
-          break;
-        }
-      /* We don't support precision beyond that of "long long".  */
-      if (precision > 2)
-        abort();
-
-      switch (*text->format_spec)
+      switch (*p)
 	{
 	case 'c':
 	  pp_character (pp, va_arg (*text->args_ptr, int));
@@ -229,92 +429,148 @@ pp_base_format_text (pretty_printer *pp, text_info *text)
 
 	case 'd':
 	case 'i':
-          if (wide)
-            pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
-          else
-            pp_integer_with_precision
-              (pp, *text->args_ptr, precision, int, "d");
+	  if (wide)
+	    pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
+	  else
+	    pp_integer_with_precision
+	      (pp, *text->args_ptr, precision, int, "d");
 	  break;
 
 	case 'o':
-          if (wide)
-            pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
-                       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
-          else
-            pp_integer_with_precision
-              (pp, *text->args_ptr, precision, unsigned, "u");
+	  if (wide)
+	    pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
+		       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
+	  else
+	    pp_integer_with_precision
+	      (pp, *text->args_ptr, precision, unsigned, "o");
 	  break;
 
 	case 's':
 	  pp_string (pp, va_arg (*text->args_ptr, const char *));
 	  break;
 
-        case 'p':
-          pp_pointer (pp, va_arg (*text->args_ptr, void *));
-          break;
+	case 'p':
+	  pp_pointer (pp, va_arg (*text->args_ptr, void *));
+	  break;
 
 	case 'u':
-          if (wide)
-            pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
-                       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
-          else
-            pp_integer_with_precision
-              (pp, *text->args_ptr, precision, unsigned, "u");
+	  if (wide)
+	    pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
+		       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
+	  else
+	    pp_integer_with_precision
+	      (pp, *text->args_ptr, precision, unsigned, "u");
 	  break;
 
 	case 'x':
-          if (wide)
-            pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
-                       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
-          else
-            pp_integer_with_precision
-              (pp, *text->args_ptr, precision, unsigned, "x");
+	  if (wide)
+	    pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
+		       va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
+	  else
+	    pp_integer_with_precision
+	      (pp, *text->args_ptr, precision, unsigned, "x");
 	  break;
 
-	case 'm':
-	  pp_string (pp, xstrerror (text->err_no));
+	case 'H':
+	  {
+	    location_t *locus = va_arg (*text->args_ptr, location_t *);
+	    gcc_assert (text->locus != NULL);
+	    *text->locus = *locus;
+	  }
 	  break;
 
-	case '%':
-	  pp_character (pp, '%');
+	case 'J':
+	  {
+	    tree t = va_arg (*text->args_ptr, tree);
+	    gcc_assert (text->locus != NULL);
+	    *text->locus = DECL_SOURCE_LOCATION (t);
+	  }
 	  break;
 
-        case 'H':
-          {
-            const location_t *locus = va_arg (*text->args_ptr, location_t *);
-            pp_string (pp, "file '");
-            pp_string (pp, locus->file);
-            pp_string (pp, "', line ");
-            pp_decimal_int (pp, locus->line);
-          }
-          break;
-
 	case '.':
 	  {
 	    int n;
 	    const char *s;
-	    /* We handle no precision specifier but `%.*s'.  */
-	    if (*++text->format_spec != '*')
-	      abort ();
-	    else if (*++text->format_spec != 's')
-	      abort ();
-	    n = va_arg (*text->args_ptr, int);
+
+	    /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
+	       (where M == N + 1).  The format string should be verified
+	       already from the first phase.  */
+	    p++;
+	    if (ISDIGIT (*p))
+	      {
+		char *end;
+		n = strtoul (p, &end, 10);
+		p = end;
+		gcc_assert (*p == 's');
+	      }
+	    else
+	      {
+		gcc_assert (*p == '*');
+		p++;
+		gcc_assert (*p == 's');
+		n = va_arg (*text->args_ptr, int);
+
+		/* This consumes a second entry in the formatters array.  */
+		gcc_assert (formatters[argno] == formatters[argno+1]);
+		argno++;
+	      }
+
 	    s = va_arg (*text->args_ptr, const char *);
 	    pp_append_text (pp, s, s + n);
 	  }
 	  break;
 
 	default:
-          if (!pp_format_decoder (pp) || !(*pp_format_decoder (pp)) (pp, text))
-	    {
-	      /* Hmmm.  The client failed to install a format translator
-                 but called us with an unrecognized format.  Or, maybe, the
-                 translated string just contains an invalid format, or
-                 has formats in the wrong order.  Sorry.  */
-	      abort ();
-	    }
+	  {
+	    bool ok;
+
+	    gcc_assert (pp_format_decoder (pp));
+	    ok = pp_format_decoder (pp) (pp, text, p,
+					 precision, wide, plus, hash);
+	    gcc_assert (ok);
+	  }
 	}
+
+      if (quote)
+	pp_string (pp, close_quote);
+
+      obstack_1grow (&buffer->chunk_obstack, '\0');
+      *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
     }
+
+#ifdef ENABLE_CHECKING
+  for (; argno < PP_NL_ARGMAX; argno++)
+    gcc_assert (!formatters[argno]);
+#endif
+
+  /* Revert to normal obstack and wrapping mode.  */
+  buffer->obstack = &buffer->formatted_obstack;
+  buffer->line_length = 0;
+  pp_wrapping_mode (pp) = old_wrapping_mode;
+  pp_clear_state (pp);
+}
+
+/* Format of a message pointed to by TEXT.  */
+void
+pp_base_output_formatted_text (pretty_printer *pp)
+{
+  unsigned int chunk;
+  output_buffer *buffer = pp_buffer (pp);
+  struct chunk_info *chunk_array = buffer->cur_chunk_array;
+  const char **args = chunk_array->args;
+
+  gcc_assert (buffer->obstack == &buffer->formatted_obstack);
+  gcc_assert (buffer->line_length == 0);
+
+  /* This is a third phase, first 2 phases done in pp_base_format_args.
+     Now we actually print it.  */
+  for (chunk = 0; args[chunk]; chunk++)
+    pp_string (pp, args[chunk]);
+
+  /* Deallocate the chunk structure and everything after it (i.e. the
+     associated series of formatted strings).  */
+  buffer->cur_chunk_array = chunk_array->prev;
+  obstack_free (&buffer->chunk_obstack, chunk_array);
 }
 
 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
@@ -322,17 +578,15 @@ pp_base_format_text (pretty_printer *pp, text_info *text)
 void
 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
 {
-  diagnostic_prefixing_rule_t rule = pp_prefixing_rule (pp);
-  int line_cutoff = pp_line_cutoff (pp);
-
   /* Set verbatim mode.  */
-  pp->prefixing_rule = DIAGNOSTICS_SHOW_PREFIX_NEVER;
-  pp_line_cutoff (pp) = 0;
+  pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
+
   /* Do the actual formatting.  */
-  pp_format_text (pp, text);
+  pp_format (pp, text);
+  pp_output_formatted_text (pp);
+
   /* Restore previous settings.  */
-  pp_prefixing_rule (pp) = rule;
-  pp_line_cutoff (pp) = line_cutoff;
+  pp_wrapping_mode (pp) = oldmode;
 }
 
 /* Flush the content of BUFFER onto the attached stream.  */
@@ -360,7 +614,7 @@ pp_base_set_line_maximum_length (pretty_printer *pp, int length)
 void
 pp_base_clear_output_area (pretty_printer *pp)
 {
-  obstack_free (&pp->buffer->obstack, obstack_base (&pp->buffer->obstack));
+  obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack));
   pp->buffer->line_length = 0;
 }
 
@@ -423,8 +677,10 @@ void
 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
 {
   memset (pp, 0, sizeof (pretty_printer));
-  pp->buffer = xcalloc (1, sizeof (output_buffer));
-  obstack_init (&pp->buffer->obstack);
+  pp->buffer = XCNEW (output_buffer);
+  obstack_init (&pp->buffer->chunk_obstack);
+  obstack_init (&pp->buffer->formatted_obstack);
+  pp->buffer->obstack = &pp->buffer->formatted_obstack;
   pp->buffer->stream = stderr;
   pp_line_cutoff (pp) = maximum_length;
   pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
@@ -455,7 +711,7 @@ pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
 const char *
 pp_base_formatted_text (pretty_printer *pp)
 {
-  obstack_1grow (&pp->buffer->obstack, '\0');
+  obstack_1grow (pp->buffer->obstack, '\0');
   return pp_formatted_text_data (pp);
 }
 
@@ -465,7 +721,7 @@ const char *
 pp_base_last_position_in_text (const pretty_printer *pp)
 {
   const char *p = NULL;
-  struct obstack *text = &pp->buffer->obstack;
+  struct obstack *text = pp->buffer->obstack;
 
   if (obstack_base (text) != obstack_next_free (text))
     p = ((const char *) obstack_next_free (text)) - 1;
@@ -492,7 +748,9 @@ pp_printf (pretty_printer *pp, const char *msg, ...)
   text.err_no = errno;
   text.args_ptr = &ap;
   text.format_spec = msg;
-  pp_format_text (pp, &text);
+  text.locus = NULL;
+  pp_format (pp, &text);
+  pp_output_formatted_text (pp);
   va_end (ap);
 }
 
@@ -508,6 +766,7 @@ pp_verbatim (pretty_printer *pp, const char *msg, ...)
   text.err_no = errno;
   text.args_ptr = &ap;
   text.format_spec = msg;
+  text.locus = NULL;
   pp_format_verbatim (pp, &text);
   va_end (ap);
 }
@@ -518,7 +777,7 @@ pp_verbatim (pretty_printer *pp, const char *msg, ...)
 void
 pp_base_newline (pretty_printer *pp)
 {
-  obstack_1grow (&pp->buffer->obstack, '\n');
+  obstack_1grow (pp->buffer->obstack, '\n');
   pp->buffer->line_length = 0;
 }
 
@@ -533,7 +792,7 @@ pp_base_character (pretty_printer *pp, int c)
       if (ISSPACE (c))
         return;
     }
-  obstack_1grow (&pp->buffer->obstack, c);
+  obstack_1grow (pp->buffer->obstack, c);
   ++pp->buffer->line_length;
 }
 
@@ -545,4 +804,14 @@ pp_base_string (pretty_printer *pp, const char *str)
   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 }
 
+/* Maybe print out a whitespace if needed.  */
 
+void
+pp_base_maybe_space (pretty_printer *pp)
+{
+  if (pp_base (pp)->padding != pp_none)
+    {
+      pp_space (pp);
+      pp_base (pp)->padding = pp_none;
+    }
+}