pretty-print.h (pp_maybe_newline_and_indent): New macro.

	* pretty-print.h (pp_maybe_newline_and_indent): New macro.
	* c-pretty-print.h (c_pretty_printer): Now typedef to the
	structure.  Be consistent with pretty-print.h abd cxx-pretty-print.h
	(struct c_pretty_print_info): Document.  Add new fields.
	(pp_type_specifier_seq): Rename from pp_c_type_specifier.
	(pp_direct_abstract_declarator): New macro.
	(pp_ptr_operator): Likewise.
	(pp_simple_type_specifier): Likewise.
	(pp_expression): Likewise.
	(pp_parameter_list): Rename from pp_parameter_declaration.
	* c-pretty-print.c (pp_c_whitespace): Now a function.
	(pp_c_left_paren): Likewise.
	(pp_c_right_paren): Likewise.
	(pp_c_dot): Likewise.
	(pp_c_ampersand): Likewise.
	(pp_c_arrow): Likewise.
	(pp_c_semicolon): Likewise.
	(pp_c_type_cast): New function.
	(pp_c_space_for_pointer_operator): Likewise.
	(pp_c_call_argument_list): Likewise.
	(pp_c_cv_qualifier): Adjust prototype.
	(pp_c_type_qualifier_list): Likewise.
	(pp_c_pointer): Likewise.  Handle REFERENCE_TYPE here.
	(pp_c_type_specifier): Rename from pp_c_simple_type_specifier.
	Adjust to follow standard grammar.
	(pp_c_specifier_qualifier_list): Adjusr prototype.  Handle
	REFERENCE_TYPE.  Tidy.
	(pp_c_parameter_type_list): Adjust prototype.  Tidy.
	(pp_c_parameter_declaration): Remove.
	(pp_c_abstract_declarator): Adjust prototype.
	(pp_c_direct_abstract_declarator): Likewise.
	(pp_c_type_id): 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_declarator): Likewise.
	(pp_c_declaration): Likewise.
	(pp_c_attributes): Likewise.  Tidy.
	(pp_c_function_definition): Adjust prototype.
	(pp_c_char): Likewise.
	(pp_c_string_literal): Likewise.
	(pp_c_integer_constant): Likewise.
	(pp_c_character_constant): Likewise.
	(pp_c_bool_constant): Likewise.
	(pp_c_enumeration_constant): Likewise.
	(pp_c_floating_constant): Likewise.
	(pp_c_constant): Likewise.
	(pp_c_identifier): Likewise.
	(pp_c_primary_expression): Likewise.  Remove TARGET_EXPR case.  Tidy.
	(pp_c_initializer): Adjust prototype.
	(pp_c_init_declarator): Likewise.
	(pp_c_initializer_list): Likewise.
	(pp_c_id_expression): Likewise.
	(pp_c_postfix_expression): Likewise.
	(pp_c_expression_list): Likewise.
	(pp_c_unary_expression): Likewise.
	(pp_c_cast_expression): Likewise.
	(pp_c_multiplicative_expression): Likewise.
	(pp_c_additive_expression): Likewise.
	(pp_c_shift_expression): Likewise.
	(pp_c_relational_expression): Likewise.
	(pp_c_equality_expression): Likewise.
	(pp_c_and_expression): Likewise.
	(pp_c_exclusive_or_expression): Likewise.
	(pp_c_inclusive_or_expression): Likewise.
	(pp_c_logical_and_expression): Likewise.
	(pp_c_logical_or_expression): Likewise.
	(pp_c_conditional_expression): Likewise.
	(pp_c_assignment_expression): Likewise.
	(pp_c_expression): Likewise.  Tidy.
	(pp_c_statement): Likewise.  Document.
	(pp_c_pretty_printer_init): Adjust prototype. Tidy.

	* c-lang.c (c_initialize_diagnostics): Update.
	* c-common.h (strip_pointer_operator): Declare.
	* c-common.c (strip_pointer_operator): Define.

cp/
	* cxx-pretty-print.h (pp_cxx_flag_default_argument): New flag.
	(cxx_pretty_printer): Adjust base type.
	(pp_cxx_function_specifier): Declare.
	* cxx-pretty-print.c (pp_cxx_whitespace): New macro.
	(pp_cxx_left_paren): Likewise.
	(pp_cxx_right_paren): Likewise.
	(pp_cxx_dot): Likewise.
	(pp_cxx_arrow): Likewise.
	(pp_cxx_semicolon): Likewise.
	(pp_cxx_identifier): Likewise.
	(pp_cxx_cv_qualifier_seq): Likewise.
	(pp_cxx_storage_class_specifier): Likewise.
	(pp_cxx_expression_list): Likewise.
	(pp_cxx_space_for_pointer_operator): Likewise.
	(pp_cxx_init_declarator): Likewise.
	(pp_cxx_call_argument_list): Likewise.
	(pp_cxx_nonconsecutive_character): Tidy.
	(pp_cxx_conversion_function_id): New function.
	(pp_cxx_template_id): Likewise.
	(pp_cxx_class_name): Likewise.
	(pp_cxx_template_keyword_if_needed): Likewise.
	(pp_cxx_nested_name_specifier): Likewise.
	(pp_cxx_unqualified_id): Tidy
	(pp_cxx_qualified_id): Handle more nodes.
	(pp_cxx_primary_expression): Tidy.
	(pp_cxx_postfix_expression): Likewise.
	(pp_cxx_new_expression): Tidy.
	(pp_cxx_delete_expression): Likewise.
	(pp_cxx_cast_expression): New function.
	(pp_cxx_pm_expression): Tidy.
	(pp_cxx_conditional_expression): Likewise.
	(pp_cxx_assignment_operator): New function.
	(pp_cxx_assignment_expression): Tidy.
	(pp_cxx_expression): New function.
	(pp_cxx_function_specifier): Likewise.
	(pp_cxx_decl_specifier_seq): Likewise.
	(pp_cxx_simple_type_specifier): Tidy.
	(pp_cxx_type_specifier_seq): Likewise.
	(pp_cxx_ptr_operator): New function.
	(pp_cxx_implicit_parameter_type): Likewise.
	(pp_cxx_parameter_declaration): Tidy.
	(pp_cxx_parameter_declaration_clause): New function.
	(pp_cxx_exception_specification): Likewise.
	(pp_cxx_direct_declarator): Tidy.
	(pp_cxx_declarator): Likewise.
	(pp_cxx_ctor_initializer): New function.
	(pp_cxx_function_definition): Likewise.
	(pp_cxx_abstract_declarator): Tidy.
	(pp_cxx_direct_abstract_declarator): Likewise.
	(pp_cxx_type_id): Likewise.
	(pp_cxx_exception_declaration): New function.
	(pp_cxx_statement): Likewise.
	(pp_cxx_simple_declaration): Likewise.
	(pp_cxx_template_parameter_list): Likewise.
	(pp_cxx_template_parameter): Likewise.
	(pp_cxx_template_declaration): Likewise.
	(pp_cxx_explicit_specialization): Likewise.
	(pp_cxx_explicit_instantiation): Likewise.
	(pp_cxx_declaration): Tidy.
	(pp_cxx_pretty_printer_init): Initialize more fields.

From-SVN: r70777

1 files changed, 746 insertions, 624 deletions

diff --git a/gcc/c-pretty-print.c b/gcc/c-pretty-print.c
index 6e12d6134d8..922d987ab28 100644
--- a/gcc/c-pretty-print.c
+++ b/gcc/c-pretty-print.c
@@ -35,29 +35,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    takes expression 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);               \
@@ -82,64 +65,86 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
     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_primary_expression (c_pretty_printer, tree);
+static void pp_c_char (c_pretty_printer *, int);
 
 /* postfix-expression  */
-static void pp_c_initializer_list (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);
-static void pp_c_relational_expression (c_pretty_printer, tree);
-static void pp_c_equality_expression (c_pretty_printer, tree);
-static void pp_c_and_expression (c_pretty_printer, tree);
-static void pp_c_exclusive_or_expression (c_pretty_printer, tree);
-static void pp_c_inclusive_or_expression (c_pretty_printer, tree);
-static void pp_c_logical_and_expression (c_pretty_printer, tree);
-static void pp_c_conditional_expression (c_pretty_printer, tree);
-static void pp_c_assignment_expression (c_pretty_printer, tree);
+static void pp_c_initializer_list (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);
+static void pp_c_relational_expression (c_pretty_printer *, tree);
+static void pp_c_equality_expression (c_pretty_printer *, tree);
+static void pp_c_and_expression (c_pretty_printer *, tree);
+static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
+static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
+static void pp_c_logical_and_expression (c_pretty_printer *, tree);
+static void pp_c_conditional_expression (c_pretty_printer *, tree);
+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_simple_type_specifier (c_pretty_printer, tree);
-static void pp_c_parameter_declaration (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);
-
 
 
-/* Declarations.  */
+/* Helper functions. */
+
+void
+pp_c_whitespace (c_pretty_printer *pp)
+{
+  pp_space (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_left_paren (c_pretty_printer *pp)
+{
+  pp_left_paren (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_right_paren (c_pretty_printer *pp)
+{
+  pp_right_paren (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_dot (c_pretty_printer *pp)
+{
+  pp_dot (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_ampersand (c_pretty_printer *pp)
+{
+  pp_ampersand (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_arrow (c_pretty_printer *pp)
+{
+  pp_arrow (pp);
+  pp_base (pp)->padding = pp_none;
+}
+
+void
+pp_c_semicolon(c_pretty_printer *pp)
+{
+  pp_semicolon (pp);
+  pp_base (pp)->padding = pp_none;
+}
 
 static void
-pp_c_cv_qualifier (c_pretty_printer pp, const char *cv)
+pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
 {
   const char *p = pp_last_position_in_text (pp);
   if (p != NULL && *p == '*')
@@ -147,16 +152,45 @@ pp_c_cv_qualifier (c_pretty_printer pp, const char *cv)
   pp_c_identifier (pp, cv);
 }
 
+/* Pretty-print T using the type-cast notation '( type-name )'.  */
+static inline void
+pp_c_type_cast (c_pretty_printer *pp, tree t)
+{
+  pp_c_left_paren (pp);
+  pp_type_id (pp, t);
+  pp_c_right_paren (pp);
+}
+
+void
+pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
+{
+  if (POINTER_TYPE_P (t))
+    {
+      tree pointee = strip_pointer_operator (TREE_TYPE (t));
+      if (TREE_CODE (pointee) != ARRAY_TYPE
+          && TREE_CODE (pointee) != FUNCTION_TYPE)
+        pp_c_whitespace (pp);
+    }
+}
+
+
+/* Declarations.  */
+
 /* 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:
+
+   type-qualifier-list:
+       type-qualifier
+       type-qualifier-list type-qualifier
+
+   type-qualifier:
        const
-       volatile
-       restrict
-       __restrict__   */
+       restrict                              -- C99
+       __restrict__                          -- GNU C
+       volatile    */
 void
-pp_c_type_qualifier_list (c_pretty_printer pp, tree t)
+pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
 {
    int qualifiers;
    
@@ -176,16 +210,21 @@ pp_c_type_qualifier_list (c_pretty_printer pp, tree t)
       * type-qualifier-list(opt)
       * type-qualifier-list(opt) pointer  */
 static void
-pp_c_pointer (c_pretty_printer pp, tree t)
+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:
+      /* It is easier to handle C++ reference types here. */
+    case REFERENCE_TYPE:
       if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
         pp_c_pointer (pp, TREE_TYPE (t));
-      pp_c_star (pp);
+      if (TREE_CODE (t) == POINTER_TYPE)
+        pp_c_star (pp);
+      else
+        pp_c_ampersand (pp);
       pp_c_type_qualifier_list (pp, t);
       break;
 
@@ -194,49 +233,39 @@ pp_c_pointer (c_pretty_printer pp, tree t)
     }
 }
 
-/*
-  simple-type-specifier:
-     void
-     char
-     short
-     int
-     long
-     float
-     double
-     signed
-     unsigned
-     _Bool                          -- C99
-     _Complex                       -- C99
-     _Imaginary                     -- C99
-     typedef-name.
+/* type-specifier:
+      void
+      char
+      short
+      int
+      long
+      float
+      double
+      signed
+      unsigned
+      _Bool                          -- C99
+      _Complex                       -- C99
+      _Imaginary                     -- C99
+      struct-or-union-specifier
+      enum-specifier
+      typedef-name.
 
   GNU extensions.
   simple-type-specifier:
       __complex__
       __vector__   */
-static void
-pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
+void
+pp_c_type_specifier (c_pretty_printer *pp, tree t)
 {
-  enum tree_code code;
-
-  if (DECL_P (t) && TREE_CODE (t) != TYPE_DECL)
-    t = TREE_TYPE (t);
-
-  code = TREE_CODE (t);
+  const enum tree_code code = TREE_CODE (t);
   switch (code)
     {
     case ERROR_MARK:
-      pp_c_identifier (ppi, "<type-error>");
-      break;
-
-#if 0
-    case UNKNOWN_TYPE:
-      pp_c_identifier (ppi, "<unkown-type>");
+      pp_c_identifier (pp, "<type-error>");
       break;
-#endif
 
     case IDENTIFIER_NODE:
-      pp_c_tree_identifier (ppi, t);
+      pp_c_tree_identifier (pp, t);
       break;
 
     case VOID_TYPE:
@@ -244,58 +273,43 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
     case CHAR_TYPE:
     case INTEGER_TYPE:
     case REAL_TYPE:
-      pp_c_simple_type_specifier (ppi, TYPE_NAME (t));
-      break;
-
-    case COMPLEX_TYPE:
-    case VECTOR_TYPE:
-      pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
-      if (code == COMPLEX_TYPE)
-	pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__");
-      else if (code == VECTOR_TYPE)
-	pp_c_identifier (ppi, "__vector__");
+      pp_c_type_specifier (pp, TYPE_NAME (t));
       break;
 
     case TYPE_DECL:
       if (DECL_NAME (t))
-	pp_id_expression (ppi, t);
+	pp_id_expression (pp, t);
       else
-	pp_c_identifier (ppi, "<typedef-error>");
+	pp_c_identifier (pp, "<typedef-error>");
       break;
 
     case UNION_TYPE:
     case RECORD_TYPE:
     case ENUMERAL_TYPE:
       if (code == UNION_TYPE)
-	pp_c_identifier (ppi, "union");
+	pp_c_identifier (pp, "union");
       else if (code == RECORD_TYPE)
-	pp_c_identifier (ppi, "struct");
+	pp_c_identifier (pp, "struct");
       else if (code == ENUMERAL_TYPE)
-	pp_c_identifier (ppi, "enum");
+	pp_c_identifier (pp, "enum");
       else
-	pp_c_identifier (ppi, "<tag-error>");
+	pp_c_identifier (pp, "<tag-error>");
 
       if (TYPE_NAME (t))
-	pp_id_expression (ppi, TYPE_NAME (t));
+	pp_id_expression (pp, 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));
+	pp_c_identifier (pp, "<anonymous>");
       break;
 
     default:
-      pp_unsupported_tree (ppi, t);
+      pp_unsupported_tree (pp, t);
       break;
     }
 }
 
 /* specifier-qualifier-list:
       type-specifier specifier-qualifier-list-opt
-      cv-qualifier specifier-qualifier-list-opt
+      type-qualifier specifier-qualifier-list-opt
 
 
   Implementation note:  Because of the non-linearities in array or
@@ -304,18 +318,19 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
   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_specifier_qualifier_list (c_pretty_printer *pp, tree t)
 {
+  const enum tree_code code = TREE_CODE (t);
+
   if (TREE_CODE (t) != POINTER_TYPE)
     pp_c_type_qualifier_list (pp, t);
-  switch (TREE_CODE (t))
+  switch (code)
     {
+    case REFERENCE_TYPE:
     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);
+        tree pointee = strip_pointer_operator (TREE_TYPE (t));
         pp_c_specifier_qualifier_list (pp, pointee);
         if (TREE_CODE (pointee) == ARRAY_TYPE
             || TREE_CODE (pointee) == FUNCTION_TYPE)
@@ -323,10 +338,7 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
             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);
+        pp_ptr_operator (pp, t);
       }
       break;
 
@@ -338,12 +350,14 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
     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);
+      if (code == COMPLEX_TYPE)
+	pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__");
+      else if (code == VECTOR_TYPE)
+	pp_c_identifier (pp, "__vector__");
       break;
 
     default:
-      pp_c_simple_type_specifier (pp, t);
+      pp_simple_type_specifier (pp, t);
       break;
     }
 }
@@ -359,26 +373,28 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
    parameter-declaration:
       declaration-specifiers declarator
       declaration-specifiers abstract-declarator(opt)   */
-static void
-pp_c_parameter_type_list (c_pretty_printer pp, tree t)
+void
+pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
 {
+  bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
+  tree parms = want_parm_decl ? DECL_ARGUMENTS (t) :  TYPE_ARG_TYPES (t);
   pp_c_left_paren (pp);
-  if (t == void_list_node)
+  if (parms == 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))
+      for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
         {
           if (!first)
             pp_separate_with (pp, ',');
           first = false;
-          pp_declaration_specifiers (pp, want_parm_decl ? t : TREE_VALUE (t));
+          pp_declaration_specifiers
+            (pp, want_parm_decl ? parms : TREE_VALUE (parms));
           if (want_parm_decl)
-            pp_declarator (pp, t);
+            pp_declarator (pp, parms);
           else
-            pp_abstract_declarator (pp, TREE_VALUE (t));
+            pp_abstract_declarator (pp, TREE_VALUE (parms));
         }
     }
   pp_c_right_paren (pp);
@@ -388,7 +404,7 @@ pp_c_parameter_type_list (c_pretty_printer pp, tree t)
       pointer
       pointer(opt) direct-abstract-declarator  */
 static inline void
-pp_c_abstract_declarator (c_pretty_printer pp, tree t)
+pp_c_abstract_declarator (c_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == POINTER_TYPE)
     {
@@ -398,7 +414,7 @@ pp_c_abstract_declarator (c_pretty_printer pp, tree t)
       t = TREE_TYPE (t);
     }
 
-  pp_c_direct_abstract_declarator (pp, t);
+  pp_direct_abstract_declarator (pp, t);
 }
 
 /* direct-abstract-declarator:
@@ -406,26 +422,26 @@ pp_c_abstract_declarator (c_pretty_printer pp, tree t)
       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)
+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);
+      pp_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));
+      pp_c_parameter_type_list (pp, t);
+      pp_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_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
       pp_c_right_bracket (pp);
-      pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
+      pp_direct_abstract_declarator (pp, TREE_TYPE (t));
       break;
 
     case IDENTIFIER_NODE:
@@ -447,15 +463,23 @@ pp_c_direct_abstract_declarator (c_pretty_printer pp, tree t)
     }
 }
 
+/* type-name:
+      specifier-qualifier-list  abstract-declarator(opt)  */
 void
-pp_c_type_id (c_pretty_printer ppi, tree t)
+pp_c_type_id (c_pretty_printer *pp, tree t)
 {
-  pp_c_specifier_qualifier_list (ppi, t);
-  pp_abstract_declarator (ppi, t);
+  pp_c_specifier_qualifier_list (pp, t);
+  pp_abstract_declarator (pp, t);
 }
 
-static inline void
-pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
+/* storage-class-specifier:
+      typedef
+      extern
+      static
+      auto
+      register  */
+void
+pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == TYPE_DECL)
     pp_c_identifier (pp, "typedef");
@@ -468,8 +492,10 @@ pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
     }
 }
 
-static inline void
-pp_c_function_specifier (c_pretty_printer pp, tree t)
+/* function-specifier:
+      inline   */
+void
+pp_c_function_specifier (c_pretty_printer *pp, tree t)
 {
   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
     pp_c_identifier (pp, "inline");
@@ -480,8 +506,8 @@ pp_c_function_specifier (c_pretty_printer pp, tree t)
       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)
+void
+pp_c_declaration_specifiers (c_pretty_printer *pp, tree t)
 {
   pp_storage_class_specifier (pp, t);
   pp_function_specifier (pp, t);
@@ -498,7 +524,7 @@ pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
       direct-declaratpr ( parameter-type-list )
       direct-declarator ( identifier-list(opt) )  */
 void
-pp_c_direct_declarator (c_pretty_printer pp, tree t)
+pp_c_direct_declarator (c_pretty_printer *pp, tree t)
 {
   switch (TREE_CODE (t))
     {
@@ -507,25 +533,30 @@ pp_c_direct_declarator (c_pretty_printer pp, tree t)
     case TYPE_DECL:
     case FIELD_DECL:
     case LABEL_DECL:
-      pp_c_tree_identifier (pp, DECL_NAME (t));
+      if (DECL_NAME (t))
+        {
+          pp_c_space_for_pointer_operator (pp, TREE_TYPE (t));
+          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));
+      pp_parameter_list (pp, t);
+      pp_abstract_declarator (pp, TREE_TYPE (t));
       break;
 
     case FUNCTION_DECL:
+      pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
       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));
+        pp_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)));
+          pp_parameter_list (pp, t);
+          pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
         }
       break;
 
@@ -546,7 +577,7 @@ pp_c_direct_declarator (c_pretty_printer pp, tree t)
 /* declarator:
       pointer(opt)  direct-declarator   */
 void
-pp_c_declarator (c_pretty_printer pp, tree t)
+pp_c_declarator (c_pretty_printer *pp, tree t)
 {
   switch (TREE_CODE (t))
     {
@@ -574,41 +605,18 @@ pp_c_declarator (c_pretty_printer pp, tree t)
     }
 }
 
-/* init-declarator:
-      declarator:
-      declarator = initializer   */
-static inline void
-pp_c_init_declarator (c_pretty_printer pp, tree t)
-{
-  pp_declarator (pp, t);
-  if (DECL_INITIAL (t))
-    {
-      pp_space (pp);
-      pp_equal (pp);
-      pp_space (pp);
-      pp_c_initializer (pp, DECL_INITIAL (t));
-    }
-}
-
 /* declaration:
       declaration-specifiers init-declarator-list(opt) ;  */
-
 void
-pp_c_declaration (c_pretty_printer pp, tree t)
+pp_c_declaration (c_pretty_printer *pp, tree t)
 {
   pp_declaration_specifiers (pp, t);
   pp_c_init_declarator (pp, t);
 }
 
-static void
-pp_c_parameter_declaration (c_pretty_printer pp, tree t)
-{
-  pp_unsupported_tree (pp, t);
-}
-
 /* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
 void
-pp_c_attributes (c_pretty_printer pp, tree attributes)
+pp_c_attributes (c_pretty_printer *pp, tree attributes)
 {
   if (attributes == NULL_TREE)
     return;
@@ -620,11 +628,7 @@ pp_c_attributes (c_pretty_printer pp, tree attributes)
     {
       pp_tree_identifier (pp, TREE_PURPOSE (attributes));
       if (TREE_VALUE (attributes))
-	{
-	  pp_c_left_paren (pp);
-	  pp_c_expression_list (pp, TREE_VALUE (attributes));
-	  pp_c_right_paren (pp);
-	}
+        pp_c_call_argument_list (pp, TREE_VALUE (attributes));
 
       if (TREE_CHAIN (attributes))
 	pp_separate_with (pp, ',');
@@ -636,7 +640,7 @@ pp_c_attributes (c_pretty_printer pp, tree attributes)
 /* function-definition:
       declaration-specifiers declarator compound-statement  */
 void
-pp_c_function_definition (c_pretty_printer pp, tree t)
+pp_c_function_definition (c_pretty_printer *pp, tree t)
 {
   pp_declaration_specifiers (pp, t);
   pp_declarator (pp, t);
@@ -651,64 +655,64 @@ pp_c_function_definition (c_pretty_printer pp, tree t)
 
 /* Print out a c-char.  */
 static void
-pp_c_char (c_pretty_printer ppi, int c)
+pp_c_char (c_pretty_printer *pp, int c)
 {
   switch (c)
     {
     case TARGET_NEWLINE:
-      pp_string (ppi, "\\n");
+      pp_string (pp, "\\n");
       break;
     case TARGET_TAB:
-      pp_string (ppi, "\\t");
+      pp_string (pp, "\\t");
       break;
     case TARGET_VT:
-      pp_string (ppi, "\\v");
+      pp_string (pp, "\\v");
       break;
     case TARGET_BS:
-      pp_string (ppi, "\\b");
+      pp_string (pp, "\\b");
       break;
     case TARGET_CR:
-      pp_string (ppi, "\\r");
+      pp_string (pp, "\\r");
       break;
     case TARGET_FF:
-      pp_string (ppi, "\\f");
+      pp_string (pp, "\\f");
       break;
     case TARGET_BELL:
-      pp_string (ppi, "\\a");
+      pp_string (pp, "\\a");
       break;
     case '\\':
-      pp_string (ppi, "\\\\");
+      pp_string (pp, "\\\\");
       break;
     case '\'':
-      pp_string (ppi, "\\'");
+      pp_string (pp, "\\'");
       break;
     case '\"':
-      pp_string (ppi, "\\\"");
+      pp_string (pp, "\\\"");
       break;
     default:
       if (ISPRINT (c))
-	pp_character (ppi, c);
+	pp_character (pp, c);
       else
-	pp_scalar (ppi, "\\%03o", (unsigned) c);
+	pp_scalar (pp, "\\%03o", (unsigned) c);
       break;
     }
 }
 
 /* Print out a STRING literal.  */
 void
-pp_c_string_literal (c_pretty_printer ppi, tree s)
+pp_c_string_literal (c_pretty_printer *pp, tree s)
 {
   const char *p = TREE_STRING_POINTER (s);
   int n = TREE_STRING_LENGTH (s) - 1;
   int i;
-  pp_doublequote (ppi);
+  pp_doublequote (pp);
   for (i = 0; i < n; ++i)
-    pp_c_char (ppi, p[i]);
-  pp_doublequote (ppi);
+    pp_c_char (pp, p[i]);
+  pp_doublequote (pp);
 }
 
 static void
-pp_c_integer_constant (c_pretty_printer pp, tree i)
+pp_c_integer_constant (c_pretty_printer *pp, tree i)
 {
   if (host_integerp (i, 0))
     pp_wide_integer (pp, TREE_INT_CST_LOW (i));
@@ -729,7 +733,7 @@ pp_c_integer_constant (c_pretty_printer pp, tree i)
 
 /* Print out a CHARACTER literal.  */
 static inline void
-pp_c_character_constant (c_pretty_printer pp, tree c)
+pp_c_character_constant (c_pretty_printer *pp, tree c)
 {
   tree type = TREE_TYPE (c);
   if (type == wchar_type_node)
@@ -744,7 +748,7 @@ pp_c_character_constant (c_pretty_printer pp, tree c)
 
 /* Print out a BOOLEAN literal.  */
 static void
-pp_c_bool_constant (c_pretty_printer pp, tree b)
+pp_c_bool_constant (c_pretty_printer *pp, tree b)
 {
   if (b == boolean_false_node)
     {
@@ -775,7 +779,7 @@ pp_c_bool_constant (c_pretty_printer pp, 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_enumeration_constant (c_pretty_printer ppi, tree e)
+pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
 {
   bool value_is_named = true;
   tree type = TREE_TYPE (e);
@@ -788,13 +792,11 @@ pp_c_enumeration_constant (c_pretty_printer ppi, tree e)
     ;
 
   if (value != NULL_TREE)
-    pp_id_expression (ppi, TREE_PURPOSE (value));
+    pp_id_expression (pp, TREE_PURPOSE (value));
   else
     {
       /* Value must have been cast.  */
-      pp_c_left_paren (ppi);
-      pp_type_id (ppi, type);
-      pp_c_right_paren (ppi);
+      pp_c_type_cast (pp, type);
       value_is_named = false;
     }
 
@@ -803,7 +805,7 @@ pp_c_enumeration_constant (c_pretty_printer ppi, tree e)
 
 /* Print out a REAL value.  */
 static inline void
-pp_c_floating_constant (c_pretty_printer pp, tree r)
+pp_c_floating_constant (c_pretty_printer *pp, tree r)
 {
   real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
 		   sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
@@ -816,7 +818,7 @@ pp_c_floating_constant (c_pretty_printer pp, tree r)
       enumeration-constant
       chatracter-constant   */
 void
-pp_c_constant (c_pretty_printer pp, tree e)
+pp_c_constant (c_pretty_printer *pp, tree e)
 {
   switch (TREE_CODE (e))
     {
@@ -850,7 +852,7 @@ pp_c_constant (c_pretty_printer pp, tree e)
 }
 
 void
-pp_c_identifier (c_pretty_printer pp, const char *id)
+pp_c_identifier (c_pretty_printer *pp, const char *id)
 {
   pp_c_maybe_whitespace (pp);            
   pp_identifier (pp, id);  
@@ -863,8 +865,8 @@ pp_c_identifier (c_pretty_printer pp, const char *id)
       constant
       string-literal
       ( expression )   */
-static void
-pp_c_primary_expression (c_pretty_printer ppi, tree e)
+void
+pp_c_primary_expression (c_pretty_printer *pp, tree e)
 {
   switch (TREE_CODE (e))
     {
@@ -877,50 +879,34 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
       e = DECL_NAME (e);
       /* Fall through.  */
     case IDENTIFIER_NODE:
-      pp_c_tree_identifier (ppi, e);
+      pp_c_tree_identifier (pp, e);
       break;
 
     case ERROR_MARK:
-      pp_c_identifier (ppi, "<erroneous-expression>");
+      pp_c_identifier (pp, "<erroneous-expression>");
       break;
 
     case RESULT_DECL:
-      pp_c_identifier (ppi, "<return-value>");
+      pp_c_identifier (pp, "<return-value>");
       break;
 
     case INTEGER_CST:
     case REAL_CST:
     case STRING_CST:
-      pp_c_constant (ppi, e);
+      pp_c_constant (pp, e);
       break;
 
-    case TARGET_EXPR:
-      pp_c_left_paren (ppi);
-      pp_c_identifier (ppi, "__builtin_memcpy");
-      pp_c_left_paren (ppi);
-      pp_ampersand (ppi);
-      pp_primary_expression (ppi, TREE_OPERAND (e, 0));
-      pp_separate_with (ppi, ',');
-      pp_ampersand (ppi);
-      pp_initializer (ppi, TREE_OPERAND (e, 1));
-      if (TREE_OPERAND (e, 2))
-	{
-	  pp_separate_with (ppi, ',');
-	  pp_c_expression (ppi, TREE_OPERAND (e, 2));
-	}
-      pp_c_right_paren (ppi);
-
     case STMT_EXPR:
-      pp_c_left_paren (ppi);
-      pp_statement (ppi, STMT_EXPR_STMT (e));
-      pp_c_right_paren (ppi);
+      pp_c_left_paren (pp);
+      pp_statement (pp, STMT_EXPR_STMT (e));
+      pp_c_right_paren (pp);
       break;
 
     default:
       /* 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);
+      pp_c_left_paren (pp);
+      pp_expression (pp, e);
+      pp_c_right_paren (pp);
       break;
     }
 }
@@ -931,23 +917,53 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e)
       { initializer-list }
       { initializer-list , }   */
 
-void
-pp_c_initializer (c_pretty_printer ppi, tree e)
+static void
+pp_c_initializer (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == CONSTRUCTOR)
     {
       enum tree_code code = TREE_CODE (TREE_TYPE (e));
       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 	{
-	  pp_c_left_brace (ppi);
-	  pp_c_initializer_list (ppi, e);
-	  pp_c_right_brace (ppi);
+	  pp_c_left_brace (pp);
+	  pp_c_initializer_list (pp, e);
+	  pp_c_right_brace (pp);
 	}
       else
-	pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
+	pp_unsupported_tree (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_assignment_expression (ppi, e);
+    pp_expression (pp, e);
+}
+
+/* init-declarator:
+      declarator:
+      declarator = initializer   */
+void
+pp_c_init_declarator (c_pretty_printer *pp, tree t)
+{
+  pp_declarator (pp, t);
+  if (DECL_INITIAL (t))
+    {
+      tree init = DECL_INITIAL (t);
+      /* This C++ bit is handled here because it is easier to do so.
+         In templates, the C++ parser builds a TREE_LIST for a
+         direct-initialization; the TREE_PURPOSE is the variable to
+         initialize and the TREE_VALUE is the initializer.  */
+      if (TREE_CODE (init) == TREE_LIST)
+        {
+          pp_c_left_paren (pp);
+          pp_expression (pp, TREE_VALUE (init));
+          pp_right_paren (pp);
+        }
+      else
+        {
+          pp_space (pp);
+          pp_equal (pp);
+          pp_space (pp);
+          pp_c_initializer (pp, init);
+        }
+    }
 }
 
 /* initializer-list:
@@ -965,7 +981,7 @@ pp_c_initializer (c_pretty_printer ppi, tree e)
       [ constant-expression ]
       identifier   */
 static void
-pp_c_initializer_list (c_pretty_printer ppi, tree e)
+pp_c_initializer_list (c_pretty_printer *pp, tree e)
 {
   tree type = TREE_TYPE (e);
   const enum tree_code code = TREE_CODE (type);
@@ -977,26 +993,26 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e)
 	{
 	  if (code == RECORD_TYPE || code == UNION_TYPE)
 	    {
-	      pp_c_dot (ppi);
-	      pp_c_primary_expression (ppi, TREE_PURPOSE (init));
+	      pp_c_dot (pp);
+	      pp_c_primary_expression (pp, TREE_PURPOSE (init));
 	    }
 	  else
 	    {
-	      pp_c_left_bracket (ppi);
+	      pp_c_left_bracket (pp);
 	      if (TREE_PURPOSE (init))
-		pp_c_constant (ppi, TREE_PURPOSE (init));
-	      pp_c_right_bracket (ppi);
+		pp_c_constant (pp, TREE_PURPOSE (init));
+	      pp_c_right_bracket (pp);
 	    }
-	  pp_c_whitespace (ppi);
-	  pp_equal (ppi);
-	  pp_c_whitespace (ppi);
-	  pp_initializer (ppi, TREE_VALUE (init));
+	  pp_c_whitespace (pp);
+	  pp_equal (pp);
+	  pp_c_whitespace (pp);
+	  pp_initializer (pp, TREE_VALUE (init));
 	  if (TREE_CHAIN (init))
-	    pp_separate_with (ppi, ',');
+	    pp_separate_with (pp, ',');
 	}
     }
   else
-    pp_unsupported_tree (ppi, type);
+    pp_unsupported_tree (pp, type);
 }
 
 /*  This is a convenient function, used to bridge gap between C and C++
@@ -1005,7 +1021,7 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e)
     id-expression:
        identifier  */
 void
-pp_c_id_expression (c_pretty_printer pp, tree t)
+pp_c_id_expression (c_pretty_printer *pp, tree t)
 {
   switch (TREE_CODE (t))
     {
@@ -1038,43 +1054,41 @@ pp_c_id_expression (c_pretty_printer pp, tree t)
       ( type-name ) { initializer-list }
       ( type-name ) { initializer-list , }  */
 void
-pp_c_postfix_expression (c_pretty_printer ppi, tree e)
+pp_c_postfix_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
     {
     case POSTINCREMENT_EXPR:
     case POSTDECREMENT_EXPR:
-      pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
-      pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
+      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
+      pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
       break;
 
     case ARROW_EXPR:
-      pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_arrow (ppi);
+      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_arrow (pp);
       break;
 
     case ARRAY_REF:
-      pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_left_bracket (ppi);
-      pp_c_expression (ppi, TREE_OPERAND (e, 1));
-      pp_c_right_bracket (ppi);
+      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_left_bracket (pp);
+      pp_expression (pp, TREE_OPERAND (e, 1));
+      pp_c_right_bracket (pp);
       break;
 
     case CALL_EXPR:
-      pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_left_paren (ppi);
-      pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
-      pp_c_right_paren (ppi);
+      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_call_argument_list (pp, TREE_OPERAND (e, 1));
       break;
 
     case ABS_EXPR:
     case FFS_EXPR:
-      pp_c_identifier (ppi,
+      pp_c_identifier (pp,
 		       code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
-      pp_c_left_paren (ppi);
-      pp_c_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_right_paren (ppi);
+      pp_c_left_paren (pp);
+      pp_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_right_paren (pp);
       break;
 
     case COMPONENT_REF:
@@ -1082,86 +1096,94 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 	tree object = TREE_OPERAND (e, 0);
 	if (TREE_CODE (object) == INDIRECT_REF)
 	  {
-	    pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
-	    pp_c_arrow (ppi);
+	    pp_postfix_expression (pp, TREE_OPERAND (object, 0));
+	    pp_c_arrow (pp);
 	  }
 	else
 	  {
-	    pp_postfix_expression (ppi, object);
-	    pp_c_dot (ppi);
+	    pp_postfix_expression (pp, object);
+	    pp_c_dot (pp);
 	  }
-	pp_c_expression (ppi, TREE_OPERAND (e, 1));
+	pp_expression (pp, TREE_OPERAND (e, 1));
       }
       break;
 
     case COMPLEX_CST:
     case VECTOR_CST:
     case COMPLEX_EXPR:
-      pp_c_left_paren (ppi);
-      pp_type_id (ppi, TREE_TYPE (e));
-      pp_c_right_paren (ppi);
-      pp_c_left_brace (ppi);
+      pp_c_type_cast (pp, TREE_TYPE (e));
+      pp_c_left_brace (pp);
 
       if (code == COMPLEX_CST)
 	{
-	  pp_c_expression (ppi, TREE_REALPART (e));
-	  pp_separate_with (ppi, ',');
-	  pp_c_expression (ppi, TREE_IMAGPART (e));
+	  pp_expression (pp, TREE_REALPART (e));
+	  pp_separate_with (pp, ',');
+	  pp_expression (pp, TREE_IMAGPART (e));
 	}
       else if (code == VECTOR_CST)
-	pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
+	pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
       else if (code == COMPLEX_EXPR)
 	{
-	  pp_c_expression (ppi, TREE_OPERAND (e, 0));
-	  pp_separate_with (ppi, ',');
-	  pp_c_expression (ppi, TREE_OPERAND (e, 1));
+	  pp_expression (pp, TREE_OPERAND (e, 0));
+	  pp_separate_with (pp, ',');
+	  pp_expression (pp, TREE_OPERAND (e, 1));
 	}
 
-      pp_c_right_brace (ppi);
+      pp_c_right_brace (pp);
       break;
 
     case COMPOUND_LITERAL_EXPR:
       e = DECL_INITIAL (e);
       /* Fall through.  */
     case CONSTRUCTOR:
-      pp_initializer (ppi, e);
+      pp_initializer (pp, e);
       break;
 
     case VA_ARG_EXPR:
-      pp_c_identifier (ppi, "__builtin_va_arg");
-      pp_c_left_paren (ppi);
-      pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
-      pp_separate_with (ppi, ',');
-      pp_type_id (ppi, TREE_TYPE (e));
-      pp_c_right_paren (ppi);
+      pp_c_identifier (pp, "__builtin_va_arg");
+      pp_c_left_paren (pp);
+      pp_assignment_expression (pp, TREE_OPERAND (e, 0));
+      pp_separate_with (pp, ',');
+      pp_type_id (pp, TREE_TYPE (e));
+      pp_c_right_paren (pp);
       break;
 
     case ADDR_EXPR:
       if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
         {
-          pp_c_id_expression (ppi, TREE_OPERAND (e, 0));
+          pp_c_id_expression (pp, TREE_OPERAND (e, 0));
           break;
         }
       /* else fall through.  */
 
     default:
-      pp_primary_expression (ppi, e);
+      pp_primary_expression (pp, e);
       break;
     }
 }
 
 /* Print out an expression-list; E is expected to be a TREE_LIST  */
 void
-pp_c_expression_list (c_pretty_printer ppi, tree e)
+pp_c_expression_list (c_pretty_printer *pp, tree e)
 {
   for (; e != NULL_TREE; e = TREE_CHAIN (e))
     {
-      pp_c_assignment_expression (ppi, TREE_VALUE (e));
+      pp_expression (pp, TREE_VALUE (e));
       if (TREE_CHAIN (e))
-	pp_separate_with (ppi, ',');
+	pp_separate_with (pp, ',');
     }
 }
 
+/* Print out an expression-list in parens, as in a function call.   */
+void
+pp_c_call_argument_list (c_pretty_printer *pp, tree t)
+{
+  pp_c_left_paren (pp);
+  if (t && TREE_CODE (t) == TREE_LIST)
+    pp_c_expression_list (pp, t);
+  pp_c_right_paren (pp);
+}
+
 /* unary-expression:
       postfix-expression
       ++ cast-expression
@@ -1180,15 +1202,15 @@ pp_c_expression_list (c_pretty_printer ppi, tree e)
       __real__ unary-expression
       __imag__ unary-expression  */
 void
-pp_c_unary_expression (c_pretty_printer ppi, tree e)
+pp_c_unary_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
     {
     case PREINCREMENT_EXPR:
     case PREDECREMENT_EXPR:
-      pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
-      pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
+      pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
+      pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
       break;
 
     case ADDR_EXPR:
@@ -1199,66 +1221,68 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e)
     case CONJ_EXPR:
       /* String literal are used by address.  */
       if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
-	pp_ampersand (ppi);
+	pp_ampersand (pp);
       else if (code == INDIRECT_REF)
-	pp_c_star (ppi);
+	pp_c_star (pp);
       else if (code == NEGATE_EXPR)
-	pp_minus (ppi);
+	pp_minus (pp);
       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
-	pp_complement (ppi);
+	pp_complement (pp);
       else if (code == TRUTH_NOT_EXPR)
-	pp_exclamation (ppi);
-      pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
+	pp_exclamation (pp);
+      pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
       break;
 
     case SIZEOF_EXPR:
     case ALIGNOF_EXPR:
-      pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
-      pp_c_whitespace (ppi);
+      pp_c_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
+      pp_c_whitespace (pp);
       if (TYPE_P (TREE_OPERAND (e, 0)))
-	{
-	  pp_c_left_paren (ppi);
-	  pp_type_id (ppi, TREE_OPERAND (e, 0));
-	  pp_c_right_paren (ppi);
-	}
+        pp_c_type_cast (pp, TREE_OPERAND (e, 0));
       else
-	pp_unary_expression (ppi, TREE_OPERAND (e, 0));
+	pp_unary_expression (pp, TREE_OPERAND (e, 0));
       break;
 
     case REALPART_EXPR:
     case IMAGPART_EXPR:
-      pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
-      pp_c_whitespace (ppi);
-      pp_unary_expression (ppi, TREE_OPERAND (e, 0));
+      pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
+      pp_c_whitespace (pp);
+      pp_unary_expression (pp, TREE_OPERAND (e, 0));
       break;
 
     default:
-      pp_postfix_expression (ppi, e);
+      pp_postfix_expression (pp, e);
       break;
     }
 }
 
+/* cast-expression:
+      unary-expression
+      ( type-name ) cast-expression  */
 void
-pp_c_cast_expression (c_pretty_printer ppi, tree e)
+pp_c_cast_expression (c_pretty_printer *pp, tree e)
 {
   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));
+      pp_c_type_cast (pp, TREE_TYPE (e));
+      pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
       break;
 
     default:
-      pp_unary_expression (ppi, e);
+      pp_unary_expression (pp, e);
     }
 }
 
+/* multiplicative-expression:
+      cast-expression
+      multiplicative-expression * cast-expression
+      multiplicative-expression / cast-expression
+      multiplicative-expression % cast-expression   */
 static void
-pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
+pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
@@ -1266,70 +1290,84 @@ pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
     case MULT_EXPR:
     case TRUNC_DIV_EXPR:
     case TRUNC_MOD_EXPR:
-      pp_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
+      pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
       if (code == MULT_EXPR)
-	pp_c_star (ppi);
+	pp_c_star (pp);
       else if (code == TRUNC_DIV_EXPR)
-	pp_slash (ppi);
+	pp_slash (pp);
       else
-	pp_modulo (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
+	pp_modulo (pp);
+      pp_c_whitespace (pp);
+      pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
       break;
 
     default:
-      pp_c_cast_expression (ppi, e);
+      pp_c_cast_expression (pp, e);
       break;
     }
 }
 
+/* additive-expression:
+      multiplicative-expression
+      additive-expression + multiplicative-expression
+      additive-expression - multiplicative-expression   */
 static inline void
-pp_c_additive_expression (c_pretty_printer ppi, tree e)
+pp_c_additive_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
     {
     case PLUS_EXPR:
     case MINUS_EXPR:
-      pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
+      pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
       if (code == PLUS_EXPR)
-	pp_plus (ppi);
+	pp_plus (pp);
       else
-	pp_minus (ppi);
-      pp_c_whitespace (ppi);
-      pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1)); 
+	pp_minus (pp);
+      pp_c_whitespace (pp);
+      pp_multiplicative_expression (pp, TREE_OPERAND (e, 1)); 
       break;
 
     default:
-      pp_multiplicative_expression (ppi, e);
+      pp_multiplicative_expression (pp, e);
       break;
     }
 }
 
+/* additive-expression:
+      additive-expression
+      shift-expression << additive-expression
+      shift-expression >> additive-expression   */
 static inline void
-pp_c_shift_expression (c_pretty_printer ppi, tree e)
+pp_c_shift_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
     {
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
-      pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
-      pp_c_whitespace (ppi);
-      pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
+      pp_c_whitespace (pp);
+      pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
       break;
 
     default:
-      pp_c_additive_expression (ppi, e);
+      pp_c_additive_expression (pp, e);
     }
 }
 
+/* relational-expression:
+      shift-expression
+      relational-expression < shift-expression
+      relational-expression > shift-expression
+      relational-expression <= shift-expression
+      relational-expression >= shift-expression   */
 static void
-pp_c_relational_expression (c_pretty_printer ppi, tree e)
+pp_c_relational_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
@@ -1338,176 +1376,212 @@ pp_c_relational_expression (c_pretty_printer ppi, tree e)
     case GT_EXPR:
     case LE_EXPR:
     case GE_EXPR:
-      pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
+      pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
       if (code == LT_EXPR)
-	pp_less (ppi);
+	pp_less (pp);
       else if (code == GT_EXPR)
-	pp_greater (ppi);
+	pp_greater (pp);
       else if (code == LE_EXPR)
-	pp_identifier (ppi, "<=");
+	pp_identifier (pp, "<=");
       else if (code == GE_EXPR)
-	pp_identifier (ppi, ">=");
-      pp_c_whitespace (ppi);
-      pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
+	pp_identifier (pp, ">=");
+      pp_c_whitespace (pp);
+      pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
       break;
 
     default:
-      pp_c_shift_expression (ppi, e);
+      pp_c_shift_expression (pp, e);
       break;
     }
 }
 
+/* equality-expression:
+      relational-expression
+      equality-expression == relational-expression
+      equality-equality != relational-expression  */
 static inline void
-pp_c_equality_expression (c_pretty_printer ppi, tree e)
+pp_c_equality_expression (c_pretty_printer *pp, tree e)
 {
   enum tree_code code = TREE_CODE (e);
   switch (code)
     {
     case EQ_EXPR:
     case NE_EXPR:
-      pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
-      pp_c_whitespace (ppi);
-      pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
+      pp_c_whitespace (pp);
+      pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
       break;
 
     default:
-      pp_c_relational_expression (ppi, e);
+      pp_c_relational_expression (pp, e);
       break;
     }
 }
 
+/* AND-expression:
+      equality-expression
+      AND-expression & equality-equality   */
 static inline void
-pp_c_and_expression (c_pretty_printer ppi, tree e)
+pp_c_and_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == BIT_AND_EXPR)
     {
-      pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_ampersand (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_and_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_ampersand (pp);
+      pp_c_whitespace (pp);
+      pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_equality_expression (ppi, e);
+    pp_c_equality_expression (pp, e);
 }
 
+/* exclusive-OR-expression:
+     AND-expression
+     exclusive-OR-expression ^ AND-expression  */
 static inline void
-pp_c_exclusive_or_expression (c_pretty_printer ppi, tree e)
+pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == BIT_XOR_EXPR)
     {
-      pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
-      pp_carret (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_maybe_whitespace (pp);
+      pp_carret (pp);
+      pp_c_whitespace (pp);
+      pp_c_and_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_and_expression (ppi, e);
+    pp_c_and_expression (pp, e);
 }
 
+/* inclusive-OR-expression:
+     exclusive-OR-expression
+     inclusive-OR-expression | exclusive-OR-expression  */
 static inline void
-pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e)
+pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == BIT_IOR_EXPR)
     {
-      pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_bar (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_bar (pp);
+      pp_c_whitespace (pp);
+      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_exclusive_or_expression (ppi, e);
+    pp_c_exclusive_or_expression (pp, e);
 }
 
+/* logical-AND-expression:
+      inclusive-OR-expression
+      logical-AND-expression && inclusive-OR-expression  */
 static inline void
-pp_c_logical_and_expression (c_pretty_printer ppi, tree e)
+pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
     {
-      pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_identifier (ppi, "&&");
-      pp_c_whitespace (ppi);
-      pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_identifier (pp, "&&");
+      pp_c_whitespace (pp);
+      pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_inclusive_or_expression (ppi, e);
+    pp_c_inclusive_or_expression (pp, e);
 }
 
+/* logical-OR-expression:
+      logical-AND-expression
+      logical-OR-expression || logical-AND-expression  */
 void
-pp_c_logical_or_expression (c_pretty_printer ppi, tree e)
+pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
     {
-      pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_identifier (ppi, "||");
-      pp_c_whitespace (ppi);
-      pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_identifier (pp, "||");
+      pp_c_whitespace (pp);
+      pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_logical_and_expression (ppi, e);
+    pp_c_logical_and_expression (pp, e);
 }
 
+/* conditional-expression:
+      logical-OR-expression
+      logical-OR-expression ? expression : conditional-expression  */
 static void
-pp_c_conditional_expression (c_pretty_printer ppi, tree e)
+pp_c_conditional_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == COND_EXPR)
     {
-      pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_whitespace (ppi);
-      pp_question (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_expression (ppi, TREE_OPERAND (e, 1));
-      pp_c_maybe_whitespace (ppi);
-      pp_colon (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
+      pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_question (pp);
+      pp_c_whitespace (pp);
+      pp_expression (pp, TREE_OPERAND (e, 1));
+      pp_c_whitespace (pp);
+      pp_colon (pp);
+      pp_c_whitespace (pp);
+      pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
     }
   else
-    pp_c_logical_or_expression (ppi, e);
+    pp_c_logical_or_expression (pp, e);
 }
 
 
-/* Pretty-print a C assignment-expression.  */
+/* assignment-expression:
+      conditional-expression
+      unary-expression assignment-operator  assignment-expression 
+
+   assignment-expression: one of
+      =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
 static void
-pp_c_assignment_expression (c_pretty_printer ppi, tree e)
+pp_c_assignment_expression (c_pretty_printer *pp, tree e)
 {
   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
     {
-      pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
-      pp_c_maybe_whitespace (ppi);
-      pp_equal (ppi);
-      pp_space (ppi);
-      pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
+      pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_whitespace (pp);
+      pp_equal (pp);
+      pp_space (pp);
+      pp_c_expression (pp, TREE_OPERAND (e, 1));
     }
   else
-    pp_c_conditional_expression (ppi, e);
+    pp_c_conditional_expression (pp, e);
 }
 
-/* Pretty-print an expression.  */
+/* expression:
+       assignment-expression
+       expression , assignment-expression
+
+  Implementation note:  instead of going through the usual recursion
+  chain, I take the liberty of dispatching nodes to the appropriate
+  functions.  This makes some redundancy, but it worths it. That also
+  prevents a possible infinite recursion between pp_c_primary_expression ()
+  and pp_c_expression ().  */
 void
-pp_c_expression (c_pretty_printer ppi, tree e)
+pp_c_expression (c_pretty_printer *pp, tree e)
 {
   switch (TREE_CODE (e))
     {
     case INTEGER_CST:
-      pp_c_integer_constant (ppi, e);
+      pp_c_integer_constant (pp, e);
       break;
 
     case REAL_CST:
-      pp_c_floating_constant (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;
 
+    case IDENTIFIER_NODE:
     case FUNCTION_DECL:
     case VAR_DECL:
     case CONST_DECL:
@@ -1516,9 +1590,8 @@ pp_c_expression (c_pretty_printer ppi, tree e)
     case FIELD_DECL:
     case LABEL_DECL:
     case ERROR_MARK:
-    case TARGET_EXPR:
     case STMT_EXPR:
-      pp_primary_expression (ppi, e);
+      pp_primary_expression (pp, e);
       break;
 
     case POSTINCREMENT_EXPR:
@@ -1535,7 +1608,7 @@ pp_c_expression (c_pretty_printer ppi, tree e)
     case COMPOUND_LITERAL_EXPR:
     case COMPLEX_EXPR:
     case VA_ARG_EXPR:
-      pp_postfix_expression (ppi, e);
+      pp_postfix_expression (pp, e);
       break;
 
     case CONJ_EXPR:
@@ -1550,89 +1623,93 @@ pp_c_expression (c_pretty_printer ppi, tree e)
     case ALIGNOF_EXPR:
     case REALPART_EXPR:
     case IMAGPART_EXPR:
-      pp_c_unary_expression (ppi, e);
+      pp_c_unary_expression (pp, e);
       break;
 
     case FLOAT_EXPR:
     case FIX_TRUNC_EXPR:
     case CONVERT_EXPR:
-      pp_c_cast_expression (ppi, e);
+      pp_c_cast_expression (pp, e);
       break;
 
     case MULT_EXPR:
     case TRUNC_MOD_EXPR:
     case TRUNC_DIV_EXPR:
-      pp_multiplicative_expression (ppi, e);
+      pp_multiplicative_expression (pp, e);
       break;
 
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
-      pp_c_shift_expression (ppi, e);
+      pp_c_shift_expression (pp, e);
       break;
 
     case LT_EXPR:
     case GT_EXPR:
     case LE_EXPR:
     case GE_EXPR:
-      pp_c_relational_expression (ppi, e);
+      pp_c_relational_expression (pp, e);
       break;
 
     case BIT_AND_EXPR:
-      pp_c_and_expression (ppi, e);
+      pp_c_and_expression (pp, e);
       break;
 
     case BIT_XOR_EXPR:
-      pp_c_exclusive_or_expression (ppi, e);
+      pp_c_exclusive_or_expression (pp, e);
       break;
 
     case BIT_IOR_EXPR:
-      pp_c_inclusive_or_expression (ppi, e);
+      pp_c_inclusive_or_expression (pp, e);
       break;
 
     case TRUTH_ANDIF_EXPR:
-      pp_c_logical_and_expression (ppi, e);
+      pp_c_logical_and_expression (pp, e);
       break;
 
     case TRUTH_ORIF_EXPR:
-      pp_c_logical_or_expression (ppi, e);
+      pp_c_logical_or_expression (pp, e);
       break;
 
     case EQ_EXPR:
     case NE_EXPR:
-      pp_c_equality_expression (ppi, e);
+      pp_c_equality_expression (pp, e);
       break;
       
     case COND_EXPR:
-      pp_conditional_expression (ppi, e);
+      pp_conditional_expression (pp, e);
       break;
 
     case PLUS_EXPR:
     case MINUS_EXPR:
-      pp_c_additive_expression (ppi, e);
+      pp_c_additive_expression (pp, e);
       break;
 
     case MODIFY_EXPR:
     case INIT_EXPR:
-      pp_assignment_expression (ppi, e);
+      pp_assignment_expression (pp, e);
       break;
 
     case COMPOUND_EXPR:
-      pp_c_left_paren (ppi);
-      pp_c_expression (ppi, TREE_OPERAND (e, 0));
-      pp_separate_with (ppi, ',');
-      pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
-      pp_c_right_paren (ppi);
+      pp_c_left_paren (pp);
+      pp_expression (pp, TREE_OPERAND (e, 0));
+      pp_separate_with (pp, ',');
+      pp_assignment_expression (pp, TREE_OPERAND (e, 1));
+      pp_c_right_paren (pp);
       break;
 
     case NOP_EXPR:
     case NON_LVALUE_EXPR:
     case SAVE_EXPR:
     case UNSAVE_EXPR:
-      pp_c_expression (ppi, TREE_OPERAND (e, 0));
+      pp_expression (pp, TREE_OPERAND (e, 0));
+      break;
+
+    case TARGET_EXPR:
+      pp_postfix_expression (pp, TREE_OPERAND (e, 1));
       break;
       
     default:
-      pp_unsupported_tree (ppi, e);
+      pp_unsupported_tree (pp, e);
       break;
     }
 }
@@ -1640,8 +1717,16 @@ pp_c_expression (c_pretty_printer ppi, tree e)
 
 
 /* Statements.  */
+
+/* statement:
+      labeled-statement
+      coumpound-statement
+      expression-statement
+      selection-statement
+      iteration-statement
+      jump-statement   */
 void
-pp_c_statement (c_pretty_printer ppi, tree stmt)
+pp_c_statement (c_pretty_printer *pp, tree stmt)
 {
   enum tree_code code;
 
@@ -1651,164 +1736,193 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
   code = TREE_CODE (stmt);
   switch (code)
     {
+       /* labeled-statement:
+             identifier : statement
+             case constant-expression : statement
+             default : statement   */
     case LABEL_STMT:
     case CASE_LABEL:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, -3);
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, -3);
       else
-        pp_indentation (ppi) -= 3;
+        pp_indentation (pp) -= 3;
       if (code == LABEL_STMT)
-	pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
+	pp_tree_identifier (pp, DECL_NAME (LABEL_STMT_LABEL (stmt)));
       else if (code == CASE_LABEL)
 	{
 	  if (CASE_LOW (stmt) == NULL_TREE)
-	    pp_identifier (ppi, "default");
+	    pp_identifier (pp, "default");
 	  else
 	    {
-	      pp_c_identifier (ppi, "case");
-	      pp_c_whitespace (ppi);
-	      pp_conditional_expression (ppi, CASE_LOW (stmt));
+	      pp_c_identifier (pp, "case");
+	      pp_c_whitespace (pp);
+	      pp_conditional_expression (pp, CASE_LOW (stmt));
 	      if (CASE_HIGH (stmt))
 		{
-		  pp_identifier (ppi, "...");
-		  pp_conditional_expression (ppi, CASE_HIGH (stmt));
+		  pp_identifier (pp, "...");
+		  pp_conditional_expression (pp, CASE_HIGH (stmt));
 		}
 	    }
 	}
-      pp_colon (ppi);
-      pp_indentation (ppi) += 3;
-      pp_needs_newline (ppi) = true;
+      pp_colon (pp);
+      pp_indentation (pp) += 3;
+      pp_needs_newline (pp) = true;
       break;
 
+      /* coumpound-statement:
+            {  block-item-list(opt) }
+
+         block-item-list:
+            block-item
+            block-item-list block-item
+
+         block-item:
+            declaration
+            statement   */
     case COMPOUND_STMT:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, 0);
-      pp_c_left_brace (ppi);
-      pp_newline_and_indent (ppi, 3);
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_left_brace (pp);
+      pp_newline_and_indent (pp, 3);
       for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
-	pp_c_statement (ppi, stmt);
-      pp_newline_and_indent (ppi, -3);
-      pp_c_right_brace (ppi);
-      pp_needs_newline (ppi) = true;
+	pp_statement (pp, stmt);
+      pp_newline_and_indent (pp, -3);
+      pp_c_right_brace (pp);
+      pp_needs_newline (pp) = true;
       break;
 
+      /* expression-statement:
+            expression(opt) ;  */
     case EXPR_STMT:
     case CLEANUP_STMT:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, 0);
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
       {
         tree e = code == EXPR_STMT
           ? EXPR_STMT_EXPR (stmt)
           : CLEANUP_EXPR (stmt);
         if (e)
-          pp_c_expression (ppi, e);
+          pp_expression (pp, e);
       }
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = true;
+      pp_c_semicolon (pp);
+      pp_needs_newline (pp) = true;
       break;
 
+      /* selection-statement:
+            if ( expression ) statement
+            if ( expression ) statement else statement
+            switch ( expression ) statement   */
     case IF_STMT:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, 0);
-      pp_c_identifier (ppi, "if");
-      pp_c_whitespace (ppi);
-      pp_c_left_paren (ppi);
-      pp_c_expression (ppi, IF_COND (stmt));
-      pp_c_right_paren (ppi);
-      pp_newline_and_indent (ppi, 3);
-      pp_statement (ppi, THEN_CLAUSE (stmt));
-      pp_newline_and_indent (ppi, -3);
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_identifier (pp, "if");
+      pp_c_whitespace (pp);
+      pp_c_left_paren (pp);
+      pp_expression (pp, IF_COND (stmt));
+      pp_c_right_paren (pp);
+      pp_newline_and_indent (pp, 3);
+      pp_statement (pp, THEN_CLAUSE (stmt));
+      pp_newline_and_indent (pp, -3);
       if (ELSE_CLAUSE (stmt))
 	{
 	  tree else_clause = ELSE_CLAUSE (stmt);
-	  pp_c_identifier (ppi, "else");
+	  pp_c_identifier (pp, "else");
 	  if (TREE_CODE (else_clause) == IF_STMT)
-	    pp_c_whitespace (ppi);
+	    pp_c_whitespace (pp);
 	  else
-	    pp_newline_and_indent (ppi, 3);
-	  pp_statement (ppi, else_clause);
+	    pp_newline_and_indent (pp, 3);
+	  pp_statement (pp, else_clause);
 	  if (TREE_CODE (else_clause) != IF_STMT)
-	    pp_newline_and_indent (ppi, -3);
+	    pp_newline_and_indent (pp, -3);
 	}
       break;
 
     case SWITCH_STMT:
-      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_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;
-
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_identifier (pp, "switch");
+      pp_space (pp);
+      pp_c_left_paren (pp);
+      pp_expression (pp, SWITCH_COND (stmt));
+      pp_c_right_paren (pp);
+      pp_indentation (pp) += 3;
+      pp_needs_newline (pp) = true;
+      pp_statement (pp, SWITCH_BODY (stmt));
+      pp_newline_and_indent (pp, -3);
+      break;
+
+      /* iteration-statement:
+            while ( expression ) statement
+            do statement while ( expression ) ;
+            for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
+            for ( declaration expression(opt) ; expression(opt) ) statement  */
     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_c_right_paren (ppi);
-      pp_newline_and_indent (ppi, 3);
-      pp_statement (ppi, WHILE_BODY (stmt));
-      pp_indentation (ppi) -= 3;
-      pp_needs_newline (ppi) = true;
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_identifier (pp, "while");
+      pp_space (pp);
+      pp_c_left_paren (pp);
+      pp_expression (pp, WHILE_COND (stmt));
+      pp_c_right_paren (pp);
+      pp_newline_and_indent (pp, 3);
+      pp_statement (pp, WHILE_BODY (stmt));
+      pp_indentation (pp) -= 3;
+      pp_needs_newline (pp) = 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));
-      pp_newline_and_indent (ppi, -3);
-      pp_c_identifier (ppi, "while");
-      pp_space (ppi);
-      pp_c_left_paren (ppi);
-      pp_c_expression (ppi, DO_COND (stmt));
-      pp_c_right_paren (ppi);
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = true;
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_identifier (pp, "do");
+      pp_newline_and_indent (pp, 3);
+      pp_statement (pp, DO_BODY (stmt));
+      pp_newline_and_indent (pp, -3);
+      pp_c_identifier (pp, "while");
+      pp_space (pp);
+      pp_c_left_paren (pp);
+      pp_expression (pp, DO_COND (stmt));
+      pp_c_right_paren (pp);
+      pp_c_semicolon (pp);
+      pp_needs_newline (pp) = 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);
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_c_identifier (pp, "for");
+      pp_space (pp);
+      pp_c_left_paren (pp);
       if (FOR_INIT_STMT (stmt))
-        pp_statement (ppi, FOR_INIT_STMT (stmt));
+        pp_statement (pp, FOR_INIT_STMT (stmt));
       else
-        pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = false;
-      pp_c_whitespace (ppi);
+        pp_c_semicolon (pp);
+      pp_needs_newline (pp) = false;
+      pp_c_whitespace (pp);
       if (FOR_COND (stmt))
-	pp_c_expression (ppi, FOR_COND (stmt));
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = false;
-      pp_c_whitespace (ppi);
+	pp_expression (pp, FOR_COND (stmt));
+      pp_c_semicolon (pp);
+      pp_needs_newline (pp) = false;
+      pp_c_whitespace (pp);
       if (FOR_EXPR (stmt))
-	pp_c_expression (ppi, FOR_EXPR (stmt));
-      pp_c_right_paren (ppi);
-      pp_newline_and_indent (ppi, 3);
-      pp_statement (ppi, FOR_BODY (stmt));
-      pp_indentation (ppi) -= 3;
-      pp_needs_newline (ppi) = true;
-      break;
-
+	pp_expression (pp, FOR_EXPR (stmt));
+      pp_c_right_paren (pp);
+      pp_newline_and_indent (pp, 3);
+      pp_statement (pp, FOR_BODY (stmt));
+      pp_indentation (pp) -= 3;
+      pp_needs_newline (pp) = true;
+      break;
+
+      /* jump-statement:
+            goto identifier;
+            continue ;
+            return expression(opt) ;  */
     case BREAK_STMT:
     case CONTINUE_STMT:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, 0);
-      pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = true;
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_identifier (pp, code == BREAK_STMT ? "break" : "continue");
+      pp_c_semicolon (pp);
+      pp_needs_newline (pp) = true;
       break;
 
     case RETURN_STMT:
@@ -1817,13 +1931,19 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
 	tree e = code == RETURN_STMT
 	  ? RETURN_STMT_EXPR (stmt)
 	  : GOTO_DESTINATION (stmt);
-        if (pp_needs_newline (ppi))
-          pp_newline_and_indent (ppi, 0);
-	pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
+        if (pp_needs_newline (pp))
+          pp_newline_and_indent (pp, 0);
+	pp_c_identifier (pp, code == RETURN_STMT ? "return" : "goto");
+        pp_c_whitespace (pp);
 	if (e)
-	  pp_c_expression (ppi, e);
-	pp_c_semicolon (ppi);
-	pp_needs_newline (ppi) = true;
+          {
+            if (TREE_CODE (e) == INIT_EXPR
+                && TREE_CODE (TREE_OPERAND (e, 0)) == RESULT_DECL)
+              e = TREE_OPERAND (e, 1);
+            pp_expression (pp, e);
+          }
+	pp_c_semicolon (pp);
+	pp_needs_newline (pp) = true;
       }
       break;
 
@@ -1831,29 +1951,28 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
       if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
         {
           int i = 0;
-          if (pp_needs_newline (ppi))
-            pp_newline_and_indent (ppi, 0);
+          if (pp_needs_newline (pp))
+            pp_newline_and_indent (pp, 0);
           if (SCOPE_BEGIN_P (stmt))
             {
-              pp_left_brace (ppi);
+              pp_left_brace (pp);
               i = 3;
             }
           else if (SCOPE_END_P (stmt))
             {
-              pp_right_brace (ppi);
+              pp_right_brace (pp);
               i = -3;
             }
-          pp_indentation (ppi) += i;
-          pp_needs_newline (ppi) = true;
+          pp_indentation (pp) += i;
+          pp_needs_newline (pp) = true;
         }
       break;
 
     case DECL_STMT:
-      if (pp_needs_newline (ppi))
-        pp_newline_and_indent (ppi, 0);
-      pp_declaration (ppi, DECL_STMT_DECL (stmt));
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = true;
+      if (pp_needs_newline (pp))
+        pp_newline_and_indent (pp, 0);
+      pp_declaration (pp, DECL_STMT_DECL (stmt));
+      pp_needs_newline (pp) = true;
       break;
 
     case ASM_STMT:
@@ -1861,52 +1980,51 @@ pp_c_statement (c_pretty_printer ppi, tree stmt)
 	bool has_volatile_p = ASM_VOLATILE_P (stmt);
 	bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
 	  || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
-	pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
+	pp_c_identifier (pp, is_extended ? "__asm__" : "asm");
 	if (has_volatile_p)
-	  pp_c_identifier (ppi, "__volatile__");
-	pp_space (ppi);
-	pp_c_left_paren (ppi);
-	pp_c_string_literal (ppi, ASM_STRING (stmt));
+	  pp_c_identifier (pp, "__volatile__");
+	pp_space (pp);
+	pp_c_left_paren (pp);
+	pp_c_string_literal (pp, ASM_STRING (stmt));
 	if (is_extended)
 	  {
-	    pp_space (ppi);
-	    pp_separate_with (ppi, ':');
+	    pp_space (pp);
+	    pp_separate_with (pp, ':');
 	    if (ASM_OUTPUTS (stmt))
-	      pp_c_expression (ppi, ASM_OUTPUTS (stmt));
-	    pp_space (ppi);
-	    pp_separate_with (ppi, ':');
+	      pp_expression (pp, ASM_OUTPUTS (stmt));
+	    pp_space (pp);
+	    pp_separate_with (pp, ':');
 	    if (ASM_INPUTS (stmt))
-	      pp_c_expression (ppi, ASM_INPUTS (stmt));
-	    pp_space (ppi);
-	    pp_separate_with (ppi, ':');
+	      pp_expression (pp, ASM_INPUTS (stmt));
+	    pp_space (pp);
+	    pp_separate_with (pp, ':');
 	    if (ASM_CLOBBERS (stmt))
-	      pp_c_expression (ppi, ASM_CLOBBERS (stmt));
+	      pp_expression (pp, ASM_CLOBBERS (stmt));
 	  }
-	pp_c_right_paren (ppi);
-	pp_newline (ppi);
+	pp_c_right_paren (pp);
+	pp_newline (pp);
       }
       break;
 
     case FILE_STMT:
-      pp_c_identifier (ppi, "__FILE__");
-      pp_space (ppi);
-      pp_equal (ppi);
-      pp_c_whitespace (ppi);
-      pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
-      pp_c_semicolon (ppi);
-      pp_needs_newline (ppi) = true;
+      pp_c_identifier (pp, "__FILE__");
+      pp_space (pp);
+      pp_equal (pp);
+      pp_c_whitespace (pp);
+      pp_c_identifier (pp, FILE_STMT_FILENAME (stmt));
+      pp_c_semicolon (pp);
+      pp_needs_newline (pp) = true;
       break;
 
     default:
-      pp_unsupported_tree (ppi, stmt);
+      pp_unsupported_tree (pp, stmt);
     }
-
 }
 
 
 /* Initialize the PRETTY-PRINTER for handling C codes.  */
 void
-pp_c_pretty_printer_init (c_pretty_printer pp)
+pp_c_pretty_printer_init (c_pretty_printer *pp)
 {
   pp->offset_list               = 0;
 
@@ -1914,10 +2032,13 @@ pp_c_pretty_printer_init (c_pretty_printer pp)
   pp->declaration_specifiers    = pp_c_declaration_specifiers;
   pp->declarator                = pp_c_declarator;
   pp->direct_declarator         = pp_c_direct_declarator;
-  pp->type_specifier            = pp_c_simple_type_specifier;
+  pp->type_specifier_seq        = pp_c_specifier_qualifier_list;
   pp->abstract_declarator       = pp_c_abstract_declarator;
-  pp->parameter_declaration     = pp_c_parameter_declaration;
+  pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
+  pp->ptr_operator              = pp_c_pointer;
+  pp->parameter_list            = pp_c_parameter_type_list;
   pp->type_id                   = pp_c_type_id;
+  pp->simple_type_specifier     = pp_c_type_specifier;
   pp->function_specifier        = pp_c_function_specifier;
   pp->storage_class_specifier   = pp_c_storage_class_specifier;
 
@@ -1931,4 +2052,5 @@ pp_c_pretty_printer_init (c_pretty_printer pp)
   pp->multiplicative_expression = pp_c_multiplicative_expression;
   pp->conditional_expression    = pp_c_conditional_expression;
   pp->assignment_expression     = pp_c_assignment_expression;
+  pp->expression                = pp_c_expression;
 }