pretty-print.c (pp_base_indent): Rename from pp_indent.

	* pretty-print.c (pp_base_indent): Rename from pp_indent.
	* c-pretty-print.h (pp_c_pretty_print_flag)s: New datatype.
	(struct c_pretty_print_info): Add more fields.
	(pp_c_left_paren): Move to c-pretty-print.c.
	(pp_c_right_paren): Likewise.
	(pp_c_left_brace): Likewise.
	(pp_c_right_brace): Likewise.
	(pp_c_left_bracket): Likewise.
	(pp_c_right_bracket): Likewise.
	(pp_c_declarator): Declare.
	(pp_c_direct_declarator): Likewise.
	(pp_c_specifier_qualifier_list): Likewise.
	(pp_c_type_id): Likewise.
	* c-pretty-print.c (pp_c_cv_qualifier): Change prootype. Rework..
	(pp_c_type_qualifier_list): New.
	(pp_c_pointer): Likewise.
	(pp_c_parameter_type_list): Likewise.
	(pp_c_function_definition): Likewise.
	(pp_c_id_expression): Likewise.
	(pp_c_simple_type_specifier): Tidy.
	(pp_c_unary_expression): Likewise.
	(pp_c_expression): Likewise.
	(pp_c_pretty_printer_init): Likewise.
	(pp_c_specifier_qualifier_list): Rework..
	(pp_c_abstract_declarator): Likewise.
	(pp_c_postfix_expression): Likewise.
	(pp_c_primary_expression): Likewise.
	(pp_c_cast_expression): Likewise.
	(pp_c_direct_abstract_declarator): Likewise.
	(pp_c_storage_class_specifier): Likewise.
	(pp_c_function_specifier): Likewise.
	(pp_c_declaration_specifiers): Likewise.
	(pp_c_direct_declarator): Likewise.
	(pp_c_declarator): Likewise.
	(pp_c_declaration): Likewise.
	(pp_c_statement): Likewise.
	(pp_c_integer_constant): Rename from pp_c_integer_literal.
	(pp_c_character_constant): Rename from pp_c_character_literal.
	(pp_c_bool_constant): Rename from pp_c_bool_literal.
	(pp_c_enumeration_constant): Rename from pp_c_enumerator.
	(pp_c_floating_constant): Rename from pp_c_real_literal.
	(pp_c_constant): Rename from pp_c_literal.
	* c-lang.c: Include diagnostic.h and c-pretty-print.h
	(LANG_HOOKS_INITIALIZE_DIAGNOSTITCS): Define.
	(c_initialize_diagnostics): New.
	* Makefile.in (c-lang.o): Update dependency.

cp/

	* error.c (dump_expr): Tidy.
	* cxx-pretty-print.c (pp_cxx_nonconsecutive_character): New.
	(pp_cxx_begin_template_argument_list): Likewise.
	(pp_cxx_end_template_argument_list): Likewise.
	(is_destructor_name): Likewise.
	(pp_cxx_unqualified_id): Likewise.
	(pp_cxx_qualified_id): Likewise.
	(pp_cxx_id_expression): Likewise.
	(pp_cxx_new_expression): Likewise.
	(pp_cxx_delete_expression): Likewise.
	(pp_cxx_pm_expression): Likewise.
	(pp_cxx_type_specifier): Rework.
	(pp_cxx_type_id): Likewise.
	(pp_cxx_primary_expression): Likewise.
	(pp_cxx_postfix_expression): Likewise.
	(pp_cxx_unary_expression): Likewise.
	(pp_cxx_multiplicative_expression): Likewise.
	(pp_cxx_conditional_expression): Likewise.
	(pp_cxx_assignment_expression): Likewise.
	(pp_cxx_pretty_printer_init): Tidy.

From-SVN: r70299

1 files changed, 707 insertions, 204 deletions

diff --git a/gcc/c-pretty-print.c b/gcc/c-pretty-print.c
index 58a66e0..ee4d2a4 100644
--- a/gcc/c-pretty-print.c
+++ b/gcc/c-pretty-print.c
@@ -34,18 +34,85 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    much easier o add extensions and nifty pretty-printing effects that
    takes expresssion or declaration contexts into account.  */
 
+
+#define pp_c_whitespace(PP)           \
+   do {                               \
+     pp_space (PP);                   \
+     pp_base (PP)->padding = pp_none; \
+   } while (0)
+#define pp_c_maybe_whitespace(PP)            \
+   do {                                      \
+     if (pp_base (PP)->padding == pp_before) \
+       pp_c_whitespace (PP);                 \
+   } while (0)
+
+#define pp_c_left_paren(PP)           \
+  do {                                \
+    pp_left_paren (PP);               \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_right_paren(PP)          \
+  do {                                \
+    pp_right_paren (PP);              \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_left_brace(PP)           \
+  do {                                \
+    pp_left_brace (PP);               \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_right_brace(PP)          \
+  do {                                \
+    pp_right_brace (PP);              \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_left_bracket(PP)         \
+  do {                                \
+    pp_left_bracket (PP);             \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_right_bracket(PP)        \
+  do {                                \
+    pp_right_bracket (PP);            \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_arrow(PP)                \
+  do {                                \
+    pp_arrow (PP);                    \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_star(PP)                 \
+  do {                                \
+    pp_star (PP);                     \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_dot(PP)                  \
+  do {                                \
+    pp_dot (PP);                      \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
+#define pp_c_semicolon(PP)            \
+  do {                                \
+    pp_semicolon (PP);                \
+    pp_base (PP)->padding = pp_none;  \
+  } while (0)
+
 /* literal  */
 static void pp_c_char (c_pretty_printer, int);
-static void pp_c_character_literal (c_pretty_printer, tree);
-static void pp_c_bool_literal (c_pretty_printer, tree);
-static bool pp_c_enumerator (c_pretty_printer, tree);
-
 static void pp_c_primary_expression (c_pretty_printer, tree);
 
 /* postfix-expression  */
 static void pp_c_initializer_list (c_pretty_printer, tree);
 
-static void pp_c_unary_expression (c_pretty_printer, tree);
 static void pp_c_multiplicative_expression (c_pretty_printer, tree);
 static void pp_c_additive_expression (c_pretty_printer, tree);
 static void pp_c_shift_expression (c_pretty_printer, tree);
@@ -60,14 +127,10 @@ static void pp_c_assignment_expression (c_pretty_printer, tree);
 
 /* declarations.  */
 static void pp_c_declaration_specifiers (c_pretty_printer, tree);
+static void pp_c_direct_abstract_declarator (c_pretty_printer, tree);
 static void pp_c_init_declarator (c_pretty_printer, tree);
-static void pp_c_declarator (c_pretty_printer, tree);
-static void pp_c_direct_declarator (c_pretty_printer, tree);
-static void pp_c_abstract_declarator (c_pretty_printer, tree);
-static void pp_c_specifier_qualifier_list (c_pretty_printer, tree);
 static void pp_c_simple_type_specifier (c_pretty_printer, tree);
 static void pp_c_parameter_declaration (c_pretty_printer, tree);
-static void pp_c_type_id (c_pretty_printer, tree);
 static void pp_c_storage_class_specifier (c_pretty_printer, tree);
 static void pp_c_function_specifier (c_pretty_printer, tree);
 
@@ -75,21 +138,60 @@ static void pp_c_function_specifier (c_pretty_printer, tree);
 
 /* Declarations.  */
 
-/* Print out CV-qualifiers.  Take care of possible extensions.
-     cv-qualifier:
-        const
-        volatile
-        restrict
-        __restrict__   */
+static void
+pp_c_cv_qualifier (c_pretty_printer pp, const char *cv)
+{
+  const char *p = pp_last_position_in_text (pp);
+  if (p != NULL && *p == '*')
+    pp_c_whitespace (pp);
+  pp_c_identifier (pp, cv);
+}
+
+/* C++ cv-qualifiers are called type-qualifiers in C.  Print out the
+   cv-qualifiers of T.  If T is a declaration then it is the cv-qualifier
+   of its type.  Take care of possible extensions.
+   cv-qualifier:
+       const
+       volatile
+       restrict
+       __restrict__   */
 void
-pp_c_cv_qualifier (c_pretty_printer ppi, int cv)
+pp_c_type_qualifier_list (c_pretty_printer pp, tree t)
 {
-  if (cv & TYPE_QUAL_CONST)
-    pp_c_identifier (ppi, "const");
-  if (cv & TYPE_QUAL_VOLATILE)
-    pp_c_identifier (ppi, "volatile");
-  if (cv & TYPE_QUAL_RESTRICT)
-    pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
+   int qualifiers;
+   
+  if (!TYPE_P (t))
+    t = TREE_TYPE (t);
+
+  qualifiers = TYPE_QUALS (t);
+  if (qualifiers & TYPE_QUAL_CONST)
+    pp_c_cv_qualifier (pp, "const");
+  if (qualifiers & TYPE_QUAL_VOLATILE)
+    pp_c_cv_qualifier (pp, "volatile");
+  if (qualifiers & TYPE_QUAL_RESTRICT)
+    pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
+}
+
+/* pointer:
+      * type-qualifier-list(opt)
+      * type-qualifier-list(opt) pointer  */
+static void
+pp_c_pointer (c_pretty_printer pp, tree t)
+{
+  if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
+    t = TREE_TYPE (t);
+  switch (TREE_CODE (t))
+    {
+    case POINTER_TYPE:
+      if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
+        pp_c_pointer (pp, TREE_TYPE (t));
+      pp_c_star (pp);
+      pp_c_type_qualifier_list (pp, t);
+      break;
+
+    default:
+      pp_unsupported_tree (pp, t);
+    }
 }
 
 /*
@@ -115,7 +217,12 @@ pp_c_cv_qualifier (c_pretty_printer ppi, int cv)
 static void
 pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
 {
-  const enum tree_code code = TREE_CODE (t);
+  enum tree_code code;
+
+  if (DECL_P (t) && TREE_CODE (t) != TYPE_DECL)
+    t = TREE_TYPE (t);
+
+  code = TREE_CODE (t);
   switch (code)
     {
     case ERROR_MARK:
@@ -137,7 +244,7 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
     case CHAR_TYPE:
     case INTEGER_TYPE:
     case REAL_TYPE:
-      pp_c_tree_identifier (ppi, DECL_NAME (t));
+      pp_c_simple_type_specifier (ppi, TYPE_NAME (t));
       break;
 
     case COMPLEX_TYPE:
@@ -151,7 +258,7 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
 
     case TYPE_DECL:
       if (DECL_NAME (t))
-	pp_c_tree_identifier (ppi, DECL_NAME (t));
+	pp_id_expression (ppi, t);
       else
 	pp_c_identifier (ppi, "<typedef-error>");
       break;
@@ -169,38 +276,182 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
 	pp_c_identifier (ppi, "<tag-error>");
 
       if (TYPE_NAME (t))
-	pp_c_tree_identifier (ppi, TYPE_NAME (t));
+	pp_id_expression (ppi, TYPE_NAME (t));
       else
 	pp_c_identifier (ppi, "<anonymous>");
       break;
 
+    case POINTER_TYPE:
+    case ARRAY_TYPE:
+    case FUNCTION_TYPE:
+      pp_c_simple_type_specifier (ppi, TREE_TYPE (t));
+      break;
+
     default:
       pp_unsupported_tree (ppi, t);
+      break;
     }
 }
 
 /* specifier-qualifier-list:
       type-specifier specifier-qualifier-list-opt
-      cv-qualifier specifier-qualifier-list-opt  */
-static inline void
-pp_c_specifier_qualifier_list (c_pretty_printer ppi, tree t)
+      cv-qualifier specifier-qualifier-list-opt
+
+
+  Implementation note:  Because of the non-linearities in array or
+  function declarations, this routinie prints not just the
+  specifier-qualifier-list of such entities or types of such entities,
+  but also the 'pointer' production part of their declarators.  The
+  remaining part is done by pp_declarator or pp_c_abstract_declarator.  */
+void
+pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
 {
-  pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
-  pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
+  if (TREE_CODE (t) != POINTER_TYPE)
+    pp_c_type_qualifier_list (pp, t);
+  switch (TREE_CODE (t))
+    {
+    case POINTER_TYPE:
+      {
+        /* Get the types-specifier of this type.  */
+        tree pointee = TREE_TYPE (t);
+        while (TREE_CODE (pointee) == POINTER_TYPE)
+          pointee = TREE_TYPE (pointee);
+        pp_c_specifier_qualifier_list (pp, pointee);
+        if (TREE_CODE (pointee) == ARRAY_TYPE
+            || TREE_CODE (pointee) == FUNCTION_TYPE)
+          {
+            pp_c_whitespace (pp);
+            pp_c_left_paren (pp);
+          }
+        pp_c_pointer (pp, t);
+        if (TREE_CODE (pointee) != FUNCTION_TYPE
+            && TREE_CODE (pointee) != ARRAY_TYPE)
+          pp_c_whitespace (pp);
+      }
+      break;
+
+    case FUNCTION_TYPE:
+    case ARRAY_TYPE:
+      pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
+      break;
+
+    case VECTOR_TYPE:
+    case COMPLEX_TYPE:
+      pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
+      pp_space (pp);
+      pp_c_simple_type_specifier (pp, t);
+      break;
+
+    default:
+      pp_c_simple_type_specifier (pp, t);
+      break;
+    }
 }
 
+/* parameter-type-list:
+      parameter-list
+      parameter-list , ...
+
+   parameter-list:
+      parameter-declaration
+      parameter-list , parameter-declaration
+
+   parameter-declaration:
+      declaration-specifiers declarator
+      declaration-specifiers abstract-declarator(opt)   */
 static void
-pp_c_abstract_declarator (c_pretty_printer ppi, tree t)
+pp_c_parameter_type_list (c_pretty_printer pp, tree t)
 {
-  pp_unsupported_tree (ppi, t);
+  pp_c_left_paren (pp);
+  if (t == void_list_node)
+    pp_c_identifier (pp, "void");
+  else
+    {
+      bool first = true;
+      bool want_parm_decl = t && DECL_P (t);
+      for ( ; t != NULL && t != void_list_node; t = TREE_CHAIN (t))
+        {
+          if (!first)
+            pp_separate_with (pp, ',');
+          first = false;
+          pp_declaration_specifiers (pp, want_parm_decl ? t : TREE_VALUE (t));
+          if (want_parm_decl)
+            pp_declarator (pp, t);
+          else
+            pp_abstract_declarator (pp, TREE_VALUE (t));
+        }
+    }
+  pp_c_right_paren (pp);
 }
 
-
+/* abstract-declarator:
+      pointer
+      pointer(opt) direct-abstract-declarator  */
 static inline void
+pp_c_abstract_declarator (c_pretty_printer pp, tree t)
+{
+  if (TREE_CODE (t) == POINTER_TYPE)
+    {
+      if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
+          || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+        pp_c_right_paren (pp);
+      t = TREE_TYPE (t);
+    }
+
+  pp_c_direct_abstract_declarator (pp, t);
+}
+
+/* direct-abstract-declarator:
+      ( abstract-declarator )
+      direct-abstract-declarator(opt) [ assignment-expression(opt) ]
+      direct-abstract-declarator(opt) [ * ]
+      direct-abstract-declarator(opt) ( parameter-type-list(opt) )  */
+static void
+pp_c_direct_abstract_declarator (c_pretty_printer pp, tree t)
+{
+  switch (TREE_CODE (t))
+    {
+    case POINTER_TYPE:
+      pp_c_abstract_declarator (pp, t);
+      break;
+      
+    case FUNCTION_TYPE:
+      pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
+      pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
+      break;
+
+    case ARRAY_TYPE:
+      pp_c_left_bracket (pp);
+      if (TYPE_DOMAIN (t))
+        pp_c_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
+      pp_c_right_bracket (pp);
+      pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
+      break;
+
+    case IDENTIFIER_NODE:
+    case VOID_TYPE:
+    case BOOLEAN_TYPE:
+    case INTEGER_TYPE:
+    case REAL_TYPE:
+    case ENUMERAL_TYPE:
+    case RECORD_TYPE:
+    case UNION_TYPE:
+    case VECTOR_TYPE:
+    case COMPLEX_TYPE:
+    case TYPE_DECL:
+      break;
+      
+    default:
+      pp_unsupported_tree (pp, t);
+      break;
+    }
+}
+
+void
 pp_c_type_id (c_pretty_printer ppi, tree t)
 {
   pp_c_specifier_qualifier_list (ppi, t);
-  pp_c_abstract_declarator (ppi, t);
+  pp_abstract_declarator (ppi, t);
 }
 
 static inline void
@@ -208,8 +459,13 @@ pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
 {
   if (TREE_CODE (t) == TYPE_DECL)
     pp_c_identifier (pp, "typedef");
-  else if (DECL_REGISTER (t))
-    pp_c_identifier (pp, "register");
+  else if (DECL_P (t))
+    {
+      if (DECL_REGISTER (t))
+        pp_c_identifier (pp, "register");
+      else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
+        pp_c_identifier (pp, "static");
+    }
 }
 
 static inline void
@@ -219,27 +475,108 @@ pp_c_function_specifier (c_pretty_printer pp, tree t)
     pp_c_identifier (pp, "inline");
 }
 
+/* declaration-specifiers:
+      storage-class-specifier declaration-specifiers(opt)
+      type-specifier declaration-specifiers(opt)
+      type-qualifier declaration-specifiers(opt)
+      function-specifier declaration-specifiers(opt)  */
 static inline void
 pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
 {
-  pp_c_storage_class_specifier (pp, t);
-  pp_c_function_specifier (pp, t);
-  pp_type_specifier (pp, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
-  pp_c_cv_qualifier (pp, TYPE_QUALS (TREE_TYPE (t)));
+  pp_storage_class_specifier (pp, t);
+  pp_function_specifier (pp, t);
+  pp_c_specifier_qualifier_list (pp, DECL_P (t) ?  TREE_TYPE (t) : t);
 }
 
-static inline void
+/* direct-declarator
+      identifier
+      ( declarator )
+      direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
+      direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
+      direct-declarator [ type-qualifier-list static assignment-exression ]
+      direct-declarator [ type-qualifier-list * ]
+      direct-declaratpr ( parameter-type-list )
+      direct-declarator ( identifier-list(opt) )  */
+void
 pp_c_direct_declarator (c_pretty_printer pp, tree t)
 {
-  pp_unsupported_tree (pp, t);
+  switch (TREE_CODE (t))
+    {
+    case VAR_DECL:
+    case PARM_DECL:
+    case TYPE_DECL:
+    case FIELD_DECL:
+    case LABEL_DECL:
+      pp_c_tree_identifier (pp, DECL_NAME (t));
+    case ARRAY_TYPE:
+    case POINTER_TYPE:
+      pp_abstract_declarator (pp, TREE_TYPE (t));
+      break;
+
+    case FUNCTION_TYPE:
+      pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
+      pp_c_abstract_declarator (pp, TREE_TYPE (t));
+      break;
+
+    case FUNCTION_DECL:
+      pp_c_tree_identifier (pp, DECL_NAME (t));
+      if (pp_c_base (pp)->flags & pp_c_flag_abstract)
+        pp_c_abstract_declarator (pp, TREE_TYPE (t));
+      else
+        {
+          pp_c_parameter_type_list (pp, DECL_ARGUMENTS (t));
+          pp_c_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
+        }
+      break;
+
+    case INTEGER_TYPE:
+    case REAL_TYPE:
+    case ENUMERAL_TYPE:
+    case UNION_TYPE:
+    case RECORD_TYPE:
+      break;
+
+    default:
+      pp_unsupported_tree (pp, t);
+      break;
+    }
 }
 
-static inline void
+
+/* declarator:
+      pointer(opt)  direct-declarator   */
+void
 pp_c_declarator (c_pretty_printer pp, tree t)
 {
-  pp_unsupported_tree (pp, t);
+  switch (TREE_CODE (t))
+    {
+    case INTEGER_TYPE:
+    case REAL_TYPE:
+    case ENUMERAL_TYPE:
+    case UNION_TYPE:
+    case RECORD_TYPE:
+      break;
+
+    case VAR_DECL:
+    case PARM_DECL:
+    case FIELD_DECL:
+    case ARRAY_TYPE:
+    case FUNCTION_TYPE:
+    case FUNCTION_DECL:
+    case TYPE_DECL:
+      pp_direct_declarator (pp, t);
+    break;
+
+    
+    default:
+      pp_unsupported_tree (pp, t);
+      break;
+    }
 }
 
+/* init-declarator:
+      declarator:
+      declarator = initializer   */
 static inline void
 pp_c_init_declarator (c_pretty_printer pp, tree t)
 {
@@ -253,6 +590,9 @@ pp_c_init_declarator (c_pretty_printer pp, tree t)
     }
 }
 
+/* declaration:
+      declaration-specifiers init-declarator-list(opt) ;  */
+
 void
 pp_c_declaration (c_pretty_printer pp, tree t)
 {
@@ -293,6 +633,19 @@ pp_c_attributes (c_pretty_printer pp, tree attributes)
   pp_c_right_paren (pp);
 }
 
+/* function-definition:
+      declaration-specifiers declarator compound-statement  */
+void
+pp_c_function_definition (c_pretty_printer pp, tree t)
+{
+  pp_declaration_specifiers (pp, t);
+  pp_declarator (pp, t);
+  pp_needs_newline (pp) = true;
+  pp_statement (pp, DECL_SAVED_TREE (t));
+  pp_newline (pp);
+  pp_flush (pp);
+}
+
 
 /* Expressions.  */
 
@@ -354,43 +707,67 @@ pp_c_string_literal (c_pretty_printer ppi, tree s)
   pp_doublequote (ppi);
 }
 
+static void
+pp_c_integer_constant (c_pretty_printer pp, tree i)
+{
+  if (host_integerp (i, 0))
+    pp_wide_integer (pp, TREE_INT_CST_LOW (i));
+  else
+    {
+      if (tree_int_cst_sgn (i) < 0)
+        {
+          pp_c_char (pp, '-');
+          i = build_int_2 (-TREE_INT_CST_LOW (i),
+                           ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
+        }
+      sprintf (pp_buffer (pp)->digit_buffer,
+               HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+               TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
+      pp_string (pp, pp_buffer (pp)->digit_buffer);
+    }
+}
+
 /* Print out a CHARACTER literal.  */
 static inline void
-pp_c_character_literal (c_pretty_printer ppi, tree c)
+pp_c_character_constant (c_pretty_printer pp, tree c)
 {
   tree type = TREE_TYPE (c);
-  pp_quote (ppi);
+  if (type == wchar_type_node)
+    pp_character (pp, 'L'); 
+  pp_quote (pp);
   if (host_integerp (c, TREE_UNSIGNED (type)))
-    pp_c_char (ppi, tree_low_cst (c, TREE_UNSIGNED (type)));
+    pp_c_char (pp, tree_low_cst (c, TREE_UNSIGNED (type)));
   else
-    pp_scalar (ppi, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
-  pp_quote (ppi);
+    pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
+  pp_quote (pp);
 }
 
 /* Print out a BOOLEAN literal.  */
-void
-pp_c_bool_literal (c_pretty_printer ppi, tree b)
+static void
+pp_c_bool_constant (c_pretty_printer pp, tree b)
 {
-  if (b == boolean_false_node || integer_zerop (b))
+  if (b == boolean_false_node)
     {
       if (c_dialect_cxx ())
-	pp_c_identifier (ppi, "false");
+	pp_c_identifier (pp, "false");
       else if (flag_isoc99)
-	pp_c_identifier (ppi, "_False");
+	pp_c_identifier (pp, "_False");
       else
-	pp_unsupported_tree (ppi, b);
+	pp_unsupported_tree (pp, b);
     }
   else if (b == boolean_true_node)
     {
       if (c_dialect_cxx ())
-	pp_c_identifier (ppi, "true");
+	pp_c_identifier (pp, "true");
       else if (flag_isoc99)
-	pp_c_identifier (ppi, "_True");
+	pp_c_identifier (pp, "_True");
       else
-	pp_unsupported_tree (ppi, b);
+	pp_unsupported_tree (pp, b);
     }
+  else if (TREE_CODE (b) == INTEGER_CST)
+    pp_c_integer_constant (pp, b);
   else
-    pp_unsupported_tree (ppi, b);
+    pp_unsupported_tree (pp, b);
 }
 
 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
@@ -398,8 +775,9 @@ pp_c_bool_literal (c_pretty_printer ppi, tree b)
    print out the type-id part of the cast-expression -- the casted value
    is then printed by pp_c_integer_literal.  */
 static bool
-pp_c_enumerator (c_pretty_printer ppi, tree e)
+pp_c_enumeration_constant (c_pretty_printer ppi, tree e)
 {
+  bool value_is_named = true;
   tree type = TREE_TYPE (e);
   tree value;
 
@@ -410,86 +788,81 @@ pp_c_enumerator (c_pretty_printer ppi, tree e)
     ;
 
   if (value != NULL_TREE)
-    pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
+    pp_id_expression (ppi, TREE_PURPOSE (value));
   else
     {
       /* Value must have been cast.  */
       pp_c_left_paren (ppi);
       pp_type_id (ppi, type);
       pp_c_right_paren (ppi);
-      return false;
+      value_is_named = false;
     }
 
-  return true;
-}
-
-/* Print out an INTEGER constant value.  */
-void
-pp_c_integer_literal (c_pretty_printer ppi, tree i)
-{
-  tree type = TREE_TYPE (i);
-
-  if (type == boolean_type_node)
-    pp_c_bool_literal (ppi, i);
-  else if (type == char_type_node)
-    pp_c_character_literal (ppi, i);
-  else if (TREE_CODE (type) == ENUMERAL_TYPE
-	   && pp_c_enumerator (ppi, i))
-    ;
-  else
-    {
-      if (host_integerp (i, 0))
-	pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
-      else
-	{
-	  if (tree_int_cst_sgn (i) < 0)
-	    {
-	      pp_c_char (ppi, '-');
-	      i = build_int_2 (-TREE_INT_CST_LOW (i),
-			       ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
-	      sprintf (pp_buffer (ppi)->digit_buffer,
-		       HOST_WIDE_INT_PRINT_DOUBLE_HEX,
-		       TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
-	      pp_string (ppi, pp_buffer (ppi)->digit_buffer);
-	    }
-	}
-    }
+  return value_is_named;
 }
 
 /* Print out a REAL value.  */
-void
-pp_c_real_literal (c_pretty_printer ppi, tree r)
+static inline void
+pp_c_floating_constant (c_pretty_printer pp, tree r)
 {
-  real_to_decimal (pp_buffer (ppi)->digit_buffer, &TREE_REAL_CST (r),
-		   sizeof (pp_buffer (ppi)->digit_buffer), 0, 1);
-  pp_string (ppi, pp_buffer(ppi)->digit_buffer);
+  real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
+		   sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
+  pp_string (pp, pp_buffer(pp)->digit_buffer);
 }
 
-
+/* constant:
+      integer-constant
+      floating-constant
+      enumeration-constant
+      chatracter-constant   */
 void
-pp_c_literal (c_pretty_printer ppi, tree e)
+pp_c_constant (c_pretty_printer pp, tree e)
 {
   switch (TREE_CODE (e))
     {
     case INTEGER_CST:
-      pp_c_integer_literal (ppi, e);
+      {
+        tree type = TREE_TYPE (e);
+        if (type == boolean_type_node)
+          pp_c_bool_constant (pp, e);
+        else if (type == char_type_node)
+          pp_c_character_constant (pp, e);
+        else if (TREE_CODE (type) == ENUMERAL_TYPE
+                 && pp_c_enumeration_constant (pp, e))
+          ; 
+        else 
+          pp_c_integer_constant (pp, e);
+      }
       break;
 
     case REAL_CST:
-      pp_c_real_literal (ppi, e);
+      pp_c_floating_constant (pp, e);
       break;
 
     case STRING_CST:
-      pp_c_string_literal (ppi, e);
+      pp_c_string_literal (pp, e);
       break;
 
     default:
-      pp_unsupported_tree (ppi, e);
+      pp_unsupported_tree (pp, e);
       break;
     }
 }
 
-/* Pretty-print a C primary-expression.  */
+void
+pp_c_identifier (c_pretty_printer pp, const char *id)
+{
+  pp_c_maybe_whitespace (pp);            
+  pp_identifier (pp, id);  
+  pp_base (pp)->padding = pp_before;
+}
+
+/* Pretty-print a C primary-expression.
+   primary-expression:
+      identifier
+      constant
+      string-literal
+      ( expression )   */
 static void
 pp_c_primary_expression (c_pretty_printer ppi, tree e)
 {
@@ -518,7 +891,7 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
     case INTEGER_CST:
     case REAL_CST:
     case STRING_CST:
-      pp_c_literal (ppi, e);
+      pp_c_constant (ppi, e);
       break;
 
     case TARGET_EXPR:
@@ -526,7 +899,7 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
       pp_c_identifier (ppi, "__builtin_memcpy");
       pp_c_left_paren (ppi);
       pp_ampersand (ppi);
-      pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
+      pp_primary_expression (ppi, TREE_OPERAND (e, 0));
       pp_separate_with (ppi, ',');
       pp_ampersand (ppi);
       pp_initializer (ppi, TREE_OPERAND (e, 1));
@@ -544,7 +917,7 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
       break;
 
     default:
-      /*  Make sure this call won't cause any infinite loop.  */
+      /* FIXME:  Make sure we won't get into an infinie loop.  */
       pp_c_left_paren (ppi);
       pp_c_expression (ppi, e);
       pp_c_right_paren (ppi);
@@ -552,7 +925,12 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
     }
 }
 
-/* Print out a C initializer -- also support C compound-literals.  */
+/* Print out a C initializer -- also support C compound-literals.
+   initializer:
+      assignment-expression:
+      { initializer-list }
+      { initializer-list , }   */
+
 void
 pp_c_initializer (c_pretty_printer ppi, tree e)
 {
@@ -561,9 +939,9 @@ pp_c_initializer (c_pretty_printer ppi, tree e)
       enum tree_code code = TREE_CODE (TREE_TYPE (e));
       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 	{
-	  pp_left_brace (ppi);
+	  pp_c_left_brace (ppi);
 	  pp_c_initializer_list (ppi, e);
-	  pp_right_brace (ppi);
+	  pp_c_right_brace (ppi);
 	}
       else
 	pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
@@ -572,6 +950,20 @@ pp_c_initializer (c_pretty_printer ppi, tree e)
     pp_assignment_expression (ppi, e);
 }
 
+/* initializer-list:
+      designation(opt) initializer
+      initializer-list , designation(opt) initializer
+
+   designation:
+      designator-list =
+
+   designator-list:
+      designator
+      designator-list designator
+
+   designator:
+      [ constant-expression ]
+      identifier   */
 static void
 pp_c_initializer_list (c_pretty_printer ppi, tree e)
 {
@@ -580,19 +972,19 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e)
 
   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
     {
-      tree init = TREE_OPERAND (e, 1);
+      tree init = TREE_OPERAND (e, 0);
       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 	{
 	  if (code == RECORD_TYPE || code == UNION_TYPE)
 	    {
-	      pp_dot (ppi);
+	      pp_c_dot (ppi);
 	      pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 	    }
 	  else
 	    {
 	      pp_c_left_bracket (ppi);
 	      if (TREE_PURPOSE (init))
-		pp_c_literal (ppi, TREE_PURPOSE (init));
+		pp_c_constant (ppi, TREE_PURPOSE (init));
 	      pp_c_right_bracket (ppi);
 	    }
 	  pp_c_whitespace (ppi);
@@ -607,6 +999,44 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e)
     pp_unsupported_tree (ppi, type);
 }
 
+/*  This is a convenient function, used to bridge gap between C and C++
+    grammars.
+
+    id-expression:
+       identifier  */
+void
+pp_c_id_expression (c_pretty_printer pp, tree t)
+{
+  switch (TREE_CODE (t))
+    {
+    case VAR_DECL:
+    case PARM_DECL:
+    case CONST_DECL:
+    case TYPE_DECL:
+    case FUNCTION_DECL:
+    case FIELD_DECL:
+    case LABEL_DECL:
+      t = DECL_NAME (t);
+    case IDENTIFIER_NODE:
+      pp_c_tree_identifier (pp, t);
+      break;
+
+    default:
+      pp_unsupported_tree (pp, t);
+      break;
+    }
+}
+
+/* postfix-expression:
+      primary-expression
+      postfix-expression [ expression ]
+      postfix-expression ( argument-expression-list(opt) )
+      postfix-expression . identifier
+      postfix-expression -> identifier
+      postfix-expression ++
+      postfix-expression --
+      ( type-name ) { initializer-list }
+      ( type-name ) { initializer-list , }  */
 void
 pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 {
@@ -621,7 +1051,7 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 
     case ARROW_EXPR:
       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
-      pp_arrow (ppi);
+      pp_c_arrow (ppi);
       break;
 
     case ARRAY_REF:
@@ -653,12 +1083,12 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 	if (TREE_CODE (object) == INDIRECT_REF)
 	  {
 	    pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
-	    pp_arrow (ppi);
+	    pp_c_arrow (ppi);
 	  }
 	else
 	  {
 	    pp_postfix_expression (ppi, object);
-	    pp_dot (ppi);
+	    pp_c_dot (ppi);
 	  }
 	pp_c_expression (ppi, TREE_OPERAND (e, 1));
       }
@@ -670,7 +1100,7 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
       pp_c_left_paren (ppi);
       pp_type_id (ppi, TREE_TYPE (e));
       pp_c_right_paren (ppi);
-      pp_left_brace (ppi);
+      pp_c_left_brace (ppi);
 
       if (code == COMPLEX_CST)
 	{
@@ -687,7 +1117,7 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 	  pp_c_expression (ppi, TREE_OPERAND (e, 1));
 	}
 
-      pp_right_brace (ppi);
+      pp_c_right_brace (ppi);
       break;
 
     case COMPOUND_LITERAL_EXPR:
@@ -706,6 +1136,14 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
       pp_c_right_paren (ppi);
       break;
 
+    case ADDR_EXPR:
+      if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
+        {
+          pp_c_id_expression (ppi, TREE_OPERAND (e, 0));
+          break;
+        }
+      /* else fall through.   */
+
     default:
       pp_primary_expression (ppi, e);
       break;
@@ -741,7 +1179,7 @@ pp_c_expression_list (c_pretty_printer ppi, tree e)
       __alignof__ ( type-id )
       __real__ unary-expression
       __imag__ unary-expression  */
-static void
+void
 pp_c_unary_expression (c_pretty_printer ppi, tree e)
 {
   enum tree_code code = TREE_CODE (e);
@@ -759,10 +1197,11 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e)
     case BIT_NOT_EXPR:
     case TRUTH_NOT_EXPR:
     case CONJ_EXPR:
-      if (code == ADDR_EXPR)
+      /* String literal are used by address.  */
+      if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
 	pp_ampersand (ppi);
       else if (code == INDIRECT_REF)
-	pp_star (ppi);
+	pp_c_star (ppi);
       else if (code == NEGATE_EXPR)
 	pp_minus (ppi);
       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
@@ -783,7 +1222,7 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e)
 	  pp_c_right_paren (ppi);
 	}
       else
-	pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
+	pp_unary_expression (ppi, TREE_OPERAND (e, 0));
       break;
 
     case REALPART_EXPR:
@@ -802,15 +1241,20 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e)
 void
 pp_c_cast_expression (c_pretty_printer ppi, tree e)
 {
-  if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
+  switch (TREE_CODE (e))
     {
+    case FLOAT_EXPR:
+    case FIX_TRUNC_EXPR:
+    case CONVERT_EXPR:
       pp_c_left_paren (ppi);
       pp_type_id (ppi, TREE_TYPE (e));
       pp_c_right_paren (ppi);
       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
+      break;
+
+    default:
+      pp_unary_expression (ppi, e);
     }
-  else
-    pp_unary_expression (ppi, e);
 }
 
 static void
@@ -822,10 +1266,10 @@ pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
     case MULT_EXPR:
     case TRUNC_DIV_EXPR:
     case TRUNC_MOD_EXPR:
-      pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
+      pp_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
       pp_c_whitespace (ppi);
       if (code == MULT_EXPR)
-	pp_star (ppi);
+	pp_c_star (ppi);
       else if (code == TRUNC_DIV_EXPR)
 	pp_slash (ppi);
       else
@@ -855,7 +1299,7 @@ pp_c_additive_expression (c_pretty_printer ppi, tree e)
       else
 	pp_minus (ppi);
       pp_c_whitespace (ppi);
-      pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
+      pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1)); 
       break;
 
     default:
@@ -923,7 +1367,7 @@ pp_c_equality_expression (c_pretty_printer ppi, tree e)
     case EQ_EXPR:
     case NE_EXPR:
       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
       pp_c_whitespace (ppi);
       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
@@ -941,7 +1385,7 @@ pp_c_and_expression (c_pretty_printer ppi, tree e)
   if (TREE_CODE (e) == BIT_AND_EXPR)
     {
       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_ampersand (ppi);
       pp_c_whitespace (ppi);
       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
@@ -971,7 +1415,7 @@ pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e)
   if (TREE_CODE (e) == BIT_IOR_EXPR)
     {
       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_bar (ppi);
       pp_c_whitespace (ppi);
       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
@@ -986,7 +1430,7 @@ pp_c_logical_and_expression (c_pretty_printer ppi, tree e)
   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
     {
       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_identifier (ppi, "&&");
       pp_c_whitespace (ppi);
       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
@@ -1001,7 +1445,7 @@ pp_c_logical_or_expression (c_pretty_printer ppi, tree e)
   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
     {
       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_identifier (ppi, "||");
       pp_c_whitespace (ppi);
       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
@@ -1016,7 +1460,7 @@ pp_c_conditional_expression (c_pretty_printer ppi, tree e)
   if (TREE_CODE (e) == COND_EXPR)
     {
       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
+      pp_c_whitespace (ppi);
       pp_question (ppi);
       pp_c_whitespace (ppi);
       pp_c_expression (ppi, TREE_OPERAND (e, 1));
@@ -1053,11 +1497,11 @@ pp_c_expression (c_pretty_printer ppi, tree e)
   switch (TREE_CODE (e))
     {
     case INTEGER_CST:
-      pp_c_integer_literal (ppi, e);
+      pp_c_integer_constant (ppi, e);
       break;
 
     case REAL_CST:
-      pp_c_real_literal (ppi, e);
+      pp_c_floating_constant (ppi, e);
       break;
 
     case STRING_CST:
@@ -1074,7 +1518,7 @@ pp_c_expression (c_pretty_printer ppi, tree e)
     case ERROR_MARK:
     case TARGET_EXPR:
     case STMT_EXPR:
-      pp_c_primary_expression (ppi, e);
+      pp_primary_expression (ppi, e);
       break;
 
     case POSTINCREMENT_EXPR:
@@ -1091,7 +1535,7 @@ pp_c_expression (c_pretty_printer ppi, tree e)
     case COMPOUND_LITERAL_EXPR:
     case COMPLEX_EXPR:
     case VA_ARG_EXPR:
-      pp_c_postfix_expression (ppi, e);
+      pp_postfix_expression (ppi, e);
       break;
 
     case CONJ_EXPR:
@@ -1109,15 +1553,16 @@ pp_c_expression (c_pretty_printer ppi, tree e)
       pp_c_unary_expression (ppi, e);
       break;
 
-    case CONVERT_EXPR:
     case FLOAT_EXPR:
+    case FIX_TRUNC_EXPR:
+    case CONVERT_EXPR:
       pp_c_cast_expression (ppi, e);
       break;
 
     case MULT_EXPR:
     case TRUNC_MOD_EXPR:
     case TRUNC_DIV_EXPR:
-      pp_c_multiplicative_expression (ppi, e);
+      pp_multiplicative_expression (ppi, e);
       break;
 
     case LSHIFT_EXPR:
@@ -1152,17 +1597,23 @@ pp_c_expression (c_pretty_printer ppi, tree e)
       pp_c_logical_or_expression (ppi, e);
       break;
 
+    case EQ_EXPR:
+    case NE_EXPR:
+      pp_c_equality_expression (ppi, e);
+      break;
+      
     case COND_EXPR:
-      pp_c_conditional_expression (ppi, e);
+      pp_conditional_expression (ppi, e);
       break;
 
-    case MODIFY_EXPR:
-    case INIT_EXPR:
-      pp_c_assignment_expression (ppi, e);
+    case PLUS_EXPR:
+    case MINUS_EXPR:
+      pp_c_additive_expression (ppi, e);
       break;
 
-    case NOP_EXPR:
-      pp_c_expression (ppi, TREE_OPERAND (e, 0));
+    case MODIFY_EXPR:
+    case INIT_EXPR:
+      pp_assignment_expression (ppi, e);
       break;
 
     case COMPOUND_EXPR:
@@ -1173,27 +1624,42 @@ pp_c_expression (c_pretty_printer ppi, tree e)
       pp_c_right_paren (ppi);
       break;
 
-
+    case NOP_EXPR:
+    case NON_LVALUE_EXPR:
+    case SAVE_EXPR:
+    case UNSAVE_EXPR:
+      pp_c_expression (ppi, TREE_OPERAND (e, 0));
+      break;
+      
     default:
       pp_unsupported_tree (ppi, e);
       break;
     }
 }
 
+
 
 /* Statements.  */
 void
 pp_c_statement (c_pretty_printer ppi, tree stmt)
 {
-  const enum tree_code code = TREE_CODE (stmt);
+  enum tree_code code;
+
+  if (stmt == NULL)
+    return;
+  
+  code = TREE_CODE (stmt);
   switch (code)
     {
     case LABEL_STMT:
     case CASE_LABEL:
-      pp_newline (ppi);
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, -3);
+      else
+        pp_indentation (ppi) -= 3;
       if (code == LABEL_STMT)
 	pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
-      else if (code == LABEL_STMT)
+      else if (code == CASE_LABEL)
 	{
 	  if (CASE_LOW (stmt) == NULL_TREE)
 	    pp_identifier (ppi, "default");
@@ -1210,35 +1676,45 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
 	    }
 	}
       pp_colon (ppi);
-      pp_newline_and_indent (ppi, 3);
+      pp_indentation (ppi) += 3;
+      pp_needs_newline (ppi) = true;
       break;
 
     case COMPOUND_STMT:
-      pp_left_brace (ppi);
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
+      pp_c_left_brace (ppi);
       pp_newline_and_indent (ppi, 3);
       for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
 	pp_c_statement (ppi, stmt);
       pp_newline_and_indent (ppi, -3);
-      pp_right_brace (ppi);
-      pp_newline (ppi);
+      pp_c_right_brace (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     case EXPR_STMT:
     case CLEANUP_STMT:
-      pp_newline (ppi);
-      pp_c_expression (ppi, code == EXPR_STMT
-		       ? EXPR_STMT_EXPR (stmt)
-		       : CLEANUP_EXPR (stmt));
-      pp_semicolon (ppi);
-      pp_newline (ppi);
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
+      {
+        tree e = code == EXPR_STMT
+          ? EXPR_STMT_EXPR (stmt)
+          : CLEANUP_EXPR (stmt);
+        if (e)
+          pp_c_expression (ppi, e);
+      }
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     case IF_STMT:
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_c_identifier (ppi, "if");
-      pp_space (ppi);
+      pp_c_whitespace (ppi);
       pp_c_left_paren (ppi);
       pp_c_expression (ppi, IF_COND (stmt));
-      pp_right_paren (ppi);
+      pp_c_right_paren (ppi);
       pp_newline_and_indent (ppi, 3);
       pp_statement (ppi, THEN_CLAUSE (stmt));
       pp_newline_and_indent (ppi, -3);
@@ -1257,29 +1733,36 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
       break;
 
     case SWITCH_STMT:
-      pp_newline (ppi);
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_c_identifier (ppi, "switch");
       pp_space (ppi);
       pp_c_left_paren (ppi);
       pp_c_expression (ppi, SWITCH_COND (stmt));
-      pp_right_paren (ppi);
-      pp_newline_and_indent (ppi, 3);
+      pp_c_right_paren (ppi);
+      pp_indentation (ppi) += 3;
+      pp_needs_newline (ppi) = true;
       pp_statement (ppi, SWITCH_BODY (stmt));
       pp_newline_and_indent (ppi, -3);
       break;
 
     case WHILE_STMT:
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_c_identifier (ppi, "while");
       pp_space (ppi);
       pp_c_left_paren (ppi);
       pp_c_expression (ppi, WHILE_COND (stmt));
-      pp_right_paren (ppi);
+      pp_c_right_paren (ppi);
       pp_newline_and_indent (ppi, 3);
       pp_statement (ppi, WHILE_BODY (stmt));
-      pp_newline_and_indent (ppi, -3);
+      pp_indentation (ppi) -= 3;
+      pp_needs_newline (ppi) = true;
       break;
 
     case DO_STMT:
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_c_identifier (ppi, "do");
       pp_newline_and_indent (ppi, 3);
       pp_statement (ppi, DO_BODY (stmt));
@@ -1289,34 +1772,43 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
       pp_c_left_paren (ppi);
       pp_c_expression (ppi, DO_COND (stmt));
       pp_c_right_paren (ppi);
-      pp_semicolon (ppi);
-      pp_newline (ppi);
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     case FOR_STMT:
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_c_identifier (ppi, "for");
       pp_space (ppi);
       pp_c_left_paren (ppi);
-      pp_statement (ppi, FOR_INIT_STMT (stmt));
+      if (FOR_INIT_STMT (stmt))
+        pp_statement (ppi, FOR_INIT_STMT (stmt));
+      else
+        pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = false;
       pp_c_whitespace (ppi);
       if (FOR_COND (stmt))
 	pp_c_expression (ppi, FOR_COND (stmt));
-      pp_semicolon (ppi);
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = false;
       pp_c_whitespace (ppi);
       if (FOR_EXPR (stmt))
 	pp_c_expression (ppi, FOR_EXPR (stmt));
-      pp_right_paren (ppi);
+      pp_c_right_paren (ppi);
       pp_newline_and_indent (ppi, 3);
       pp_statement (ppi, FOR_BODY (stmt));
-      pp_newline_and_indent (ppi, -3);
+      pp_indentation (ppi) -= 3;
+      pp_needs_newline (ppi) = true;
       break;
 
     case BREAK_STMT:
     case CONTINUE_STMT:
-      pp_newline (ppi);
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
-      pp_semicolon (ppi);
-      pp_newline (ppi);
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     case RETURN_STMT:
@@ -1325,36 +1817,43 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
 	tree e = code == RETURN_STMT
 	  ? RETURN_STMT_EXPR (stmt)
 	  : GOTO_DESTINATION (stmt);
-
-	pp_newline (ppi);
+        if (pp_needs_newline (ppi))
+          pp_newline_and_indent (ppi, 0);
 	pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
 	if (e)
 	  pp_c_expression (ppi, e);
-	pp_semicolon (ppi);
-	pp_newline (ppi);
+	pp_c_semicolon (ppi);
+	pp_needs_newline (ppi) = true;
       }
       break;
 
     case SCOPE_STMT:
       if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
-	{
-	  if (SCOPE_BEGIN_P (stmt))
-	    {
-	      pp_left_brace (ppi);
-	      pp_newline_and_indent (ppi, 3);
-	    }
-	  else if (SCOPE_END_P (stmt))
-	    {
-	      pp_right_brace (ppi);
-	      pp_newline_and_indent (ppi, -3);
-	    }
-	}
+        {
+          int i = 0;
+          if (pp_needs_newline (ppi))
+            pp_newline_and_indent (ppi, 0);
+          if (SCOPE_BEGIN_P (stmt))
+            {
+              pp_left_brace (ppi);
+              i = 3;
+            }
+          else if (SCOPE_END_P (stmt))
+            {
+              pp_right_brace (ppi);
+              i = -3;
+            }
+          pp_indentation (ppi) += i;
+          pp_needs_newline (ppi) = true;
+        }
       break;
 
     case DECL_STMT:
+      if (pp_needs_newline (ppi))
+        pp_newline_and_indent (ppi, 0);
       pp_declaration (ppi, DECL_STMT_DECL (stmt));
-      pp_semicolon (ppi);
-      pp_newline (ppi);
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     case ASM_STMT:
@@ -1383,7 +1882,7 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
 	    if (ASM_CLOBBERS (stmt))
 	      pp_c_expression (ppi, ASM_CLOBBERS (stmt));
 	  }
-	pp_right_paren (ppi);
+	pp_c_right_paren (ppi);
 	pp_newline (ppi);
       }
       break;
@@ -1394,8 +1893,8 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
       pp_equal (ppi);
       pp_c_whitespace (ppi);
       pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
-      pp_semicolon (ppi);
-      pp_newline (ppi);
+      pp_c_semicolon (ppi);
+      pp_needs_newline (ppi) = true;
       break;
 
     default:
@@ -1413,14 +1912,18 @@ pp_c_pretty_printer_init (c_pretty_printer pp)
 
   pp->declaration               = pp_c_declaration;
   pp->declaration_specifiers    = pp_c_declaration_specifiers;
-  pp->type_specifier            = pp_c_simple_type_specifier;
   pp->declarator                = pp_c_declarator;
   pp->direct_declarator         = pp_c_direct_declarator;
+  pp->type_specifier            = pp_c_simple_type_specifier;
+  pp->abstract_declarator       = pp_c_abstract_declarator;
   pp->parameter_declaration     = pp_c_parameter_declaration;
   pp->type_id                   = pp_c_type_id;
+  pp->function_specifier        = pp_c_function_specifier;
+  pp->storage_class_specifier   = pp_c_storage_class_specifier;
 
   pp->statement                 = pp_c_statement;
 
+  pp->id_expression             = pp_c_id_expression;
   pp->primary_expression        = pp_c_primary_expression;
   pp->postfix_expression        = pp_c_postfix_expression;
   pp->unary_expression          = pp_c_unary_expression;