URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [tree-pretty-print.c] - Diff between revs 816 and 826

Only display areas with differences | Details | Blame | View Log

Rev 816	Rev 826
`/* Pretty formatting of GENERIC trees in C syntax.`	`/* Pretty formatting of GENERIC trees in C syntax.`
`Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009`	`Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009`
`Free Software Foundation, Inc.`	`Free Software Foundation, Inc.`
`Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>`	`Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>`

`This file is part of GCC.`	`This file is part of GCC.`

`GCC is free software; you can redistribute it and/or modify it under`	`GCC is free software; you can redistribute it and/or modify it under`
`the terms of the GNU General Public License as published by the Free`	`the terms of the GNU General Public License as published by the Free`
`Software Foundation; either version 3, or (at your option) any later`	`Software Foundation; either version 3, or (at your option) any later`
`version.`	`version.`

`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`	`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`
`WARRANTY; without even the implied warranty of MERCHANTABILITY or`	`WARRANTY; without even the implied warranty of MERCHANTABILITY or`
`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`	`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
`for more details.`	`for more details.`

`You should have received a copy of the GNU General Public License`	`You should have received a copy of the GNU General Public License`
`along with GCC; see the file COPYING3. If not see`	`along with GCC; see the file COPYING3. If not see`
`<http://www.gnu.org/licenses/>. */`	`<http://www.gnu.org/licenses/>. */`

`#include "config.h"`	`#include "config.h"`
`#include "system.h"`	`#include "system.h"`
`#include "coretypes.h"`	`#include "coretypes.h"`
`#include "tm.h"`	`#include "tm.h"`
`#include "tree.h"`	`#include "tree.h"`
`#include "output.h"`	`#include "output.h"`
`#include "diagnostic.h"`	`#include "diagnostic.h"`
`#include "real.h"`	`#include "real.h"`
`#include "hashtab.h"`	`#include "hashtab.h"`
`#include "tree-flow.h"`	`#include "tree-flow.h"`
`#include "langhooks.h"`	`#include "langhooks.h"`
`#include "tree-iterator.h"`	`#include "tree-iterator.h"`
`#include "tree-chrec.h"`	`#include "tree-chrec.h"`
`#include "tree-pass.h"`	`#include "tree-pass.h"`
`#include "fixed-value.h"`	`#include "fixed-value.h"`
`#include "value-prof.h"`	`#include "value-prof.h"`
`#include "predict.h"`	`#include "predict.h"`

`/* Local functions, macros and variables. */`	`/* Local functions, macros and variables. */`
`static const char *op_symbol (const_tree);`	`static const char *op_symbol (const_tree);`
`static void pretty_print_string (pretty_printer , const char);`	`static void pretty_print_string (pretty_printer , const char);`
`static void newline_and_indent (pretty_printer *, int);`	`static void newline_and_indent (pretty_printer *, int);`
`static void maybe_init_pretty_print (FILE *);`	`static void maybe_init_pretty_print (FILE *);`
`static void print_struct_decl (pretty_printer *, const_tree, int, int);`	`static void print_struct_decl (pretty_printer *, const_tree, int, int);`
`static void do_niy (pretty_printer *, const_tree);`	`static void do_niy (pretty_printer *, const_tree);`

`#define INDENT(SPACE) do { \`	`#define INDENT(SPACE) do { \`
`int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)`	`int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)`

`#define NIY do_niy(buffer,node)`	`#define NIY do_niy(buffer,node)`

`static pretty_printer buffer;`	`static pretty_printer buffer;`
`static int initialized = 0;`	`static int initialized = 0;`

`/* Try to print something for an unknown tree code. */`	`/* Try to print something for an unknown tree code. */`

`static void`	`static void`
`do_niy (pretty_printer *buffer, const_tree node)`	`do_niy (pretty_printer *buffer, const_tree node)`
`{`	`{`
`int i, len;`	`int i, len;`

`pp_string (buffer, "<<< Unknown tree: ");`	`pp_string (buffer, "<<< Unknown tree: ");`
`pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);`	`pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);`

`if (EXPR_P (node))`	`if (EXPR_P (node))`
`{`	`{`
`len = TREE_OPERAND_LENGTH (node);`	`len = TREE_OPERAND_LENGTH (node);`
`for (i = 0; i < len; ++i)`	`for (i = 0; i < len; ++i)`
`{`	`{`
`newline_and_indent (buffer, 2);`	`newline_and_indent (buffer, 2);`
`dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);`
`}`	`}`
`}`	`}`

`pp_string (buffer, " >>>\n");`	`pp_string (buffer, " >>>\n");`
`}`	`}`

`/* Debugging function to print out a generic expression. */`	`/* Debugging function to print out a generic expression. */`

`void`	`void`
`debug_generic_expr (tree t)`	`debug_generic_expr (tree t)`
`{`	`{`
`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS);`	`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS);`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`
`}`	`}`

`/* Debugging function to print out a generic statement. */`	`/* Debugging function to print out a generic statement. */`

`void`	`void`
`debug_generic_stmt (tree t)`	`debug_generic_stmt (tree t)`
`{`	`{`
`print_generic_stmt (stderr, t, TDF_VOPS\|TDF_MEMSYMS);`	`print_generic_stmt (stderr, t, TDF_VOPS\|TDF_MEMSYMS);`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`
`}`	`}`

`/* Debugging function to print out a chain of trees . */`	`/* Debugging function to print out a chain of trees . */`

`void`	`void`
`debug_tree_chain (tree t)`	`debug_tree_chain (tree t)`
`{`	`{`
`struct pointer_set_t *seen = pointer_set_create ();`	`struct pointer_set_t *seen = pointer_set_create ();`

`while (t)`	`while (t)`
`{`	`{`
`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS\|TDF_UID);`	`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS\|TDF_UID);`
`fprintf (stderr, " ");`	`fprintf (stderr, " ");`
`t = TREE_CHAIN (t);`	`t = TREE_CHAIN (t);`
`if (pointer_set_insert (seen, t))`	`if (pointer_set_insert (seen, t))`
`{`	`{`
`fprintf (stderr, "... [cycled back to ");`	`fprintf (stderr, "... [cycled back to ");`
`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS\|TDF_UID);`	`print_generic_expr (stderr, t, TDF_VOPS\|TDF_MEMSYMS\|TDF_UID);`
`fprintf (stderr, "]");`	`fprintf (stderr, "]");`
`break;`	`break;`
`}`	`}`
`}`	`}`
`fprintf (stderr, "\n");`	`fprintf (stderr, "\n");`

`pointer_set_destroy (seen);`	`pointer_set_destroy (seen);`
`}`	`}`

`/* Prints declaration DECL to the FILE with details specified by FLAGS. */`	`/* Prints declaration DECL to the FILE with details specified by FLAGS. */`
`void`	`void`
`print_generic_decl (FILE *file, tree decl, int flags)`	`print_generic_decl (FILE *file, tree decl, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`print_declaration (&buffer, decl, 2, flags);`	`print_declaration (&buffer, decl, 2, flags);`
`pp_write_text_to_stream (&buffer);`	`pp_write_text_to_stream (&buffer);`
`}`	`}`

`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`	`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`
`to show in the dump. See TDF_* in tree-pass.h. */`	`to show in the dump. See TDF_* in tree-pass.h. */`

`void`	`void`
`print_generic_stmt (FILE *file, tree t, int flags)`	`print_generic_stmt (FILE *file, tree t, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`dump_generic_node (&buffer, t, 0, flags, true);`	`dump_generic_node (&buffer, t, 0, flags, true);`
`pp_flush (&buffer);`	`pp_flush (&buffer);`
`}`	`}`

`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`	`/* Print tree T, and its successors, on file FILE. FLAGS specifies details`
`to show in the dump. See TDF_* in tree-pass.h. The output is indented by`	`to show in the dump. See TDF_* in tree-pass.h. The output is indented by`
`INDENT spaces. */`	`INDENT spaces. */`

`void`	`void`
`print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)`	`print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)`
`{`	`{`
`int i;`	`int i;`

`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`

`for (i = 0; i < indent; i++)`	`for (i = 0; i < indent; i++)`
`pp_space (&buffer);`	`pp_space (&buffer);`
`dump_generic_node (&buffer, t, indent, flags, true);`	`dump_generic_node (&buffer, t, indent, flags, true);`
`pp_flush (&buffer);`	`pp_flush (&buffer);`
`}`	`}`

`/* Print a single expression T on file FILE. FLAGS specifies details to show`	`/* Print a single expression T on file FILE. FLAGS specifies details to show`
`in the dump. See TDF_* in tree-pass.h. */`	`in the dump. See TDF_* in tree-pass.h. */`

`void`	`void`
`print_generic_expr (FILE *file, tree t, int flags)`	`print_generic_expr (FILE *file, tree t, int flags)`
`{`	`{`
`maybe_init_pretty_print (file);`	`maybe_init_pretty_print (file);`
`dump_generic_node (&buffer, t, 0, flags, false);`	`dump_generic_node (&buffer, t, 0, flags, false);`
`}`	`}`

`/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set`	`/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set`
`in FLAGS. */`	`in FLAGS. */`

`static void`	`static void`
`dump_decl_name (pretty_printer *buffer, tree node, int flags)`	`dump_decl_name (pretty_printer *buffer, tree node, int flags)`
`{`	`{`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`{`	`{`
`if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))`	`if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))`
`pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));`	`pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));`
`else`	`else`
`pp_tree_identifier (buffer, DECL_NAME (node));`	`pp_tree_identifier (buffer, DECL_NAME (node));`
`}`	`}`
`if ((flags & TDF_UID) \|\| DECL_NAME (node) == NULL_TREE)`	`if ((flags & TDF_UID) \|\| DECL_NAME (node) == NULL_TREE)`
`{`	`{`
`if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)`	`if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)`
`pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));`	`pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));`
`else if (TREE_CODE (node) == DEBUG_EXPR_DECL)`	`else if (TREE_CODE (node) == DEBUG_EXPR_DECL)`
`{`	`{`
`if (flags & TDF_NOUID)`	`if (flags & TDF_NOUID)`
`pp_string (buffer, "D#xxxx");`	`pp_string (buffer, "D#xxxx");`
`else`	`else`
`pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));`	`pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));`
`}`	`}`
`else`	`else`
`{`	`{`
`char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';`	`char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';`
`if (flags & TDF_NOUID)`	`if (flags & TDF_NOUID)`
`pp_printf (buffer, "%c.xxxx", c);`	`pp_printf (buffer, "%c.xxxx", c);`
`else`	`else`
`pp_printf (buffer, "%c.%u", c, DECL_UID (node));`	`pp_printf (buffer, "%c.%u", c, DECL_UID (node));`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Like the above, but used for pretty printing function calls. */`	`/* Like the above, but used for pretty printing function calls. */`

`static void`	`static void`
`dump_function_name (pretty_printer *buffer, tree node, int flags)`	`dump_function_name (pretty_printer *buffer, tree node, int flags)`
`{`	`{`
`if (TREE_CODE (node) == NOP_EXPR)`	`if (TREE_CODE (node) == NOP_EXPR)`
`node = TREE_OPERAND (node, 0);`	`node = TREE_OPERAND (node, 0);`
`if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)`	`if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)`
`pp_string (buffer, lang_hooks.decl_printable_name (node, 1));`	`pp_string (buffer, lang_hooks.decl_printable_name (node, 1));`
`else`	`else`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`}`	`}`

`/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and`	`/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and`
`FLAGS are as in dump_generic_node. */`	`FLAGS are as in dump_generic_node. */`

`static void`	`static void`
`dump_function_declaration (pretty_printer *buffer, tree node,`	`dump_function_declaration (pretty_printer *buffer, tree node,`
`int spc, int flags)`	`int spc, int flags)`
`{`	`{`
`bool wrote_arg = false;`	`bool wrote_arg = false;`
`tree arg;`	`tree arg;`

`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`

`/* Print the argument types. The last element in the list is a VOID_TYPE.`	`/* Print the argument types. The last element in the list is a VOID_TYPE.`
`The following avoids printing the last element. */`	`The following avoids printing the last element. */`
`arg = TYPE_ARG_TYPES (node);`	`arg = TYPE_ARG_TYPES (node);`
`while (arg && TREE_CHAIN (arg) && arg != error_mark_node)`	`while (arg && TREE_CHAIN (arg) && arg != error_mark_node)`
`{`	`{`
`wrote_arg = true;`	`wrote_arg = true;`
`dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);`
`arg = TREE_CHAIN (arg);`	`arg = TREE_CHAIN (arg);`
`if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)`	`if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`

`if (!wrote_arg)`	`if (!wrote_arg)`
`pp_string (buffer, "void");`	`pp_string (buffer, "void");`

`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`

`/* Dump the domain associated with an array. */`	`/* Dump the domain associated with an array. */`

`static void`	`static void`
`dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)`	`dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)`
`{`	`{`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`if (domain)`	`if (domain)`
`{`	`{`
`tree min = TYPE_MIN_VALUE (domain);`	`tree min = TYPE_MIN_VALUE (domain);`
`tree max = TYPE_MAX_VALUE (domain);`	`tree max = TYPE_MAX_VALUE (domain);`

`if (min && max`	`if (min && max`
`&& integer_zerop (min)`	`&& integer_zerop (min)`
`&& host_integerp (max, 0))`	`&& host_integerp (max, 0))`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);`
`else`	`else`
`{`	`{`
`if (min)`	`if (min)`
`dump_generic_node (buffer, min, spc, flags, false);`	`dump_generic_node (buffer, min, spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`if (max)`	`if (max)`
`dump_generic_node (buffer, max, spc, flags, false);`	`dump_generic_node (buffer, max, spc, flags, false);`
`}`	`}`
`}`	`}`
`else`	`else`
`pp_string (buffer, "<unknown>");`	`pp_string (buffer, "<unknown>");`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`


`/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in`	`/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in`
`dump_generic_node. */`	`dump_generic_node. */`

`static void`	`static void`
`dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)`	`dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)`
`{`	`{`
`const char *name;`	`const char *name;`

`switch (OMP_CLAUSE_CODE (clause))`	`switch (OMP_CLAUSE_CODE (clause))`
`{`	`{`
`case OMP_CLAUSE_PRIVATE:`	`case OMP_CLAUSE_PRIVATE:`
`name = "private";`	`name = "private";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_SHARED:`	`case OMP_CLAUSE_SHARED:`
`name = "shared";`	`name = "shared";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_FIRSTPRIVATE:`	`case OMP_CLAUSE_FIRSTPRIVATE:`
`name = "firstprivate";`	`name = "firstprivate";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_LASTPRIVATE:`	`case OMP_CLAUSE_LASTPRIVATE:`
`name = "lastprivate";`	`name = "lastprivate";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_COPYIN:`	`case OMP_CLAUSE_COPYIN:`
`name = "copyin";`	`name = "copyin";`
`goto print_remap;`	`goto print_remap;`
`case OMP_CLAUSE_COPYPRIVATE:`	`case OMP_CLAUSE_COPYPRIVATE:`
`name = "copyprivate";`	`name = "copyprivate";`
`goto print_remap;`	`goto print_remap;`
`print_remap:`	`print_remap:`
`pp_string (buffer, name);`	`pp_string (buffer, name);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_REDUCTION:`	`case OMP_CLAUSE_REDUCTION:`
`pp_string (buffer, "reduction(");`	`pp_string (buffer, "reduction(");`
`pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));`	`pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_IF:`	`case OMP_CLAUSE_IF:`
`pp_string (buffer, "if(");`	`pp_string (buffer, "if(");`
`dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_NUM_THREADS:`	`case OMP_CLAUSE_NUM_THREADS:`
`pp_string (buffer, "num_threads(");`	`pp_string (buffer, "num_threads(");`
`dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),`	`dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_NOWAIT:`	`case OMP_CLAUSE_NOWAIT:`
`pp_string (buffer, "nowait");`	`pp_string (buffer, "nowait");`
`break;`	`break;`
`case OMP_CLAUSE_ORDERED:`	`case OMP_CLAUSE_ORDERED:`
`pp_string (buffer, "ordered");`	`pp_string (buffer, "ordered");`
`break;`	`break;`

`case OMP_CLAUSE_DEFAULT:`	`case OMP_CLAUSE_DEFAULT:`
`pp_string (buffer, "default(");`	`pp_string (buffer, "default(");`
`switch (OMP_CLAUSE_DEFAULT_KIND (clause))`	`switch (OMP_CLAUSE_DEFAULT_KIND (clause))`
`{`	`{`
`case OMP_CLAUSE_DEFAULT_UNSPECIFIED:`	`case OMP_CLAUSE_DEFAULT_UNSPECIFIED:`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_SHARED:`	`case OMP_CLAUSE_DEFAULT_SHARED:`
`pp_string (buffer, "shared");`	`pp_string (buffer, "shared");`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_NONE:`	`case OMP_CLAUSE_DEFAULT_NONE:`
`pp_string (buffer, "none");`	`pp_string (buffer, "none");`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_PRIVATE:`	`case OMP_CLAUSE_DEFAULT_PRIVATE:`
`pp_string (buffer, "private");`	`pp_string (buffer, "private");`
`break;`	`break;`
`case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:`	`case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:`
`pp_string (buffer, "firstprivate");`	`pp_string (buffer, "firstprivate");`
`break;`	`break;`
`default:`	`default:`
`gcc_unreachable ();`	`gcc_unreachable ();`
`}`	`}`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_SCHEDULE:`	`case OMP_CLAUSE_SCHEDULE:`
`pp_string (buffer, "schedule(");`	`pp_string (buffer, "schedule(");`
`switch (OMP_CLAUSE_SCHEDULE_KIND (clause))`	`switch (OMP_CLAUSE_SCHEDULE_KIND (clause))`
`{`	`{`
`case OMP_CLAUSE_SCHEDULE_STATIC:`	`case OMP_CLAUSE_SCHEDULE_STATIC:`
`pp_string (buffer, "static");`	`pp_string (buffer, "static");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_DYNAMIC:`	`case OMP_CLAUSE_SCHEDULE_DYNAMIC:`
`pp_string (buffer, "dynamic");`	`pp_string (buffer, "dynamic");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_GUIDED:`	`case OMP_CLAUSE_SCHEDULE_GUIDED:`
`pp_string (buffer, "guided");`	`pp_string (buffer, "guided");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_RUNTIME:`	`case OMP_CLAUSE_SCHEDULE_RUNTIME:`
`pp_string (buffer, "runtime");`	`pp_string (buffer, "runtime");`
`break;`	`break;`
`case OMP_CLAUSE_SCHEDULE_AUTO:`	`case OMP_CLAUSE_SCHEDULE_AUTO:`
`pp_string (buffer, "auto");`	`pp_string (buffer, "auto");`
`break;`	`break;`
`default:`	`default:`
`gcc_unreachable ();`	`gcc_unreachable ();`
`}`	`}`
`if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))`	`if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`dump_generic_node (buffer,`	`dump_generic_node (buffer,`
`OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),`	`OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`}`	`}`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case OMP_CLAUSE_UNTIED:`	`case OMP_CLAUSE_UNTIED:`
`pp_string (buffer, "untied");`	`pp_string (buffer, "untied");`
`break;`	`break;`

`case OMP_CLAUSE_COLLAPSE:`	`case OMP_CLAUSE_COLLAPSE:`
`pp_string (buffer, "collapse(");`	`pp_string (buffer, "collapse(");`
`dump_generic_node (buffer,`	`dump_generic_node (buffer,`
`OMP_CLAUSE_COLLAPSE_EXPR (clause),`	`OMP_CLAUSE_COLLAPSE_EXPR (clause),`
`spc, flags, false);`	`spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`default:`	`default:`
`/* Should never happen. */`	`/* Should never happen. */`
`dump_generic_node (buffer, clause, spc, flags, false);`	`dump_generic_node (buffer, clause, spc, flags, false);`
`break;`	`break;`
`}`	`}`
`}`	`}`


`/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in`	`/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in`
`dump_generic_node. */`	`dump_generic_node. */`

`void`	`void`
`dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)`	`dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)`
`{`	`{`
`if (clause == NULL)`	`if (clause == NULL)`
`return;`	`return;`

`pp_space (buffer);`	`pp_space (buffer);`
`while (1)`	`while (1)`
`{`	`{`
`dump_omp_clause (buffer, clause, spc, flags);`	`dump_omp_clause (buffer, clause, spc, flags);`
`clause = OMP_CLAUSE_CHAIN (clause);`	`clause = OMP_CLAUSE_CHAIN (clause);`
`if (clause == NULL)`	`if (clause == NULL)`
`return;`	`return;`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`


`/* Dump location LOC to BUFFER. */`	`/* Dump location LOC to BUFFER. */`

`static void`	`static void`
`dump_location (pretty_printer *buffer, location_t loc)`	`dump_location (pretty_printer *buffer, location_t loc)`
`{`	`{`
`expanded_location xloc = expand_location (loc);`	`expanded_location xloc = expand_location (loc);`

`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`if (xloc.file)`	`if (xloc.file)`
`{`	`{`
`pp_string (buffer, xloc.file);`	`pp_string (buffer, xloc.file);`
`pp_string (buffer, " : ");`	`pp_string (buffer, " : ");`
`}`	`}`
`pp_decimal_int (buffer, xloc.line);`	`pp_decimal_int (buffer, xloc.line);`
`pp_string (buffer, "] ");`	`pp_string (buffer, "] ");`
`}`	`}`


`/* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in`	`/* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in`
`dump_generic_node. */`	`dump_generic_node. */`

`static void`	`static void`
`dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)`	`dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)`
`{`	`{`
`tree t;`	`tree t;`

`pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));`	`pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));`

`if (flags & TDF_ADDRESS)`	`if (flags & TDF_ADDRESS)`
`pp_printf (buffer, "[%p] ", (void *) block);`	`pp_printf (buffer, "[%p] ", (void *) block);`

`if (BLOCK_ABSTRACT (block))`	`if (BLOCK_ABSTRACT (block))`
`pp_string (buffer, "[abstract] ");`	`pp_string (buffer, "[abstract] ");`

`if (TREE_ASM_WRITTEN (block))`	`if (TREE_ASM_WRITTEN (block))`
`pp_string (buffer, "[written] ");`	`pp_string (buffer, "[written] ");`

`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`return;`	`return;`

`if (BLOCK_SOURCE_LOCATION (block))`	`if (BLOCK_SOURCE_LOCATION (block))`
`dump_location (buffer, BLOCK_SOURCE_LOCATION (block));`	`dump_location (buffer, BLOCK_SOURCE_LOCATION (block));`

`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`

`if (BLOCK_SUPERCONTEXT (block))`	`if (BLOCK_SUPERCONTEXT (block))`
`{`	`{`
`pp_string (buffer, "SUPERCONTEXT: ");`	`pp_string (buffer, "SUPERCONTEXT: ");`
`dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,`	`dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,`
`flags \| TDF_SLIM, false);`	`flags \| TDF_SLIM, false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_SUBBLOCKS (block))`	`if (BLOCK_SUBBLOCKS (block))`
`{`	`{`
`pp_string (buffer, "SUBBLOCKS: ");`	`pp_string (buffer, "SUBBLOCKS: ");`
`for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))`	`for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`	`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_CHAIN (block))`	`if (BLOCK_CHAIN (block))`
`{`	`{`
`pp_string (buffer, "SIBLINGS: ");`	`pp_string (buffer, "SIBLINGS: ");`
`for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))`	`for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`	`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_VARS (block))`	`if (BLOCK_VARS (block))`
`{`	`{`
`pp_string (buffer, "VARS: ");`	`pp_string (buffer, "VARS: ");`
`for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))`	`for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags, false);`	`dump_generic_node (buffer, t, 0, flags, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)`	`if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)`
`{`	`{`
`unsigned i;`	`unsigned i;`
`VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);`	`VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);`

`pp_string (buffer, "NONLOCALIZED_VARS: ");`	`pp_string (buffer, "NONLOCALIZED_VARS: ");`
`for (i = 0; VEC_iterate (tree, nlv, i, t); i++)`	`for (i = 0; VEC_iterate (tree, nlv, i, t); i++)`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags, false);`	`dump_generic_node (buffer, t, 0, flags, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_ABSTRACT_ORIGIN (block))`	`if (BLOCK_ABSTRACT_ORIGIN (block))`
`{`	`{`
`pp_string (buffer, "ABSTRACT_ORIGIN: ");`	`pp_string (buffer, "ABSTRACT_ORIGIN: ");`
`dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,`	`dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,`
`flags \| TDF_SLIM, false);`	`flags \| TDF_SLIM, false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_FRAGMENT_ORIGIN (block))`	`if (BLOCK_FRAGMENT_ORIGIN (block))`
`{`	`{`
`pp_string (buffer, "FRAGMENT_ORIGIN: ");`	`pp_string (buffer, "FRAGMENT_ORIGIN: ");`
`dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,`	`dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,`
`flags \| TDF_SLIM, false);`	`flags \| TDF_SLIM, false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`

`if (BLOCK_FRAGMENT_CHAIN (block))`	`if (BLOCK_FRAGMENT_CHAIN (block))`
`{`	`{`
`pp_string (buffer, "FRAGMENT_CHAIN: ");`	`pp_string (buffer, "FRAGMENT_CHAIN: ");`
`for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))`	`for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))`
`{`	`{`
`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`	`dump_generic_node (buffer, t, 0, flags \| TDF_SLIM, false);`
`pp_string (buffer, " ");`	`pp_string (buffer, " ");`
`}`	`}`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`}`	`}`
`}`	`}`


`/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of`	`/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of`
`indent. FLAGS specifies details to show in the dump (see TDF_* in`	`indent. FLAGS specifies details to show in the dump (see TDF_* in`
`tree-pass.h). If IS_STMT is true, the object printed is considered`	`tree-pass.h). If IS_STMT is true, the object printed is considered`
`to be a statement and it is terminated by ';' if appropriate. */`	`to be a statement and it is terminated by ';' if appropriate. */`

`int`	`int`
`dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,`	`dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,`
`bool is_stmt)`	`bool is_stmt)`
`{`	`{`
`tree type;`	`tree type;`
`tree op0, op1;`	`tree op0, op1;`
`const char *str;`	`const char *str;`
`bool is_expr;`	`bool is_expr;`

`if (node == NULL_TREE)`	`if (node == NULL_TREE)`
`return spc;`	`return spc;`

`is_expr = EXPR_P (node);`	`is_expr = EXPR_P (node);`

`if (is_stmt && (flags & TDF_STMTADDR))`	`if (is_stmt && (flags & TDF_STMTADDR))`
`pp_printf (buffer, "<&%p> ", (void *)node);`	`pp_printf (buffer, "<&%p> ", (void *)node);`

`if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))`	`if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))`
`dump_location (buffer, EXPR_LOCATION (node));`	`dump_location (buffer, EXPR_LOCATION (node));`

`switch (TREE_CODE (node))`	`switch (TREE_CODE (node))`
`{`	`{`
`case ERROR_MARK:`	`case ERROR_MARK:`
`pp_string (buffer, "<<< error >>>");`	`pp_string (buffer, "<<< error >>>");`
`break;`	`break;`

`case IDENTIFIER_NODE:`	`case IDENTIFIER_NODE:`
`pp_tree_identifier (buffer, node);`	`pp_tree_identifier (buffer, node);`
`break;`	`break;`

`case TREE_LIST:`	`case TREE_LIST:`
`while (node && node != error_mark_node)`	`while (node && node != error_mark_node)`
`{`	`{`
`if (TREE_PURPOSE (node))`	`if (TREE_PURPOSE (node))`
`{`	`{`
`dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);`
`node = TREE_CHAIN (node);`	`node = TREE_CHAIN (node);`
`if (node && TREE_CODE (node) == TREE_LIST)`	`if (node && TREE_CODE (node) == TREE_LIST)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case TREE_BINFO:`	`case TREE_BINFO:`
`dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);`
`break;`	`break;`

`case TREE_VEC:`	`case TREE_VEC:`
`{`	`{`
`size_t i;`	`size_t i;`
`if (TREE_VEC_LENGTH (node) > 0)`	`if (TREE_VEC_LENGTH (node) > 0)`
`{`	`{`
`size_t len = TREE_VEC_LENGTH (node);`	`size_t len = TREE_VEC_LENGTH (node);`
`for (i = 0; i < len - 1; i++)`	`for (i = 0; i < len - 1; i++)`
`{`	`{`
`dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,`	`dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,`
`false);`	`false);`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,`	`dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,`
`flags, false);`	`flags, false);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case VOID_TYPE:`	`case VOID_TYPE:`
`case INTEGER_TYPE:`	`case INTEGER_TYPE:`
`case REAL_TYPE:`	`case REAL_TYPE:`
`case FIXED_POINT_TYPE:`	`case FIXED_POINT_TYPE:`
`case COMPLEX_TYPE:`	`case COMPLEX_TYPE:`
`case VECTOR_TYPE:`	`case VECTOR_TYPE:`
`case ENUMERAL_TYPE:`	`case ENUMERAL_TYPE:`
`case BOOLEAN_TYPE:`	`case BOOLEAN_TYPE:`
`{`	`{`
`unsigned int quals = TYPE_QUALS (node);`	`unsigned int quals = TYPE_QUALS (node);`
`enum tree_code_class tclass;`	`enum tree_code_class tclass;`

`if (quals & TYPE_QUAL_CONST)`	`if (quals & TYPE_QUAL_CONST)`
`pp_string (buffer, "const ");`	`pp_string (buffer, "const ");`
`else if (quals & TYPE_QUAL_VOLATILE)`	`else if (quals & TYPE_QUAL_VOLATILE)`
`pp_string (buffer, "volatile ");`	`pp_string (buffer, "volatile ");`
`else if (quals & TYPE_QUAL_RESTRICT)`	`else if (quals & TYPE_QUAL_RESTRICT)`
`pp_string (buffer, "restrict ");`	`pp_string (buffer, "restrict ");`

`if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))`	`if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))`
`{`	`{`
`pp_string (buffer, "<address-space-");`	`pp_string (buffer, "<address-space-");`
`pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));`	`pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));`
`pp_string (buffer, "> ");`	`pp_string (buffer, "> ");`
`}`	`}`

`tclass = TREE_CODE_CLASS (TREE_CODE (node));`	`tclass = TREE_CODE_CLASS (TREE_CODE (node));`

`if (tclass == tcc_declaration)`	`if (tclass == tcc_declaration)`
`{`	`{`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else`	`else`
`pp_string (buffer, "<unnamed type decl>");`	`pp_string (buffer, "<unnamed type decl>");`
`}`	`}`
`else if (tclass == tcc_type)`	`else if (tclass == tcc_type)`
`{`	`{`
`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`{`	`{`
`if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)`	`if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)`
`pp_tree_identifier (buffer, TYPE_NAME (node));`	`pp_tree_identifier (buffer, TYPE_NAME (node));`
`else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL`	`else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL`
`&& DECL_NAME (TYPE_NAME (node)))`	`&& DECL_NAME (TYPE_NAME (node)))`
`dump_decl_name (buffer, TYPE_NAME (node), flags);`	`dump_decl_name (buffer, TYPE_NAME (node), flags);`
`else`	`else`
`pp_string (buffer, "<unnamed type>");`	`pp_string (buffer, "<unnamed type>");`
`}`	`}`
`else if (TREE_CODE (node) == VECTOR_TYPE)`	`else if (TREE_CODE (node) == VECTOR_TYPE)`
`{`	`{`
`pp_string (buffer, "vector ");`	`pp_string (buffer, "vector ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`else if (TREE_CODE (node) == INTEGER_TYPE)`	`else if (TREE_CODE (node) == INTEGER_TYPE)`
`{`	`{`
`pp_string (buffer, (TYPE_UNSIGNED (node)`	`pp_string (buffer, (TYPE_UNSIGNED (node)`
`? "<unnamed-unsigned:"`	`? "<unnamed-unsigned:"`
`: "<unnamed-signed:"));`	`: "<unnamed-signed:"));`
`pp_decimal_int (buffer, TYPE_PRECISION (node));`	`pp_decimal_int (buffer, TYPE_PRECISION (node));`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`}`	`}`
`else if (TREE_CODE (node) == COMPLEX_TYPE)`	`else if (TREE_CODE (node) == COMPLEX_TYPE)`
`{`	`{`
`pp_string (buffer, "__complex__ ");`	`pp_string (buffer, "__complex__ ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`else if (TREE_CODE (node) == REAL_TYPE)`	`else if (TREE_CODE (node) == REAL_TYPE)`
`{`	`{`
`pp_string (buffer, "<float:");`	`pp_string (buffer, "<float:");`
`pp_decimal_int (buffer, TYPE_PRECISION (node));`	`pp_decimal_int (buffer, TYPE_PRECISION (node));`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`}`	`}`
`else if (TREE_CODE (node) == FIXED_POINT_TYPE)`	`else if (TREE_CODE (node) == FIXED_POINT_TYPE)`
`{`	`{`
`pp_string (buffer, "<fixed-point-");`	`pp_string (buffer, "<fixed-point-");`
`pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");`	`pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");`
`pp_decimal_int (buffer, TYPE_PRECISION (node));`	`pp_decimal_int (buffer, TYPE_PRECISION (node));`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`}`	`}`
`else`	`else`
`pp_string (buffer, "<unnamed type>");`	`pp_string (buffer, "<unnamed type>");`
`}`	`}`
`break;`	`break;`
`}`	`}`

`case POINTER_TYPE:`	`case POINTER_TYPE:`
`case REFERENCE_TYPE:`	`case REFERENCE_TYPE:`
`str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");`	`str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");`

`if (TREE_TYPE (node) == NULL)`	`if (TREE_TYPE (node) == NULL)`
`{`	`{`
`pp_string (buffer, str);`	`pp_string (buffer, str);`
`pp_string (buffer, "<null type>");`	`pp_string (buffer, "<null type>");`
`}`	`}`
`else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)`	`else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)`
`{`	`{`
`tree fnode = TREE_TYPE (node);`	`tree fnode = TREE_TYPE (node);`

`dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`pp_string (buffer, str);`	`pp_string (buffer, str);`
`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`	`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`
`dump_decl_name (buffer, TYPE_NAME (node), flags);`	`dump_decl_name (buffer, TYPE_NAME (node), flags);`
`else`	`else`
`pp_printf (buffer, "<T%x>", TYPE_UID (node));`	`pp_printf (buffer, "<T%x>", TYPE_UID (node));`

`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`dump_function_declaration (buffer, fnode, spc, flags);`	`dump_function_declaration (buffer, fnode, spc, flags);`
`}`	`}`
`else`	`else`
`{`	`{`
`unsigned int quals = TYPE_QUALS (node);`	`unsigned int quals = TYPE_QUALS (node);`

`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_string (buffer, str);`	`pp_string (buffer, str);`

`if (quals & TYPE_QUAL_CONST)`	`if (quals & TYPE_QUAL_CONST)`
`pp_string (buffer, " const");`	`pp_string (buffer, " const");`
`if (quals & TYPE_QUAL_VOLATILE)`	`if (quals & TYPE_QUAL_VOLATILE)`
`pp_string (buffer, " volatile");`	`pp_string (buffer, " volatile");`
`if (quals & TYPE_QUAL_RESTRICT)`	`if (quals & TYPE_QUAL_RESTRICT)`
`pp_string (buffer, " restrict");`	`pp_string (buffer, " restrict");`

`if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))`	`if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))`
`{`	`{`
`pp_string (buffer, " <address-space-");`	`pp_string (buffer, " <address-space-");`
`pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));`	`pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`}`	`}`

`if (TYPE_REF_CAN_ALIAS_ALL (node))`	`if (TYPE_REF_CAN_ALIAS_ALL (node))`
`pp_string (buffer, " {ref-all}");`	`pp_string (buffer, " {ref-all}");`
`}`	`}`
`break;`	`break;`

`case OFFSET_TYPE:`	`case OFFSET_TYPE:`
`NIY;`	`NIY;`
`break;`	`break;`

`case TARGET_MEM_REF:`	`case TARGET_MEM_REF:`
`{`	`{`
`const char *sep = "";`	`const char *sep = "";`
`tree tmp;`	`tree tmp;`

`pp_string (buffer, "MEM[");`	`pp_string (buffer, "MEM[");`

`tmp = TMR_SYMBOL (node);`	`tmp = TMR_SYMBOL (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "symbol: ");`	`pp_string (buffer, "symbol: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_BASE (node);`	`tmp = TMR_BASE (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "base: ");`	`pp_string (buffer, "base: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_INDEX (node);`	`tmp = TMR_INDEX (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "index: ");`	`pp_string (buffer, "index: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_STEP (node);`	`tmp = TMR_STEP (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "step: ");`	`pp_string (buffer, "step: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`tmp = TMR_OFFSET (node);`	`tmp = TMR_OFFSET (node);`
`if (tmp)`	`if (tmp)`
`{`	`{`
`pp_string (buffer, sep);`	`pp_string (buffer, sep);`
`sep = ", ";`	`sep = ", ";`
`pp_string (buffer, "offset: ");`	`pp_string (buffer, "offset: ");`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`
`}`	`}`
`pp_string (buffer, "]");`	`pp_string (buffer, "]");`
`if (flags & TDF_DETAILS)`	`if (flags & TDF_DETAILS)`
`{`	`{`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,`	`dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,`
`false);`	`false);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case ARRAY_TYPE:`	`case ARRAY_TYPE:`
`{`	`{`
`tree tmp;`	`tree tmp;`

`/* Print the innermost component type. */`	`/* Print the innermost component type. */`
`for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;`	`for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;`
`tmp = TREE_TYPE (tmp))`	`tmp = TREE_TYPE (tmp))`
`;`	`;`
`dump_generic_node (buffer, tmp, spc, flags, false);`	`dump_generic_node (buffer, tmp, spc, flags, false);`

`/* Print the dimensions. */`	`/* Print the dimensions. */`
`for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))`	`for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))`
`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`	`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`
`break;`	`break;`
`}`	`}`

`case RECORD_TYPE:`	`case RECORD_TYPE:`
`case UNION_TYPE:`	`case UNION_TYPE:`
`case QUAL_UNION_TYPE:`	`case QUAL_UNION_TYPE:`
`{`	`{`
`unsigned int quals = TYPE_QUALS (node);`	`unsigned int quals = TYPE_QUALS (node);`

`if (quals & TYPE_QUAL_CONST)`	`if (quals & TYPE_QUAL_CONST)`
`pp_string (buffer, "const ");`	`pp_string (buffer, "const ");`
`if (quals & TYPE_QUAL_VOLATILE)`	`if (quals & TYPE_QUAL_VOLATILE)`
`pp_string (buffer, "volatile ");`	`pp_string (buffer, "volatile ");`

`/* Print the name of the structure. */`	`/* Print the name of the structure. */`
`if (TREE_CODE (node) == RECORD_TYPE)`	`if (TREE_CODE (node) == RECORD_TYPE)`
`pp_string (buffer, "struct ");`	`pp_string (buffer, "struct ");`
`else if (TREE_CODE (node) == UNION_TYPE)`	`else if (TREE_CODE (node) == UNION_TYPE)`
`pp_string (buffer, "union ");`	`pp_string (buffer, "union ");`

`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);`	`dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);`
`else if (!(flags & TDF_SLIM))`	`else if (!(flags & TDF_SLIM))`
`/* FIXME: If we eliminate the 'else' above and attempt`	`/* FIXME: If we eliminate the 'else' above and attempt`
`to show the fields for named types, we may get stuck`	`to show the fields for named types, we may get stuck`
`following a cycle of pointers to structs. The alleged`	`following a cycle of pointers to structs. The alleged`
`self-reference check in print_struct_decl will not detect`	`self-reference check in print_struct_decl will not detect`
`cycles involving more than one pointer or struct type. */`	`cycles involving more than one pointer or struct type. */`
`print_struct_decl (buffer, node, spc, flags);`	`print_struct_decl (buffer, node, spc, flags);`
`break;`	`break;`
`}`	`}`

`case LANG_TYPE:`	`case LANG_TYPE:`
`NIY;`	`NIY;`
`break;`	`break;`

`case INTEGER_CST:`	`case INTEGER_CST:`
`if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)`	`if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)`
`{`	`{`
`/* In the case of a pointer, one may want to divide by the`	`/* In the case of a pointer, one may want to divide by the`
`size of the pointed-to type. Unfortunately, this not`	`size of the pointed-to type. Unfortunately, this not`
`straightforward. The C front-end maps expressions`	`straightforward. The C front-end maps expressions`

`(int *) 5`	`(int *) 5`
`int *p; (p + 5)`	`int *p; (p + 5)`

`in such a way that the two INTEGER_CST nodes for "5" have`	`in such a way that the two INTEGER_CST nodes for "5" have`
`different values but identical types. In the latter`	`different values but identical types. In the latter`
`case, the 5 is multiplied by sizeof (int) in c-common.c`	`case, the 5 is multiplied by sizeof (int) in c-common.c`
`(pointer_int_sum) to convert it to a byte address, and`	`(pointer_int_sum) to convert it to a byte address, and`
`yet the type of the node is left unchanged. Argh. What`	`yet the type of the node is left unchanged. Argh. What`
`is consistent though is that the number value corresponds`	`is consistent though is that the number value corresponds`
`to bytes (UNITS) offset.`	`to bytes (UNITS) offset.`

`NB: Neither of the following divisors can be trivially`	`NB: Neither of the following divisors can be trivially`
`used to recover the original literal:`	`used to recover the original literal:`

`TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))`	`TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))`
`TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */`	`TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`
`pp_string (buffer, "B"); /* pseudo-unit */`	`pp_string (buffer, "B"); /* pseudo-unit */`
`}`	`}`
`else if (! host_integerp (node, 0))`	`else if (! host_integerp (node, 0))`
`{`	`{`
`tree val = node;`	`tree val = node;`
`unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);`	`unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);`
`HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);`	`HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);`

`if (tree_int_cst_sgn (val) < 0)`	`if (tree_int_cst_sgn (val) < 0)`
`{`	`{`
`pp_character (buffer, '-');`	`pp_character (buffer, '-');`
`high = ~high + !low;`	`high = ~high + !low;`
`low = -low;`	`low = -low;`
`}`	`}`
`/* Would "%x%0x" or "%x%0x" get zero-padding on all`	`/* Would "%x%0x" or "%x%0x" get zero-padding on all`
`systems? */`	`systems? */`
`sprintf (pp_buffer (buffer)->digit_buffer,`	`sprintf (pp_buffer (buffer)->digit_buffer,`
`HOST_WIDE_INT_PRINT_DOUBLE_HEX,`	`HOST_WIDE_INT_PRINT_DOUBLE_HEX,`
`(unsigned HOST_WIDE_INT) high, low);`	`(unsigned HOST_WIDE_INT) high, low);`
`pp_string (buffer, pp_buffer (buffer)->digit_buffer);`	`pp_string (buffer, pp_buffer (buffer)->digit_buffer);`
`}`	`}`
`else`	`else`
`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`	`pp_wide_integer (buffer, TREE_INT_CST_LOW (node));`
`break;`	`break;`

`case REAL_CST:`	`case REAL_CST:`
`/* Code copied from print_node. */`	`/* Code copied from print_node. */`
`{`	`{`
`REAL_VALUE_TYPE d;`	`REAL_VALUE_TYPE d;`
`if (TREE_OVERFLOW (node))`	`if (TREE_OVERFLOW (node))`
`pp_string (buffer, " overflow");`	`pp_string (buffer, " overflow");`

`#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)`	`#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)`
`d = TREE_REAL_CST (node);`	`d = TREE_REAL_CST (node);`
`if (REAL_VALUE_ISINF (d))`	`if (REAL_VALUE_ISINF (d))`
`pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");`	`pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");`
`else if (REAL_VALUE_ISNAN (d))`	`else if (REAL_VALUE_ISNAN (d))`
`pp_string (buffer, " Nan");`	`pp_string (buffer, " Nan");`
`else`	`else`
`{`	`{`
`char string[100];`	`char string[100];`
`real_to_decimal (string, &d, sizeof (string), 0, 1);`	`real_to_decimal (string, &d, sizeof (string), 0, 1);`
`pp_string (buffer, string);`	`pp_string (buffer, string);`
`}`	`}`
`#else`	`#else`
`{`	`{`
`HOST_WIDE_INT i;`	`HOST_WIDE_INT i;`
`unsigned char p = (unsigned char ) &TREE_REAL_CST (node);`	`unsigned char p = (unsigned char ) &TREE_REAL_CST (node);`
`pp_string (buffer, "0x");`	`pp_string (buffer, "0x");`
`for (i = 0; i < sizeof TREE_REAL_CST (node); i++)`	`for (i = 0; i < sizeof TREE_REAL_CST (node); i++)`
`output_formatted_integer (buffer, "%02x", *p++);`	`output_formatted_integer (buffer, "%02x", *p++);`
`}`	`}`
`#endif`	`#endif`
`break;`	`break;`
`}`	`}`

`case FIXED_CST:`	`case FIXED_CST:`
`{`	`{`
`char string[100];`	`char string[100];`
`fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));`	`fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));`
`pp_string (buffer, string);`	`pp_string (buffer, string);`
`break;`	`break;`
`}`	`}`

`case COMPLEX_CST:`	`case COMPLEX_CST:`
`pp_string (buffer, "__complex__ (");`	`pp_string (buffer, "__complex__ (");`
`dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`break;`	`break;`

`case STRING_CST:`	`case STRING_CST:`
`pp_string (buffer, "\"");`	`pp_string (buffer, "\"");`
`pretty_print_string (buffer, TREE_STRING_POINTER (node));`	`pretty_print_string (buffer, TREE_STRING_POINTER (node));`
`pp_string (buffer, "\"");`	`pp_string (buffer, "\"");`
`break;`	`break;`

`case VECTOR_CST:`	`case VECTOR_CST:`
`{`	`{`
`tree elt;`	`tree elt;`
`pp_string (buffer, "{ ");`	`pp_string (buffer, "{ ");`
`for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))`	`for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))`
`{`	`{`
`dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);`	`dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);`
`if (TREE_CHAIN (elt))`	`if (TREE_CHAIN (elt))`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`}`	`}`
`pp_string (buffer, " }");`	`pp_string (buffer, " }");`
`}`	`}`
`break;`	`break;`

`case FUNCTION_TYPE:`	`case FUNCTION_TYPE:`
`case METHOD_TYPE:`	`case METHOD_TYPE:`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`if (TREE_CODE (node) == METHOD_TYPE)`	`if (TREE_CODE (node) == METHOD_TYPE)`
`{`	`{`
`if (TYPE_METHOD_BASETYPE (node))`	`if (TYPE_METHOD_BASETYPE (node))`
`dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),`	`dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),`
`flags);`	`flags);`
`else`	`else`
`pp_string (buffer, "<null method basetype>");`	`pp_string (buffer, "<null method basetype>");`
`pp_string (buffer, "::");`	`pp_string (buffer, "::");`
`}`	`}`
`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`	`if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))`
`dump_decl_name (buffer, TYPE_NAME (node), flags);`	`dump_decl_name (buffer, TYPE_NAME (node), flags);`
`else`	`else`
`pp_printf (buffer, "<T%x>", TYPE_UID (node));`	`pp_printf (buffer, "<T%x>", TYPE_UID (node));`
`dump_function_declaration (buffer, node, spc, flags);`	`dump_function_declaration (buffer, node, spc, flags);`
`break;`	`break;`

`case FUNCTION_DECL:`	`case FUNCTION_DECL:`
`case CONST_DECL:`	`case CONST_DECL:`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`break;`	`break;`

`case LABEL_DECL:`	`case LABEL_DECL:`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else if (LABEL_DECL_UID (node) != -1)`	`else if (LABEL_DECL_UID (node) != -1)`
`pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));`	`pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));`
`else`	`else`
`{`	`{`
`if (flags & TDF_NOUID)`	`if (flags & TDF_NOUID)`
`pp_string (buffer, "<D.xxxx>");`	`pp_string (buffer, "<D.xxxx>");`
`else`	`else`
`pp_printf (buffer, "<D.%u>", DECL_UID (node));`	`pp_printf (buffer, "<D.%u>", DECL_UID (node));`
`}`	`}`
`break;`	`break;`

`case TYPE_DECL:`	`case TYPE_DECL:`
`if (DECL_IS_BUILTIN (node))`	`if (DECL_IS_BUILTIN (node))`
`{`	`{`
`/* Don't print the declaration of built-in types. */`	`/* Don't print the declaration of built-in types. */`
`break;`	`break;`
`}`	`}`
`if (DECL_NAME (node))`	`if (DECL_NAME (node))`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`else`	`else`
`{`	`{`
`if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`	`if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`
`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`	`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`
`&& TYPE_METHODS (TREE_TYPE (node)))`	`&& TYPE_METHODS (TREE_TYPE (node)))`
`{`	`{`
`/* The type is a c++ class: all structures have at least`	`/* The type is a c++ class: all structures have at least`
`4 methods. */`	`4 methods. */`
`pp_string (buffer, "class ");`	`pp_string (buffer, "class ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`else`	`else`
`{`	`{`
`pp_string (buffer,`	`pp_string (buffer,`
`(TREE_CODE (TREE_TYPE (node)) == UNION_TYPE`	`(TREE_CODE (TREE_TYPE (node)) == UNION_TYPE`
`? "union" : "struct "));`	`? "union" : "struct "));`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case VAR_DECL:`	`case VAR_DECL:`
`case PARM_DECL:`	`case PARM_DECL:`
`case FIELD_DECL:`	`case FIELD_DECL:`
`case DEBUG_EXPR_DECL:`	`case DEBUG_EXPR_DECL:`
`case NAMESPACE_DECL:`	`case NAMESPACE_DECL:`
`dump_decl_name (buffer, node, flags);`	`dump_decl_name (buffer, node, flags);`
`break;`	`break;`

`case RESULT_DECL:`	`case RESULT_DECL:`
`pp_string (buffer, "<retval>");`	`pp_string (buffer, "<retval>");`
`break;`	`break;`

`case COMPONENT_REF:`	`case COMPONENT_REF:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`str = ".";`	`str = ".";`
`if (op0 && TREE_CODE (op0) == INDIRECT_REF)`	`if (op0 && TREE_CODE (op0) == INDIRECT_REF)`
`{`	`{`
`op0 = TREE_OPERAND (op0, 0);`	`op0 = TREE_OPERAND (op0, 0);`
`str = "->";`	`str = "->";`
`}`	`}`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`pp_string (buffer, str);`	`pp_string (buffer, str);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`op0 = component_ref_field_offset (node);`	`op0 = component_ref_field_offset (node);`
`if (op0 && TREE_CODE (op0) != INTEGER_CST)`	`if (op0 && TREE_CODE (op0) != INTEGER_CST)`
`{`	`{`
`pp_string (buffer, "{off: ");`	`pp_string (buffer, "{off: ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case BIT_FIELD_REF:`	`case BIT_FIELD_REF:`
`pp_string (buffer, "BIT_FIELD_REF <");`	`pp_string (buffer, "BIT_FIELD_REF <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case ARRAY_REF:`	`case ARRAY_REF:`
`case ARRAY_RANGE_REF:`	`case ARRAY_RANGE_REF:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`pp_character (buffer, '[');`	`pp_character (buffer, '[');`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`if (TREE_CODE (node) == ARRAY_RANGE_REF)`	`if (TREE_CODE (node) == ARRAY_RANGE_REF)`
`pp_string (buffer, " ...");`	`pp_string (buffer, " ...");`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`

`op0 = array_ref_low_bound (node);`	`op0 = array_ref_low_bound (node);`
`op1 = array_ref_element_size (node);`	`op1 = array_ref_element_size (node);`

`if (!integer_zerop (op0)`	`if (!integer_zerop (op0)`
`\|\| TREE_OPERAND (node, 2)`	`\|\| TREE_OPERAND (node, 2)`
`\|\| TREE_OPERAND (node, 3))`	`\|\| TREE_OPERAND (node, 3))`
`{`	`{`
`pp_string (buffer, "{lb: ");`	`pp_string (buffer, "{lb: ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_string (buffer, " sz: ");`	`pp_string (buffer, " sz: ");`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case CONSTRUCTOR:`	`case CONSTRUCTOR:`
`{`	`{`
`unsigned HOST_WIDE_INT ix;`	`unsigned HOST_WIDE_INT ix;`
`tree field, val;`	`tree field, val;`
`bool is_struct_init = FALSE;`	`bool is_struct_init = FALSE;`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`	`if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE`
`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`	`\|\| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)`
`is_struct_init = TRUE;`	`is_struct_init = TRUE;`
`FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)`	`FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)`
`{`	`{`
`if (field && is_struct_init)`	`if (field && is_struct_init)`
`{`	`{`
`pp_character (buffer, '.');`	`pp_character (buffer, '.');`
`dump_generic_node (buffer, field, spc, flags, false);`	`dump_generic_node (buffer, field, spc, flags, false);`
`pp_string (buffer, "=");`	`pp_string (buffer, "=");`
`}`	`}`
`if (val && TREE_CODE (val) == ADDR_EXPR)`	`if (val && TREE_CODE (val) == ADDR_EXPR)`
`if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)`	`if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)`
`val = TREE_OPERAND (val, 0);`	`val = TREE_OPERAND (val, 0);`
`if (val && TREE_CODE (val) == FUNCTION_DECL)`	`if (val && TREE_CODE (val) == FUNCTION_DECL)`
`dump_decl_name (buffer, val, flags);`	`dump_decl_name (buffer, val, flags);`
`else`	`else`
`dump_generic_node (buffer, val, spc, flags, false);`	`dump_generic_node (buffer, val, spc, flags, false);`
`if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)`	`if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case COMPOUND_EXPR:`	`case COMPOUND_EXPR:`
`{`	`{`
`tree *tp;`	`tree *tp;`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, "<COMPOUND_EXPR>");`	`pp_string (buffer, "<COMPOUND_EXPR>");`
`break;`	`break;`
`}`	`}`

`dump_generic_node (buffer, TREE_OPERAND (node, 0),`	`dump_generic_node (buffer, TREE_OPERAND (node, 0),`
`spc, flags, !(flags & TDF_SLIM));`	`spc, flags, !(flags & TDF_SLIM));`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`

`for (tp = &TREE_OPERAND (node, 1);`	`for (tp = &TREE_OPERAND (node, 1);`
`TREE_CODE (*tp) == COMPOUND_EXPR;`	`TREE_CODE (*tp) == COMPOUND_EXPR;`
`tp = &TREE_OPERAND (*tp, 1))`	`tp = &TREE_OPERAND (*tp, 1))`
`{`	`{`
`dump_generic_node (buffer, TREE_OPERAND (*tp, 0),`	`dump_generic_node (buffer, TREE_OPERAND (*tp, 0),`
`spc, flags, !(flags & TDF_SLIM));`	`spc, flags, !(flags & TDF_SLIM));`
`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`

`dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));`	`dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));`
`}`	`}`
`break;`	`break;`

`case STATEMENT_LIST:`	`case STATEMENT_LIST:`
`{`	`{`
`tree_stmt_iterator si;`	`tree_stmt_iterator si;`
`bool first = true;`	`bool first = true;`

`if (flags & TDF_SLIM)`	`if (flags & TDF_SLIM)`
`{`	`{`
`pp_string (buffer, "<STATEMENT_LIST>");`	`pp_string (buffer, "<STATEMENT_LIST>");`
`break;`	`break;`
`}`	`}`

`for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))`	`for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))`
`{`	`{`
`if (!first)`	`if (!first)`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`else`	`else`
`first = false;`	`first = false;`
`dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);`	`dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`case INIT_EXPR:`	`case INIT_EXPR:`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,`
`false);`	`false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`if (TREE_CODE (node) == MODIFY_EXPR`	`if (TREE_CODE (node) == MODIFY_EXPR`
`&& MOVE_NONTEMPORAL (node))`	`&& MOVE_NONTEMPORAL (node))`
`pp_string (buffer, "{nt}");`	`pp_string (buffer, "{nt}");`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,`
`false);`	`false);`
`break;`	`break;`

`case TARGET_EXPR:`	`case TARGET_EXPR:`
`pp_string (buffer, "TARGET_EXPR <");`	`pp_string (buffer, "TARGET_EXPR <");`
`dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);`	`dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);`	`dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case DECL_EXPR:`	`case DECL_EXPR:`
`print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);`	`print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);`
`is_stmt = false;`	`is_stmt = false;`
`break;`	`break;`

`case COND_EXPR:`	`case COND_EXPR:`
`if (TREE_TYPE (node) == NULL \|\| TREE_TYPE (node) == void_type_node)`	`if (TREE_TYPE (node) == NULL \|\| TREE_TYPE (node) == void_type_node)`
`{`	`{`
`pp_string (buffer, "if (");`	`pp_string (buffer, "if (");`
`dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);`	`dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`/* The lowered cond_exprs should always be printed in full. */`	`/* The lowered cond_exprs should always be printed in full. */`
`if (COND_EXPR_THEN (node)`	`if (COND_EXPR_THEN (node)`
`&& (IS_EMPTY_STMT (COND_EXPR_THEN (node))`	`&& (IS_EMPTY_STMT (COND_EXPR_THEN (node))`
`\|\| TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)`	`\|\| TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)`
`&& COND_EXPR_ELSE (node)`	`&& COND_EXPR_ELSE (node)`
`&& (IS_EMPTY_STMT (COND_EXPR_ELSE (node))`	`&& (IS_EMPTY_STMT (COND_EXPR_ELSE (node))`
`\|\| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))`	`\|\| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, COND_EXPR_THEN (node),`	`dump_generic_node (buffer, COND_EXPR_THEN (node),`
`0, flags, true);`	`0, flags, true);`
`if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))`	`if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))`
`{`	`{`
`pp_string (buffer, " else ");`	`pp_string (buffer, " else ");`
`dump_generic_node (buffer, COND_EXPR_ELSE (node),`	`dump_generic_node (buffer, COND_EXPR_ELSE (node),`
`0, flags, true);`	`0, flags, true);`
`}`	`}`
`}`	`}`
`else if (!(flags & TDF_SLIM))`	`else if (!(flags & TDF_SLIM))`
`{`	`{`
`/* Output COND_EXPR_THEN. */`	`/* Output COND_EXPR_THEN. */`
`if (COND_EXPR_THEN (node))`	`if (COND_EXPR_THEN (node))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,`	`dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,`
`flags, true);`	`flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`

`/* Output COND_EXPR_ELSE. */`	`/* Output COND_EXPR_ELSE. */`
`if (COND_EXPR_ELSE (node)`	`if (COND_EXPR_ELSE (node)`
`&& !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))`	`&& !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))`
`{`	`{`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer, "else");`	`pp_string (buffer, "else");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,`	`dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,`
`flags, true);`	`flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`}`	`}`
`else`	`else`
`{`	`{`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '?');`	`pp_character (buffer, '?');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`}`	`}`
`break;`	`break;`

`case BIND_EXPR:`	`case BIND_EXPR:`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`if (BIND_EXPR_VARS (node))`	`if (BIND_EXPR_VARS (node))`
`{`	`{`
`pp_newline (buffer);`	`pp_newline (buffer);`

`for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))`	`for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))`
`{`	`{`
`print_declaration (buffer, op0, spc+2, flags);`	`print_declaration (buffer, op0, spc+2, flags);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`}`	`}`

`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);`	`dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case CALL_EXPR:`	`case CALL_EXPR:`
`print_call_name (buffer, CALL_EXPR_FN (node), flags);`	`print_call_name (buffer, CALL_EXPR_FN (node), flags);`

`/* Print parameters. */`	`/* Print parameters. */`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`{`	`{`
`tree arg;`	`tree arg;`
`call_expr_arg_iterator iter;`	`call_expr_arg_iterator iter;`
`FOR_EACH_CALL_EXPR_ARG (arg, iter, node)`	`FOR_EACH_CALL_EXPR_ARG (arg, iter, node)`
`{`	`{`
`dump_generic_node (buffer, arg, spc, flags, false);`	`dump_generic_node (buffer, arg, spc, flags, false);`
`if (more_call_expr_args_p (&iter))`	`if (more_call_expr_args_p (&iter))`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`}`	`}`
`}`	`}`
`if (CALL_EXPR_VA_ARG_PACK (node))`	`if (CALL_EXPR_VA_ARG_PACK (node))`
`{`	`{`
`if (call_expr_nargs (node) > 0)`	`if (call_expr_nargs (node) > 0)`
`{`	`{`
`pp_character (buffer, ',');`	`pp_character (buffer, ',');`
`pp_space (buffer);`	`pp_space (buffer);`
`}`	`}`
`pp_string (buffer, "__builtin_va_arg_pack ()");`	`pp_string (buffer, "__builtin_va_arg_pack ()");`
`}`	`}`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`

`op1 = CALL_EXPR_STATIC_CHAIN (node);`	`op1 = CALL_EXPR_STATIC_CHAIN (node);`
`if (op1)`	`if (op1)`
`{`	`{`
`pp_string (buffer, " [static-chain: ");`	`pp_string (buffer, " [static-chain: ");`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`

`if (CALL_EXPR_RETURN_SLOT_OPT (node))`	`if (CALL_EXPR_RETURN_SLOT_OPT (node))`
`pp_string (buffer, " [return slot optimization]");`	`pp_string (buffer, " [return slot optimization]");`
`if (CALL_EXPR_TAILCALL (node))`	`if (CALL_EXPR_TAILCALL (node))`
`pp_string (buffer, " [tail call]");`	`pp_string (buffer, " [tail call]");`
`break;`	`break;`

`case WITH_CLEANUP_EXPR:`	`case WITH_CLEANUP_EXPR:`
`NIY;`	`NIY;`
`break;`	`break;`

`case CLEANUP_POINT_EXPR:`	`case CLEANUP_POINT_EXPR:`
`pp_string (buffer, "<<cleanup_point ");`	`pp_string (buffer, "<<cleanup_point ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">>");`	`pp_string (buffer, ">>");`
`break;`	`break;`

`case PLACEHOLDER_EXPR:`	`case PLACEHOLDER_EXPR:`
`pp_string (buffer, "<PLACEHOLDER_EXPR ");`	`pp_string (buffer, "<PLACEHOLDER_EXPR ");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`/* Binary arithmetic and logic expressions. */`	`/* Binary arithmetic and logic expressions. */`
`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`case MULT_EXPR:`	`case MULT_EXPR:`
`case PLUS_EXPR:`	`case PLUS_EXPR:`
`case POINTER_PLUS_EXPR:`	`case POINTER_PLUS_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`case LT_EXPR:`	`case LT_EXPR:`
`case LE_EXPR:`	`case LE_EXPR:`
`case GT_EXPR:`	`case GT_EXPR:`
`case GE_EXPR:`	`case GE_EXPR:`
`case EQ_EXPR:`	`case EQ_EXPR:`
`case NE_EXPR:`	`case NE_EXPR:`
`case UNLT_EXPR:`	`case UNLT_EXPR:`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`case LTGT_EXPR:`	`case LTGT_EXPR:`
`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`{`	`{`
`const char *op = op_symbol (node);`	`const char *op = op_symbol (node);`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`op1 = TREE_OPERAND (node, 1);`	`op1 = TREE_OPERAND (node, 1);`

`/* When the operands are expressions with less priority,`	`/* When the operands are expressions with less priority,`
`keep semantics of the tree representation. */`	`keep semantics of the tree representation. */`
`if (op_prio (op0) <= op_prio (node))`	`if (op_prio (op0) <= op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`

`pp_space (buffer);`	`pp_space (buffer);`
`pp_string (buffer, op);`	`pp_string (buffer, op);`
`pp_space (buffer);`	`pp_space (buffer);`

`/* When the operands are expressions with less priority,`	`/* When the operands are expressions with less priority,`
`keep semantics of the tree representation. */`	`keep semantics of the tree representation. */`
`if (op_prio (op1) <= op_prio (node))`	`if (op_prio (op1) <= op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, op1, spc, flags, false);`	`dump_generic_node (buffer, op1, spc, flags, false);`
`}`	`}`
`break;`	`break;`

`/* Unary arithmetic and logic expressions. */`	`/* Unary arithmetic and logic expressions. */`
`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`if (TREE_CODE (node) == ADDR_EXPR`	`if (TREE_CODE (node) == ADDR_EXPR`
`&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST`	`&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST`
`\|\| TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))`	`\|\| TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))`
`; /* Do not output '&' for strings and function pointers. */`	`; /* Do not output '&' for strings and function pointers. */`
`else`	`else`
`pp_string (buffer, op_symbol (node));`	`pp_string (buffer, op_symbol (node));`

`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`	`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`

`if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)`	`if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)`
`{`	`{`
`pp_string (buffer, "{misalignment: ");`	`pp_string (buffer, "{misalignment: ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`break;`	`break;`

`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`	`if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`else`	`else`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, op_symbol (node));`	`pp_string (buffer, op_symbol (node));`
`break;`	`break;`

`case MIN_EXPR:`	`case MIN_EXPR:`
`pp_string (buffer, "MIN_EXPR <");`	`pp_string (buffer, "MIN_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case MAX_EXPR:`	`case MAX_EXPR:`
`pp_string (buffer, "MAX_EXPR <");`	`pp_string (buffer, "MAX_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case ABS_EXPR:`	`case ABS_EXPR:`
`pp_string (buffer, "ABS_EXPR <");`	`pp_string (buffer, "ABS_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case RANGE_EXPR:`	`case RANGE_EXPR:`
`NIY;`	`NIY;`
`break;`	`break;`

`case ADDR_SPACE_CONVERT_EXPR:`	`case ADDR_SPACE_CONVERT_EXPR:`
`case FIXED_CONVERT_EXPR:`	`case FIXED_CONVERT_EXPR:`
`case FIX_TRUNC_EXPR:`	`case FIX_TRUNC_EXPR:`
`case FLOAT_EXPR:`	`case FLOAT_EXPR:`
`CASE_CONVERT:`	`CASE_CONVERT:`
`type = TREE_TYPE (node);`	`type = TREE_TYPE (node);`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (type != TREE_TYPE (op0))`	`if (type != TREE_TYPE (op0))`
`{`	`{`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, type, spc, flags, false);`	`dump_generic_node (buffer, type, spc, flags, false);`
`pp_string (buffer, ") ");`	`pp_string (buffer, ") ");`
`}`	`}`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`if (op_prio (op0) < op_prio (node))`	`if (op_prio (op0) < op_prio (node))`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case VIEW_CONVERT_EXPR:`	`case VIEW_CONVERT_EXPR:`
`pp_string (buffer, "VIEW_CONVERT_EXPR<");`	`pp_string (buffer, "VIEW_CONVERT_EXPR<");`
`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);`
`pp_string (buffer, ">(");`	`pp_string (buffer, ">(");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case PAREN_EXPR:`	`case PAREN_EXPR:`
`pp_string (buffer, "((");`	`pp_string (buffer, "((");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, "))");`	`pp_string (buffer, "))");`
`break;`	`break;`

`case NON_LVALUE_EXPR:`	`case NON_LVALUE_EXPR:`
`pp_string (buffer, "NON_LVALUE_EXPR <");`	`pp_string (buffer, "NON_LVALUE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case SAVE_EXPR:`	`case SAVE_EXPR:`
`pp_string (buffer, "SAVE_EXPR <");`	`pp_string (buffer, "SAVE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`break;`	`break;`

`case COMPLEX_EXPR:`	`case COMPLEX_EXPR:`
`pp_string (buffer, "COMPLEX_EXPR <");`	`pp_string (buffer, "COMPLEX_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case CONJ_EXPR:`	`case CONJ_EXPR:`
`pp_string (buffer, "CONJ_EXPR <");`	`pp_string (buffer, "CONJ_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case REALPART_EXPR:`	`case REALPART_EXPR:`
`pp_string (buffer, "REALPART_EXPR <");`	`pp_string (buffer, "REALPART_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case IMAGPART_EXPR:`	`case IMAGPART_EXPR:`
`pp_string (buffer, "IMAGPART_EXPR <");`	`pp_string (buffer, "IMAGPART_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case VA_ARG_EXPR:`	`case VA_ARG_EXPR:`
`pp_string (buffer, "VA_ARG_EXPR <");`	`pp_string (buffer, "VA_ARG_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case TRY_FINALLY_EXPR:`	`case TRY_FINALLY_EXPR:`
`case TRY_CATCH_EXPR:`	`case TRY_CATCH_EXPR:`
`pp_string (buffer, "try");`	`pp_string (buffer, "try");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer,`	`pp_string (buffer,`
`(TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");`	`(TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case CATCH_EXPR:`	`case CATCH_EXPR:`
`pp_string (buffer, "catch (");`	`pp_string (buffer, "catch (");`
`dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);`	`dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);`	`dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case EH_FILTER_EXPR:`	`case EH_FILTER_EXPR:`
`pp_string (buffer, "<<<eh_filter (");`	`pp_string (buffer, "<<<eh_filter (");`
`dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);`	`dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);`
`pp_string (buffer, ")>>>");`	`pp_string (buffer, ")>>>");`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);`	`dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_string (buffer, "}");`	`pp_string (buffer, "}");`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case LABEL_EXPR:`	`case LABEL_EXPR:`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`/* If this is for break or continue, don't bother printing it. */`	`/* If this is for break or continue, don't bother printing it. */`
`if (DECL_NAME (op0))`	`if (DECL_NAME (op0))`
`{`	`{`
`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`	`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`
`if (strcmp (name, "break") == 0`	`if (strcmp (name, "break") == 0`
`\|\| strcmp (name, "continue") == 0)`	`\|\| strcmp (name, "continue") == 0)`
`break;`	`break;`
`}`	`}`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`if (DECL_NONLOCAL (op0))`	`if (DECL_NONLOCAL (op0))`
`pp_string (buffer, " [non-local]");`	`pp_string (buffer, " [non-local]");`
`break;`	`break;`

`case LOOP_EXPR:`	`case LOOP_EXPR:`
`pp_string (buffer, "while (1)");`	`pp_string (buffer, "while (1)");`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);`	`dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case PREDICT_EXPR:`	`case PREDICT_EXPR:`
`pp_string (buffer, "// predicted ");`	`pp_string (buffer, "// predicted ");`
`if (PREDICT_EXPR_OUTCOME (node))`	`if (PREDICT_EXPR_OUTCOME (node))`
`pp_string (buffer, "likely by ");`	`pp_string (buffer, "likely by ");`
`else`	`else`
`pp_string (buffer, "unlikely by ");`	`pp_string (buffer, "unlikely by ");`
`pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));`	`pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));`
`pp_string (buffer, " predictor.");`	`pp_string (buffer, " predictor.");`
`break;`	`break;`

`case RETURN_EXPR:`	`case RETURN_EXPR:`
`pp_string (buffer, "return");`	`pp_string (buffer, "return");`
`op0 = TREE_OPERAND (node, 0);`	`op0 = TREE_OPERAND (node, 0);`
`if (op0)`	`if (op0)`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`if (TREE_CODE (op0) == MODIFY_EXPR)`	`if (TREE_CODE (op0) == MODIFY_EXPR)`
`dump_generic_node (buffer, TREE_OPERAND (op0, 1),`	`dump_generic_node (buffer, TREE_OPERAND (op0, 1),`
`spc, flags, false);`	`spc, flags, false);`
`else`	`else`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`}`	`}`
`break;`	`break;`

`case EXIT_EXPR:`	`case EXIT_EXPR:`
`pp_string (buffer, "if (");`	`pp_string (buffer, "if (");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ") break");`	`pp_string (buffer, ") break");`
`break;`	`break;`

`case SWITCH_EXPR:`	`case SWITCH_EXPR:`
`pp_string (buffer, "switch (");`	`pp_string (buffer, "switch (");`
`dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);`	`dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`if (SWITCH_BODY (node))`	`if (SWITCH_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,`	`dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,`
`true);`	`true);`
`}`	`}`
`else`	`else`
`{`	`{`
`tree vec = SWITCH_LABELS (node);`	`tree vec = SWITCH_LABELS (node);`
`size_t i, n = TREE_VEC_LENGTH (vec);`	`size_t i, n = TREE_VEC_LENGTH (vec);`
`for (i = 0; i < n; ++i)`	`for (i = 0; i < n; ++i)`
`{`	`{`
`tree elt = TREE_VEC_ELT (vec, i);`	`tree elt = TREE_VEC_ELT (vec, i);`
`newline_and_indent (buffer, spc+4);`	`newline_and_indent (buffer, spc+4);`
`if (elt)`	`if (elt)`
`{`	`{`
`dump_generic_node (buffer, elt, spc+4, flags, false);`	`dump_generic_node (buffer, elt, spc+4, flags, false);`
`pp_string (buffer, " goto ");`	`pp_string (buffer, " goto ");`
`dump_generic_node (buffer, CASE_LABEL (elt), spc+4,`	`dump_generic_node (buffer, CASE_LABEL (elt), spc+4,`
`flags, true);`	`flags, true);`
`pp_semicolon (buffer);`	`pp_semicolon (buffer);`
`}`	`}`
`else`	`else`
`pp_string (buffer, "case ???: goto ???;");`	`pp_string (buffer, "case ???: goto ???;");`
`}`	`}`
`}`	`}`
`newline_and_indent (buffer, spc+2);`	`newline_and_indent (buffer, spc+2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case GOTO_EXPR:`	`case GOTO_EXPR:`
`op0 = GOTO_DESTINATION (node);`	`op0 = GOTO_DESTINATION (node);`
`if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))`	`if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))`
`{`	`{`
`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`	`const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));`
`if (strcmp (name, "break") == 0`	`if (strcmp (name, "break") == 0`
`\|\| strcmp (name, "continue") == 0)`	`\|\| strcmp (name, "continue") == 0)`
`{`	`{`
`pp_string (buffer, name);`	`pp_string (buffer, name);`
`break;`	`break;`
`}`	`}`
`}`	`}`
`pp_string (buffer, "goto ");`	`pp_string (buffer, "goto ");`
`dump_generic_node (buffer, op0, spc, flags, false);`	`dump_generic_node (buffer, op0, spc, flags, false);`
`break;`	`break;`

`case ASM_EXPR:`	`case ASM_EXPR:`
`pp_string (buffer, "__asm__");`	`pp_string (buffer, "__asm__");`
`if (ASM_VOLATILE_P (node))`	`if (ASM_VOLATILE_P (node))`
`pp_string (buffer, " __volatile__");`	`pp_string (buffer, " __volatile__");`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);`
`if (ASM_CLOBBERS (node))`	`if (ASM_CLOBBERS (node))`
`{`	`{`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);`	`dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);`
`}`	`}`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`break;`	`break;`

`case CASE_LABEL_EXPR:`	`case CASE_LABEL_EXPR:`
`if (CASE_LOW (node) && CASE_HIGH (node))`	`if (CASE_LOW (node) && CASE_HIGH (node))`
`{`	`{`
`pp_string (buffer, "case ");`	`pp_string (buffer, "case ");`
`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`
`pp_string (buffer, " ... ");`	`pp_string (buffer, " ... ");`
`dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);`
`}`	`}`
`else if (CASE_LOW (node))`	`else if (CASE_LOW (node))`
`{`	`{`
`pp_string (buffer, "case ");`	`pp_string (buffer, "case ");`
`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`	`dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);`
`}`	`}`
`else`	`else`
`pp_string (buffer, "default");`	`pp_string (buffer, "default");`
`pp_character (buffer, ':');`	`pp_character (buffer, ':');`
`break;`	`break;`

`case OBJ_TYPE_REF:`	`case OBJ_TYPE_REF:`
`pp_string (buffer, "OBJ_TYPE_REF(");`	`pp_string (buffer, "OBJ_TYPE_REF(");`
`dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);`
`pp_character (buffer, ';');`	`pp_character (buffer, ';');`
`dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);`
`pp_character (buffer, '-');`	`pp_character (buffer, '-');`
`pp_character (buffer, '>');`	`pp_character (buffer, '>');`
`dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);`	`dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`break;`	`break;`

`case SSA_NAME:`	`case SSA_NAME:`
`dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);`
`pp_string (buffer, "_");`	`pp_string (buffer, "_");`
`pp_decimal_int (buffer, SSA_NAME_VERSION (node));`	`pp_decimal_int (buffer, SSA_NAME_VERSION (node));`
`if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))`	`if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))`
`pp_string (buffer, "(ab)");`	`pp_string (buffer, "(ab)");`
`else if (SSA_NAME_IS_DEFAULT_DEF (node))`	`else if (SSA_NAME_IS_DEFAULT_DEF (node))`
`pp_string (buffer, "(D)");`	`pp_string (buffer, "(D)");`
`break;`	`break;`

`case WITH_SIZE_EXPR:`	`case WITH_SIZE_EXPR:`
`pp_string (buffer, "WITH_SIZE_EXPR <");`	`pp_string (buffer, "WITH_SIZE_EXPR <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case ASSERT_EXPR:`	`case ASSERT_EXPR:`
`pp_string (buffer, "ASSERT_EXPR <");`	`pp_string (buffer, "ASSERT_EXPR <");`
`dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);`	`dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case SCEV_KNOWN:`	`case SCEV_KNOWN:`
`pp_string (buffer, "scev_known");`	`pp_string (buffer, "scev_known");`
`break;`	`break;`

`case SCEV_NOT_KNOWN:`	`case SCEV_NOT_KNOWN:`
`pp_string (buffer, "scev_not_known");`	`pp_string (buffer, "scev_not_known");`
`break;`	`break;`

`case POLYNOMIAL_CHREC:`	`case POLYNOMIAL_CHREC:`
`pp_string (buffer, "{");`	`pp_string (buffer, "{");`
`dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);`
`pp_string (buffer, ", +, ");`	`pp_string (buffer, ", +, ");`
`dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);`
`pp_string (buffer, "}_");`	`pp_string (buffer, "}_");`
`dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);`	`dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);`
`is_stmt = false;`	`is_stmt = false;`
`break;`	`break;`

`case REALIGN_LOAD_EXPR:`	`case REALIGN_LOAD_EXPR:`
`pp_string (buffer, "REALIGN_LOAD <");`	`pp_string (buffer, "REALIGN_LOAD <");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, ">");`	`pp_string (buffer, ">");`
`break;`	`break;`

`case VEC_COND_EXPR:`	`case VEC_COND_EXPR:`
`pp_string (buffer, " VEC_COND_EXPR < ");`	`pp_string (buffer, " VEC_COND_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " , ");`	`pp_string (buffer, " , ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case DOT_PROD_EXPR:`	`case DOT_PROD_EXPR:`
`pp_string (buffer, " DOT_PROD_EXPR < ");`	`pp_string (buffer, " DOT_PROD_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case OMP_PARALLEL:`	`case OMP_PARALLEL:`
`pp_string (buffer, "#pragma omp parallel");`	`pp_string (buffer, "#pragma omp parallel");`
`dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);`

`dump_omp_body:`	`dump_omp_body:`
`if (!(flags & TDF_SLIM) && OMP_BODY (node))`	`if (!(flags & TDF_SLIM) && OMP_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc + 4);`	`newline_and_indent (buffer, spc + 4);`
`dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);`	`dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_TASK:`	`case OMP_TASK:`
`pp_string (buffer, "#pragma omp task");`	`pp_string (buffer, "#pragma omp task");`
`dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_FOR:`	`case OMP_FOR:`
`pp_string (buffer, "#pragma omp for");`	`pp_string (buffer, "#pragma omp for");`
`dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);`

`if (!(flags & TDF_SLIM))`	`if (!(flags & TDF_SLIM))`
`{`	`{`
`int i;`	`int i;`

`if (OMP_FOR_PRE_BODY (node))`	`if (OMP_FOR_PRE_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`spc += 4;`	`spc += 4;`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),`	`dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),`
`spc, flags, false);`	`spc, flags, false);`
`}`	`}`
`spc -= 2;`	`spc -= 2;`
`for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)`	`for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)`
`{`	`{`
`spc += 2;`	`spc += 2;`
`newline_and_indent (buffer, spc);`	`newline_and_indent (buffer, spc);`
`pp_string (buffer, "for (");`	`pp_string (buffer, "for (");`
`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),`	`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),`
`spc, flags, false);`	`spc, flags, false);`
`pp_string (buffer, "; ");`	`pp_string (buffer, "; ");`
`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),`	`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),`
`spc, flags, false);`	`spc, flags, false);`
`pp_string (buffer, "; ");`	`pp_string (buffer, "; ");`
`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),`	`dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),`
`spc, flags, false);`	`spc, flags, false);`
`pp_string (buffer, ")");`	`pp_string (buffer, ")");`
`}`	`}`
`if (OMP_FOR_BODY (node))`	`if (OMP_FOR_BODY (node))`
`{`	`{`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`newline_and_indent (buffer, spc + 4);`	`newline_and_indent (buffer, spc + 4);`
`dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,`	`dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,`
`false);`	`false);`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;`	`spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;`
`if (OMP_FOR_PRE_BODY (node))`	`if (OMP_FOR_PRE_BODY (node))`
`{`	`{`
`spc -= 4;`	`spc -= 4;`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`
`}`	`}`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case OMP_SECTIONS:`	`case OMP_SECTIONS:`
`pp_string (buffer, "#pragma omp sections");`	`pp_string (buffer, "#pragma omp sections");`
`dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_SECTION:`	`case OMP_SECTION:`
`pp_string (buffer, "#pragma omp section");`	`pp_string (buffer, "#pragma omp section");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_MASTER:`	`case OMP_MASTER:`
`pp_string (buffer, "#pragma omp master");`	`pp_string (buffer, "#pragma omp master");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_ORDERED:`	`case OMP_ORDERED:`
`pp_string (buffer, "#pragma omp ordered");`	`pp_string (buffer, "#pragma omp ordered");`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_CRITICAL:`	`case OMP_CRITICAL:`
`pp_string (buffer, "#pragma omp critical");`	`pp_string (buffer, "#pragma omp critical");`
`if (OMP_CRITICAL_NAME (node))`	`if (OMP_CRITICAL_NAME (node))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,`	`dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,`
`flags, false);`	`flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_ATOMIC:`	`case OMP_ATOMIC:`
`pp_string (buffer, "#pragma omp atomic");`	`pp_string (buffer, "#pragma omp atomic");`
`newline_and_indent (buffer, spc + 2);`	`newline_and_indent (buffer, spc + 2);`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`break;`	`break;`

`case OMP_SINGLE:`	`case OMP_SINGLE:`
`pp_string (buffer, "#pragma omp single");`	`pp_string (buffer, "#pragma omp single");`
`dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);`	`dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);`
`goto dump_omp_body;`	`goto dump_omp_body;`

`case OMP_CLAUSE:`	`case OMP_CLAUSE:`
`dump_omp_clause (buffer, node, spc, flags);`	`dump_omp_clause (buffer, node, spc, flags);`
`is_expr = false;`	`is_expr = false;`
`break;`	`break;`

`case REDUC_MAX_EXPR:`	`case REDUC_MAX_EXPR:`
`pp_string (buffer, " REDUC_MAX_EXPR < ");`	`pp_string (buffer, " REDUC_MAX_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case REDUC_MIN_EXPR:`	`case REDUC_MIN_EXPR:`
`pp_string (buffer, " REDUC_MIN_EXPR < ");`	`pp_string (buffer, " REDUC_MIN_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`pp_string (buffer, " REDUC_PLUS_EXPR < ");`	`pp_string (buffer, " REDUC_PLUS_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_WIDEN_MULT_HI_EXPR:`	`case VEC_WIDEN_MULT_HI_EXPR:`
`pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");`	`pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_WIDEN_MULT_LO_EXPR:`	`case VEC_WIDEN_MULT_LO_EXPR:`
`pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");`	`pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_UNPACK_HI_EXPR:`	`case VEC_UNPACK_HI_EXPR:`
`pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");`	`pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_UNPACK_LO_EXPR:`	`case VEC_UNPACK_LO_EXPR:`
`pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");`	`pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_UNPACK_FLOAT_HI_EXPR:`	`case VEC_UNPACK_FLOAT_HI_EXPR:`
`pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");`	`pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_UNPACK_FLOAT_LO_EXPR:`	`case VEC_UNPACK_FLOAT_LO_EXPR:`
`pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");`	`pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_PACK_TRUNC_EXPR:`	`case VEC_PACK_TRUNC_EXPR:`
`pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");`	`pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_PACK_SAT_EXPR:`	`case VEC_PACK_SAT_EXPR:`
`pp_string (buffer, " VEC_PACK_SAT_EXPR < ");`	`pp_string (buffer, " VEC_PACK_SAT_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_PACK_FIX_TRUNC_EXPR:`	`case VEC_PACK_FIX_TRUNC_EXPR:`
`pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");`	`pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case BLOCK:`	`case BLOCK:`
`dump_block_node (buffer, node, spc, flags);`	`dump_block_node (buffer, node, spc, flags);`
`break;`	`break;`

`case VEC_EXTRACT_EVEN_EXPR:`	`case VEC_EXTRACT_EVEN_EXPR:`
`pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");`	`pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_EXTRACT_ODD_EXPR:`	`case VEC_EXTRACT_ODD_EXPR:`
`pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");`	`pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_INTERLEAVE_HIGH_EXPR:`	`case VEC_INTERLEAVE_HIGH_EXPR:`
`pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");`	`pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`case VEC_INTERLEAVE_LOW_EXPR:`	`case VEC_INTERLEAVE_LOW_EXPR:`
`pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");`	`pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);`
`pp_string (buffer, ", ");`	`pp_string (buffer, ", ");`
`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);`
`pp_string (buffer, " > ");`	`pp_string (buffer, " > ");`
`break;`	`break;`

`default:`	`default:`
`NIY;`	`NIY;`
`}`	`}`

`if (is_stmt && is_expr)`	`if (is_stmt && is_expr)`
`pp_semicolon (buffer);`	`pp_semicolon (buffer);`

`/* If we're building a diagnostic, the formatted text will be written`	`/* If we're building a diagnostic, the formatted text will be written`
`into BUFFER's stream by the caller; otherwise, write it now. */`	`into BUFFER's stream by the caller; otherwise, write it now. */`
`if (!(flags & TDF_DIAGNOSTIC))`	`if (!(flags & TDF_DIAGNOSTIC))`
`pp_write_text_to_stream (buffer);`	`pp_write_text_to_stream (buffer);`

`return spc;`	`return spc;`
`}`	`}`

`/* Print the declaration of a variable. */`	`/* Print the declaration of a variable. */`

`void`	`void`
`print_declaration (pretty_printer *buffer, tree t, int spc, int flags)`	`print_declaration (pretty_printer *buffer, tree t, int spc, int flags)`
`{`	`{`
`INDENT (spc);`	`INDENT (spc);`

`if (TREE_CODE (t) == TYPE_DECL)`	`if (TREE_CODE (t) == TYPE_DECL)`
`pp_string (buffer, "typedef ");`	`pp_string (buffer, "typedef ");`

`if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))`	`if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))`
`pp_string (buffer, "register ");`	`pp_string (buffer, "register ");`

`if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))`	`if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))`
`pp_string (buffer, "extern ");`	`pp_string (buffer, "extern ");`
`else if (TREE_STATIC (t))`	`else if (TREE_STATIC (t))`
`pp_string (buffer, "static ");`	`pp_string (buffer, "static ");`

`/* Print the type and name. */`	`/* Print the type and name. */`
`if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)`	`if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)`
`{`	`{`
`tree tmp;`	`tree tmp;`

`/* Print array's type. */`	`/* Print array's type. */`
`tmp = TREE_TYPE (t);`	`tmp = TREE_TYPE (t);`
`while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)`	`while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)`
`tmp = TREE_TYPE (tmp);`	`tmp = TREE_TYPE (tmp);`
`dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);`

`/* Print variable's name. */`	`/* Print variable's name. */`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, t, spc, flags, false);`	`dump_generic_node (buffer, t, spc, flags, false);`

`/* Print the dimensions. */`	`/* Print the dimensions. */`
`tmp = TREE_TYPE (t);`	`tmp = TREE_TYPE (t);`
`while (TREE_CODE (tmp) == ARRAY_TYPE)`	`while (TREE_CODE (tmp) == ARRAY_TYPE)`
`{`	`{`
`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`	`dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);`
`tmp = TREE_TYPE (tmp);`	`tmp = TREE_TYPE (tmp);`
`}`	`}`
`}`	`}`
`else if (TREE_CODE (t) == FUNCTION_DECL)`	`else if (TREE_CODE (t) == FUNCTION_DECL)`
`{`	`{`
`dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_decl_name (buffer, t, flags);`	`dump_decl_name (buffer, t, flags);`
`dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);`	`dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Print type declaration. */`	`/* Print type declaration. */`
`dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);`	`dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);`

`/* Print variable's name. */`	`/* Print variable's name. */`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, t, spc, flags, false);`	`dump_generic_node (buffer, t, spc, flags, false);`
`}`	`}`

`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`	`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`
`{`	`{`
`pp_string (buffer, " __asm__ ");`	`pp_string (buffer, " __asm__ ");`
`pp_character (buffer, '(');`	`pp_character (buffer, '(');`
`dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);`
`pp_character (buffer, ')');`	`pp_character (buffer, ')');`
`}`	`}`

`/* The initial value of a function serves to determine whether the function`	`/* The initial value of a function serves to determine whether the function`
`is declared or defined. So the following does not apply to function`	`is declared or defined. So the following does not apply to function`
`nodes. */`	`nodes. */`
`if (TREE_CODE (t) != FUNCTION_DECL)`	`if (TREE_CODE (t) != FUNCTION_DECL)`
`{`	`{`
`/* Print the initial value. */`	`/* Print the initial value. */`
`if (DECL_INITIAL (t))`	`if (DECL_INITIAL (t))`
`{`	`{`
`pp_space (buffer);`	`pp_space (buffer);`
`pp_character (buffer, '=');`	`pp_character (buffer, '=');`
`pp_space (buffer);`	`pp_space (buffer);`
`dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);`
`}`	`}`
`}`	`}`

`if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))`	`if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))`
`{`	`{`
`pp_string (buffer, " [value-expr: ");`	`pp_string (buffer, " [value-expr: ");`
`dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);`	`dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);`
`pp_character (buffer, ']');`	`pp_character (buffer, ']');`
`}`	`}`

`pp_character (buffer, ';');`	`pp_character (buffer, ';');`
`}`	`}`


`/* Prints a structure: name, fields, and methods.`	`/* Prints a structure: name, fields, and methods.`
`FIXME: Still incomplete. */`	`FIXME: Still incomplete. */`

`static void`	`static void`
`print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)`	`print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)`
`{`	`{`
`/* Print the name of the structure. */`	`/* Print the name of the structure. */`
`if (TYPE_NAME (node))`	`if (TYPE_NAME (node))`
`{`	`{`
`INDENT (spc);`	`INDENT (spc);`
`if (TREE_CODE (node) == RECORD_TYPE)`	`if (TREE_CODE (node) == RECORD_TYPE)`
`pp_string (buffer, "struct ");`	`pp_string (buffer, "struct ");`
`else if ((TREE_CODE (node) == UNION_TYPE`	`else if ((TREE_CODE (node) == UNION_TYPE`
`\|\| TREE_CODE (node) == QUAL_UNION_TYPE))`	`\|\| TREE_CODE (node) == QUAL_UNION_TYPE))`
`pp_string (buffer, "union ");`	`pp_string (buffer, "union ");`

`dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);`	`dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);`
`}`	`}`

`/* Print the contents of the structure. */`	`/* Print the contents of the structure. */`
`pp_newline (buffer);`	`pp_newline (buffer);`
`INDENT (spc);`	`INDENT (spc);`
`pp_character (buffer, '{');`	`pp_character (buffer, '{');`
`pp_newline (buffer);`	`pp_newline (buffer);`

`/* Print the fields of the structure. */`	`/* Print the fields of the structure. */`
`{`	`{`
`tree tmp;`	`tree tmp;`
`tmp = TYPE_FIELDS (node);`	`tmp = TYPE_FIELDS (node);`
`while (tmp)`	`while (tmp)`
`{`	`{`
`/* Avoid to print recursively the structure. */`	`/* Avoid to print recursively the structure. */`
`/* FIXME : Not implemented correctly...,`	`/* FIXME : Not implemented correctly...,`
`what about the case when we have a cycle in the contain graph? ...`	`what about the case when we have a cycle in the contain graph? ...`
`Maybe this could be solved by looking at the scope in which the`	`Maybe this could be solved by looking at the scope in which the`
`structure was declared. */`	`structure was declared. */`
`if (TREE_TYPE (tmp) != node`	`if (TREE_TYPE (tmp) != node`
`&& (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE`	`&& (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE`
`\|\| TREE_TYPE (TREE_TYPE (tmp)) != node))`	`\|\| TREE_TYPE (TREE_TYPE (tmp)) != node))`
`{`	`{`
`print_declaration (buffer, tmp, spc+2, flags);`	`print_declaration (buffer, tmp, spc+2, flags);`
`pp_newline (buffer);`	`pp_newline (buffer);`
`}`	`}`
`tmp = TREE_CHAIN (tmp);`	`tmp = TREE_CHAIN (tmp);`
`}`	`}`
`}`	`}`
`INDENT (spc);`	`INDENT (spc);`
`pp_character (buffer, '}');`	`pp_character (buffer, '}');`
`}`	`}`

`/* Return the priority of the operator CODE.`	`/* Return the priority of the operator CODE.`

`From lowest to highest precedence with either left-to-right (L-R)`	`From lowest to highest precedence with either left-to-right (L-R)`
`or right-to-left (R-L) associativity]:`	`or right-to-left (R-L) associativity]:`

`1 [L-R] ,`	`1 [L-R] ,`
`2 [R-L] = += -= *= /= %= &= ^= \|= <<= >>=`	`2 [R-L] = += -= *= /= %= &= ^= \|= <<= >>=`
`3 [R-L] ?:`	`3 [R-L] ?:`
`4 [L-R] \|\|`	`4 [L-R] \|\|`
`5 [L-R] &&`	`5 [L-R] &&`
`6 [L-R] \|`	`6 [L-R] \|`
`7 [L-R] ^`	`7 [L-R] ^`
`8 [L-R] &`	`8 [L-R] &`
`9 [L-R] == !=`	`9 [L-R] == !=`
`10 [L-R] < <= > >=`	`10 [L-R] < <= > >=`
`11 [L-R] << >>`	`11 [L-R] << >>`
`12 [L-R] + -`	`12 [L-R] + -`
`13 [L-R] * / %`	`13 [L-R] * / %`
`14 [R-L] ! ~ ++ -- + - * & (type) sizeof`	`14 [R-L] ! ~ ++ -- + - * & (type) sizeof`
`15 [L-R] fn() [] -> .`	`15 [L-R] fn() [] -> .`

`unary +, - and * have higher precedence than the corresponding binary`	`unary +, - and * have higher precedence than the corresponding binary`
`operators. */`	`operators. */`

`int`	`int`
`op_code_prio (enum tree_code code)`	`op_code_prio (enum tree_code code)`
`{`	`{`
`switch (code)`	`switch (code)`
`{`	`{`
`case TREE_LIST:`	`case TREE_LIST:`
`case COMPOUND_EXPR:`	`case COMPOUND_EXPR:`
`case BIND_EXPR:`	`case BIND_EXPR:`
`return 1;`	`return 1;`

`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`case INIT_EXPR:`	`case INIT_EXPR:`
`return 2;`	`return 2;`

`case COND_EXPR:`	`case COND_EXPR:`
`return 3;`	`return 3;`

`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`return 4;`	`return 4;`

`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`return 5;`	`return 5;`

`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`return 6;`	`return 6;`

`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`return 7;`	`return 7;`

`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`return 8;`	`return 8;`

`case EQ_EXPR:`	`case EQ_EXPR:`
`case NE_EXPR:`	`case NE_EXPR:`
`return 9;`	`return 9;`

`case UNLT_EXPR:`	`case UNLT_EXPR:`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`case LTGT_EXPR:`	`case LTGT_EXPR:`
`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`case LT_EXPR:`	`case LT_EXPR:`
`case LE_EXPR:`	`case LE_EXPR:`
`case GT_EXPR:`	`case GT_EXPR:`
`case GE_EXPR:`	`case GE_EXPR:`
`return 10;`	`return 10;`

`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`return 11;`	`return 11;`

`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`case PLUS_EXPR:`	`case PLUS_EXPR:`
`case POINTER_PLUS_EXPR:`	`case POINTER_PLUS_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`return 12;`	`return 12;`

`case VEC_WIDEN_MULT_HI_EXPR:`	`case VEC_WIDEN_MULT_HI_EXPR:`
`case VEC_WIDEN_MULT_LO_EXPR:`	`case VEC_WIDEN_MULT_LO_EXPR:`
`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`case DOT_PROD_EXPR:`	`case DOT_PROD_EXPR:`
`case MULT_EXPR:`	`case MULT_EXPR:`
`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`return 13;`	`return 13;`

`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case FLOAT_EXPR:`	`case FLOAT_EXPR:`
`CASE_CONVERT:`	`CASE_CONVERT:`
`case FIX_TRUNC_EXPR:`	`case FIX_TRUNC_EXPR:`
`case TARGET_EXPR:`	`case TARGET_EXPR:`
`return 14;`	`return 14;`

`case CALL_EXPR:`	`case CALL_EXPR:`
`case ARRAY_REF:`	`case ARRAY_REF:`
`case ARRAY_RANGE_REF:`	`case ARRAY_RANGE_REF:`
`case COMPONENT_REF:`	`case COMPONENT_REF:`
`return 15;`	`return 15;`

`/* Special expressions. */`	`/* Special expressions. */`
`case MIN_EXPR:`	`case MIN_EXPR:`
`case MAX_EXPR:`	`case MAX_EXPR:`
`case ABS_EXPR:`	`case ABS_EXPR:`
`case REALPART_EXPR:`	`case REALPART_EXPR:`
`case IMAGPART_EXPR:`	`case IMAGPART_EXPR:`
`case REDUC_MAX_EXPR:`	`case REDUC_MAX_EXPR:`
`case REDUC_MIN_EXPR:`	`case REDUC_MIN_EXPR:`
`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`case VEC_UNPACK_HI_EXPR:`	`case VEC_UNPACK_HI_EXPR:`
`case VEC_UNPACK_LO_EXPR:`	`case VEC_UNPACK_LO_EXPR:`
`case VEC_UNPACK_FLOAT_HI_EXPR:`	`case VEC_UNPACK_FLOAT_HI_EXPR:`
`case VEC_UNPACK_FLOAT_LO_EXPR:`	`case VEC_UNPACK_FLOAT_LO_EXPR:`
`case VEC_PACK_TRUNC_EXPR:`	`case VEC_PACK_TRUNC_EXPR:`
`case VEC_PACK_SAT_EXPR:`	`case VEC_PACK_SAT_EXPR:`
`return 16;`	`return 16;`

`default:`	`default:`
`/* Return an arbitrarily high precedence to avoid surrounding single`	`/* Return an arbitrarily high precedence to avoid surrounding single`
`VAR_DECLs in ()s. */`	`VAR_DECLs in ()s. */`
`return 9999;`	`return 9999;`
`}`	`}`
`}`	`}`

`/* Return the priority of the operator OP. */`	`/* Return the priority of the operator OP. */`

`int`	`int`
`op_prio (const_tree op)`	`op_prio (const_tree op)`
`{`	`{`
`enum tree_code code;`	`enum tree_code code;`

`if (op == NULL)`	`if (op == NULL)`
`return 9999;`	`return 9999;`

`code = TREE_CODE (op);`	`code = TREE_CODE (op);`
`if (code == SAVE_EXPR \|\| code == NON_LVALUE_EXPR)`	`if (code == SAVE_EXPR \|\| code == NON_LVALUE_EXPR)`
`return op_prio (TREE_OPERAND (op, 0));`	`return op_prio (TREE_OPERAND (op, 0));`

`return op_code_prio (code);`	`return op_code_prio (code);`
`}`	`}`

`/* Return the symbol associated with operator CODE. */`	`/* Return the symbol associated with operator CODE. */`

`const char *`	`const char *`
`op_symbol_code (enum tree_code code)`	`op_symbol_code (enum tree_code code)`
`{`	`{`
`switch (code)`	`switch (code)`
`{`	`{`
`case MODIFY_EXPR:`	`case MODIFY_EXPR:`
`return "=";`	`return "=";`

`case TRUTH_OR_EXPR:`	`case TRUTH_OR_EXPR:`
`case TRUTH_ORIF_EXPR:`	`case TRUTH_ORIF_EXPR:`
`return "\|\|";`	`return "\|\|";`

`case TRUTH_AND_EXPR:`	`case TRUTH_AND_EXPR:`
`case TRUTH_ANDIF_EXPR:`	`case TRUTH_ANDIF_EXPR:`
`return "&&";`	`return "&&";`

`case BIT_IOR_EXPR:`	`case BIT_IOR_EXPR:`
`return "\|";`	`return "\|";`

`case TRUTH_XOR_EXPR:`	`case TRUTH_XOR_EXPR:`
`case BIT_XOR_EXPR:`	`case BIT_XOR_EXPR:`
`return "^";`	`return "^";`

`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case BIT_AND_EXPR:`	`case BIT_AND_EXPR:`
`return "&";`	`return "&";`

`case ORDERED_EXPR:`	`case ORDERED_EXPR:`
`return "ord";`	`return "ord";`
`case UNORDERED_EXPR:`	`case UNORDERED_EXPR:`
`return "unord";`	`return "unord";`

`case EQ_EXPR:`	`case EQ_EXPR:`
`return "==";`	`return "==";`
`case UNEQ_EXPR:`	`case UNEQ_EXPR:`
`return "u==";`	`return "u==";`

`case NE_EXPR:`	`case NE_EXPR:`
`return "!=";`	`return "!=";`

`case LT_EXPR:`	`case LT_EXPR:`
`return "<";`	`return "<";`
`case UNLT_EXPR:`	`case UNLT_EXPR:`
`return "u<";`	`return "u<";`

`case LE_EXPR:`	`case LE_EXPR:`
`return "<=";`	`return "<=";`
`case UNLE_EXPR:`	`case UNLE_EXPR:`
`return "u<=";`	`return "u<=";`

`case GT_EXPR:`	`case GT_EXPR:`
`return ">";`	`return ">";`
`case UNGT_EXPR:`	`case UNGT_EXPR:`
`return "u>";`	`return "u>";`

`case GE_EXPR:`	`case GE_EXPR:`
`return ">=";`	`return ">=";`
`case UNGE_EXPR:`	`case UNGE_EXPR:`
`return "u>=";`	`return "u>=";`

`case LTGT_EXPR:`	`case LTGT_EXPR:`
`return "<>";`	`return "<>";`

`case LSHIFT_EXPR:`	`case LSHIFT_EXPR:`
`return "<<";`	`return "<<";`

`case RSHIFT_EXPR:`	`case RSHIFT_EXPR:`
`return ">>";`	`return ">>";`

`case LROTATE_EXPR:`	`case LROTATE_EXPR:`
`return "r<<";`	`return "r<<";`

`case RROTATE_EXPR:`	`case RROTATE_EXPR:`
`return "r>>";`	`return "r>>";`

`case VEC_LSHIFT_EXPR:`	`case VEC_LSHIFT_EXPR:`
`return "v<<";`	`return "v<<";`

`case VEC_RSHIFT_EXPR:`	`case VEC_RSHIFT_EXPR:`
`return "v>>";`	`return "v>>";`

`case POINTER_PLUS_EXPR:`	`case POINTER_PLUS_EXPR:`
`return "+";`	`return "+";`

`case PLUS_EXPR:`	`case PLUS_EXPR:`
`return "+";`	`return "+";`

`case REDUC_PLUS_EXPR:`	`case REDUC_PLUS_EXPR:`
`return "r+";`	`return "r+";`

`case WIDEN_SUM_EXPR:`	`case WIDEN_SUM_EXPR:`
`return "w+";`	`return "w+";`

`case WIDEN_MULT_EXPR:`	`case WIDEN_MULT_EXPR:`
`return "w*";`	`return "w*";`

`case NEGATE_EXPR:`	`case NEGATE_EXPR:`
`case MINUS_EXPR:`	`case MINUS_EXPR:`
`return "-";`	`return "-";`

`case BIT_NOT_EXPR:`	`case BIT_NOT_EXPR:`
`return "~";`	`return "~";`

`case TRUTH_NOT_EXPR:`	`case TRUTH_NOT_EXPR:`
`return "!";`	`return "!";`

`case MULT_EXPR:`	`case MULT_EXPR:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`return "*";`	`return "*";`

`case ALIGN_INDIRECT_REF:`	`case ALIGN_INDIRECT_REF:`
`return "A*";`	`return "A*";`

`case MISALIGNED_INDIRECT_REF:`	`case MISALIGNED_INDIRECT_REF:`
`return "M*";`	`return "M*";`

`case TRUNC_DIV_EXPR:`	`case TRUNC_DIV_EXPR:`
`case RDIV_EXPR:`	`case RDIV_EXPR:`
`return "/";`	`return "/";`

`case CEIL_DIV_EXPR:`	`case CEIL_DIV_EXPR:`
`return "/[cl]";`	`return "/[cl]";`

`case FLOOR_DIV_EXPR:`	`case FLOOR_DIV_EXPR:`
`return "/[fl]";`	`return "/[fl]";`

`case ROUND_DIV_EXPR:`	`case ROUND_DIV_EXPR:`
`return "/[rd]";`	`return "/[rd]";`

`case EXACT_DIV_EXPR:`	`case EXACT_DIV_EXPR:`
`return "/[ex]";`	`return "/[ex]";`

`case TRUNC_MOD_EXPR:`	`case TRUNC_MOD_EXPR:`
`return "%";`	`return "%";`

`case CEIL_MOD_EXPR:`	`case CEIL_MOD_EXPR:`
`return "%[cl]";`	`return "%[cl]";`

`case FLOOR_MOD_EXPR:`	`case FLOOR_MOD_EXPR:`
`return "%[fl]";`	`return "%[fl]";`

`case ROUND_MOD_EXPR:`	`case ROUND_MOD_EXPR:`
`return "%[rd]";`	`return "%[rd]";`

`case PREDECREMENT_EXPR:`	`case PREDECREMENT_EXPR:`
`return " --";`	`return " --";`

`case PREINCREMENT_EXPR:`	`case PREINCREMENT_EXPR:`
`return " ++";`	`return " ++";`

`case POSTDECREMENT_EXPR:`	`case POSTDECREMENT_EXPR:`
`return "-- ";`	`return "-- ";`

`case POSTINCREMENT_EXPR:`	`case POSTINCREMENT_EXPR:`
`return "++ ";`	`return "++ ";`

`case MAX_EXPR:`	`case MAX_EXPR:`
`return "max";`	`return "max";`

`case MIN_EXPR:`	`case MIN_EXPR:`
`return "min";`	`return "min";`

`default:`	`default:`
`return "<<< ??? >>>";`	`return "<<< ??? >>>";`
`}`	`}`
`}`	`}`

`/* Return the symbol associated with operator OP. */`	`/* Return the symbol associated with operator OP. */`

`static const char *`	`static const char *`
`op_symbol (const_tree op)`	`op_symbol (const_tree op)`
`{`	`{`
`return op_symbol_code (TREE_CODE (op));`	`return op_symbol_code (TREE_CODE (op));`
`}`	`}`

`/* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or`	`/* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or`
`the gimple_call_fn of a GIMPLE_CALL. */`	`the gimple_call_fn of a GIMPLE_CALL. */`

`void`	`void`
`print_call_name (pretty_printer *buffer, tree node, int flags)`	`print_call_name (pretty_printer *buffer, tree node, int flags)`
`{`	`{`
`tree op0 = node;`	`tree op0 = node;`

`if (TREE_CODE (op0) == NON_LVALUE_EXPR)`	`if (TREE_CODE (op0) == NON_LVALUE_EXPR)`
`op0 = TREE_OPERAND (op0, 0);`	`op0 = TREE_OPERAND (op0, 0);`

`again:`	`again:`
`switch (TREE_CODE (op0))`	`switch (TREE_CODE (op0))`
`{`	`{`
`case VAR_DECL:`	`case VAR_DECL:`
`case PARM_DECL:`	`case PARM_DECL:`
`case FUNCTION_DECL:`	`case FUNCTION_DECL:`
`dump_function_name (buffer, op0, flags);`	`dump_function_name (buffer, op0, flags);`
`break;`	`break;`

`case ADDR_EXPR:`	`case ADDR_EXPR:`
`case INDIRECT_REF:`	`case INDIRECT_REF:`
`case NOP_EXPR:`	`case NOP_EXPR:`
`op0 = TREE_OPERAND (op0, 0);`	`op0 = TREE_OPERAND (op0, 0);`
`goto again;`	`goto again;`

`case COND_EXPR:`	`case COND_EXPR:`
`pp_string (buffer, "(");`	`pp_string (buffer, "(");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);`
`pp_string (buffer, ") ? ");`	`pp_string (buffer, ") ? ");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);`
`pp_string (buffer, " : ");`	`pp_string (buffer, " : ");`
`dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);`	`dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);`
`break;`	`break;`

`case ARRAY_REF:`	`case ARRAY_REF:`
`if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`	`if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)`
`dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);`	`dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);`
`else`	`else`
`dump_generic_node (buffer, op0, 0, flags, false);`	`dump_generic_node (buffer, op0, 0, flags, false);`
`break;`	`break;`

`case COMPONENT_REF:`	`case COMPONENT_REF:`
`case SSA_NAME:`	`case SSA_NAME:`
`case OBJ_TYPE_REF:`	`case OBJ_TYPE_REF:`
`dump_generic_node (buffer, op0, 0, flags, false);`	`dump_generic_node (buffer, op0, 0, flags, false);`
`break;`	`break;`

`default:`	`default:`
`NIY;`	`NIY;`
`}`	`}`
`}`	`}`

`/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */`	`/* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */`

`static void`	`static void`
`pretty_print_string (pretty_printer buffer, const char str)`	`pretty_print_string (pretty_printer buffer, const char str)`
`{`	`{`
`if (str == NULL)`	`if (str == NULL)`
`return;`	`return;`

`while (*str)`	`while (*str)`
`{`	`{`
`switch (str[0])`	`switch (str[0])`
`{`	`{`
`case '\b':`	`case '\b':`
`pp_string (buffer, "\\b");`	`pp_string (buffer, "\\b");`
`break;`	`break;`

`case '\f':`	`case '\f':`
`pp_string (buffer, "\\f");`	`pp_string (buffer, "\\f");`
`break;`	`break;`

`case '\n':`	`case '\n':`
`pp_string (buffer, "\\n");`	`pp_string (buffer, "\\n");`
`break;`	`break;`

`case '\r':`	`case '\r':`
`pp_string (buffer, "\\r");`	`pp_string (buffer, "\\r");`
`break;`	`break;`

`case '\t':`	`case '\t':`
`pp_string (buffer, "\\t");`	`pp_string (buffer, "\\t");`
`break;`	`break;`

`case '\v':`	`case '\v':`
`pp_string (buffer, "\\v");`	`pp_string (buffer, "\\v");`
`break;`	`break;`

`case '\\':`	`case '\\':`
`pp_string (buffer, "\\\\");`	`pp_string (buffer, "\\\\");`
`break;`	`break;`

`case '\"':`	`case '\"':`
`pp_string (buffer, "\\\"");`	`pp_string (buffer, "\\\"");`
`break;`	`break;`

`case '\'':`	`case '\'':`
`pp_string (buffer, "\\'");`	`pp_string (buffer, "\\'");`
`break;`	`break;`

`/* No need to handle \0; the loop terminates on \0. */`	`/* No need to handle \0; the loop terminates on \0. */`

`case '\1':`	`case '\1':`
`pp_string (buffer, "\\1");`	`pp_string (buffer, "\\1");`
`break;`	`break;`

`case '\2':`	`case '\2':`
`pp_string (buffer, "\\2");`	`pp_string (buffer, "\\2");`
`break;`	`break;`

`case '\3':`	`case '\3':`
`pp_string (buffer, "\\3");`	`pp_string (buffer, "\\3");`
`break;`	`break;`

`case '\4':`	`case '\4':`
`pp_string (buffer, "\\4");`	`pp_string (buffer, "\\4");`
`break;`	`break;`

`case '\5':`	`case '\5':`
`pp_string (buffer, "\\5");`	`pp_string (buffer, "\\5");`
`break;`	`break;`

`case '\6':`	`case '\6':`
`pp_string (buffer, "\\6");`	`pp_string (buffer, "\\6");`
`break;`	`break;`

`case '\7':`	`case '\7':`
`pp_string (buffer, "\\7");`	`pp_string (buffer, "\\7");`
`break;`	`break;`

`default:`	`default:`
`pp_character (buffer, str[0]);`	`pp_character (buffer, str[0]);`
`break;`	`break;`
`}`	`}`
`str++;`	`str++;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`maybe_init_pretty_print (FILE *file)`	`maybe_init_pretty_print (FILE *file)`
`{`	`{`
`if (!initialized)`	`if (!initialized)`
`{`	`{`
`pp_construct (&buffer, /* prefix /NULL, / line-width */0);`	`pp_construct (&buffer, /* prefix /NULL, / line-width */0);`
`pp_needs_newline (&buffer) = true;`	`pp_needs_newline (&buffer) = true;`
`pp_translate_identifiers (&buffer) = false;`	`pp_translate_identifiers (&buffer) = false;`
`initialized = 1;`	`initialized = 1;`
`}`	`}`

`buffer.buffer->stream = file;`	`buffer.buffer->stream = file;`
`}`	`}`

`static void`	`static void`
`newline_and_indent (pretty_printer *buffer, int spc)`	`newline_and_indent (pretty_printer *buffer, int spc)`
`{`	`{`
`pp_newline (buffer);`	`pp_newline (buffer);`
`INDENT (spc);`	`INDENT (spc);`
`}`	`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [tree-pretty-print.c] - Diff between revs 816 and 826