2008-08-21 Manuel Lopez-Ibanez <manu@gcc.gnu.org>

[pf3gnuchains/gcc-fork.git] / gcc / cp / error.c

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 94f108e..395ede2 100644 (file)
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -1,7 +1,7 @@
 /* Call-backs for C++ error reporting.
    This code is non-reentrant.
    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
-   2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
    This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify
@@ -284,7 +284,10 @@ dump_type (tree t, int flags)
   switch (TREE_CODE (t))
     {
     case UNKNOWN_TYPE:
-      pp_identifier (cxx_pp, "<unresolved overloaded function type>");
+      if (t == init_list_type_node)
+       pp_identifier (cxx_pp, "<brace-enclosed initializer list>");
+      else
+       pp_identifier (cxx_pp, "<unresolved overloaded function type>");
       break;
 
     case TREE_LIST:
@@ -326,6 +329,7 @@ dump_type (tree t, int flags)
     case BOOLEAN_TYPE:
     case COMPLEX_TYPE:
     case VECTOR_TYPE:
+    case FIXED_POINT_TYPE:
       pp_type_specifier_seq (cxx_pp, t);
       break;
 
@@ -1583,43 +1587,6 @@ dump_expr (tree t, int flags)
       }
       break;
 
-    case NEW_EXPR:
-      {
-       tree type = TREE_OPERAND (t, 1);
-       tree init = TREE_OPERAND (t, 2);
-       if (NEW_EXPR_USE_GLOBAL (t))
-         pp_cxx_colon_colon (cxx_pp);
-       pp_cxx_identifier (cxx_pp, "new");
-       if (TREE_OPERAND (t, 0))
-         {
-           pp_cxx_left_paren (cxx_pp);
-           dump_expr_list (TREE_OPERAND (t, 0), flags);
-           pp_cxx_right_paren (cxx_pp);
-           pp_cxx_whitespace (cxx_pp);
-         }
-       if (TREE_CODE (type) == ARRAY_REF)
-         type = build_cplus_array_type
-           (TREE_OPERAND (type, 0),
-            build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
-                                           TREE_OPERAND (type, 1),
-                                           integer_one_node)));
-       dump_type (type, flags);
-       if (init)
-         {
-           pp_cxx_left_paren (cxx_pp);
-           if (TREE_CODE (init) == TREE_LIST)
-             dump_expr_list (init, flags);
-           else if (init == void_zero_node)
-             /* This representation indicates an empty initializer,
-                e.g.: "new int()".  */
-             ;
-           else
-             dump_expr (init, flags);
-           pp_cxx_right_paren (cxx_pp);
-         }
-      }
-      break;
-
     case TARGET_EXPR:
       /* Note that this only works for G++ target exprs.  If somebody
         builds a general TARGET_EXPR, there's no way to represent that
@@ -1783,8 +1750,7 @@ dump_expr (tree t, int flags)
       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
       break;
 
-    case NOP_EXPR:
-    case CONVERT_EXPR:
+    CASE_CONVERT:
     case VIEW_CONVERT_EXPR:
       {
        tree op = TREE_OPERAND (t, 0);
@@ -2075,11 +2041,34 @@ dump_expr (tree t, int flags)
     case TYPEID_EXPR:
     case MEMBER_REF:
     case DOTSTAR_EXPR:
+    case NEW_EXPR:
+    case VEC_NEW_EXPR:
     case DELETE_EXPR:
     case VEC_DELETE_EXPR:
     case MODOP_EXPR:
     case ABS_EXPR:
+    case CONJ_EXPR:
+    case VECTOR_CST:
+    case FIXED_CST:
+    case UNORDERED_EXPR:
+    case ORDERED_EXPR:
+    case UNLT_EXPR:
+    case UNLE_EXPR:
+    case UNGT_EXPR:
+    case UNGE_EXPR:
+    case UNEQ_EXPR:
+    case LTGT_EXPR:
+      pp_expression (cxx_pp, t);
+      break;
+
+    case TRUTH_AND_EXPR:
+    case TRUTH_OR_EXPR:
+    case TRUTH_XOR_EXPR:
+      if (flags & TFF_EXPR_IN_PARENS)
+       pp_cxx_left_paren (cxx_pp);
       pp_expression (cxx_pp, t);
+      if (flags & TFF_EXPR_IN_PARENS)
+       pp_cxx_right_paren (cxx_pp);
       break;
 
     case OBJ_TYPE_REF:
@@ -2399,7 +2388,9 @@ cp_print_error_function (diagnostic_context *context,
          if (abstract_origin)
            {
              ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
-             while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
+             while (TREE_CODE (ao) == BLOCK
+                    && BLOCK_ABSTRACT_ORIGIN (ao)
+                    && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
                ao = BLOCK_ABSTRACT_ORIGIN (ao);
              gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
              fndecl = ao;
@@ -2457,14 +2448,12 @@ cp_print_error_function (diagnostic_context *context,
                  pp_base_newline (context->printer);
                  if (s.file != NULL)
                    {
-#ifdef USE_MAPPED_LOCATION
                      if (flag_show_column && s.column != 0)
                        pp_printf (context->printer,
                                   "    inlined from %qs at %s:%d:%d",
                                   cxx_printable_name (fndecl, 2),
                                   s.file, s.line, s.column);
                      else
-#endif
                        pp_printf (context->printer,
                                   "    inlined from %qs at %s:%d",
                                   cxx_printable_name (fndecl, 2),
@@ -2674,7 +2663,7 @@ cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
       dlevel = DK_WARNING;
       break;
     case CPP_DL_PEDWARN:
-      dlevel = pedantic_error_kind ();
+      dlevel = DK_PEDWARN;
       break;
     case CPP_DL_ERROR:
       dlevel = DK_ERROR;
@@ -2690,13 +2679,20 @@ cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
   report_diagnostic (&diagnostic);
 }
 
-/* Warn about the use of variadic templates when appropriate.  */
+/* Warn about the use of C++0x features when appropriate.  */
 void
-maybe_warn_variadic_templates (void)
+maybe_warn_cpp0x (const char* str)
 {
   if ((cxx_dialect == cxx98) && !in_system_header)
     /* We really want to suppress this warning in system headers,
        because libstdc++ uses variadic templates even when we aren't
        in C++0x mode. */
-    pedwarn ("ISO C++ does not include variadic templates");
+    pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
+}
+
+/* Warn about the use of variadic templates when appropriate.  */
+void
+maybe_warn_variadic_templates (void)
+{
+  maybe_warn_cpp0x ("variadic templates");
 }