674 lines
16 KiB
C
674 lines
16 KiB
C
/* Prints out tree in human readable form - GNU C-compiler
|
||
Copyright (C) 1987 Free Software Foundation, Inc.
|
||
|
||
This file is part of GNU CC.
|
||
|
||
GNU CC 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 Software Foundation; either version 1, or (at your option)
|
||
any later version.
|
||
|
||
GNU CC is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GNU CC; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
|
||
#include "config.h"
|
||
#include "tree.h"
|
||
#include <stdio.h>
|
||
|
||
extern char **tree_code_name;
|
||
|
||
extern char *mode_name[];
|
||
|
||
extern char spaces[];
|
||
|
||
#define MIN(x,y) ((x < y) ? x : y)
|
||
|
||
static FILE *outfile;
|
||
|
||
extern int tree_node_counter;
|
||
|
||
/* markvec[i] is 1 if node number i has been seen already. */
|
||
|
||
static char *markvec;
|
||
|
||
static void dump ();
|
||
void dump_tree ();
|
||
|
||
void
|
||
debug_dump_tree (root)
|
||
tree root;
|
||
{
|
||
dump_tree (stderr, root);
|
||
}
|
||
|
||
void
|
||
dump_tree (outf, root)
|
||
FILE *outf;
|
||
tree root;
|
||
{
|
||
markvec = (char *) alloca (tree_node_counter + 1);
|
||
bzero (markvec, tree_node_counter + 1);
|
||
outfile = outf;
|
||
dump (root, 0);
|
||
fflush (outf);
|
||
}
|
||
|
||
static
|
||
void
|
||
wruid (node)
|
||
tree node;
|
||
{
|
||
|
||
if (node == NULL)
|
||
fputs ("<>", outfile);
|
||
else {
|
||
fprintf (outfile, "%1d", TREE_UID (node));
|
||
}
|
||
}
|
||
|
||
static
|
||
void
|
||
part (title, node)
|
||
char title[];
|
||
tree node;
|
||
{
|
||
fprintf (outfile, " %s = ", title);
|
||
wruid (node);
|
||
putc (';', outfile);
|
||
}
|
||
|
||
/* Similar to `part' but prefix with @ if value is not constant
|
||
and print the constant value if it is constant. */
|
||
static
|
||
void
|
||
cpart (title, ct, punct)
|
||
char *title;
|
||
tree ct;
|
||
char punct;
|
||
{
|
||
fprintf (outfile, " %s = ", title);
|
||
if (ct == NULL)
|
||
fputs ("<>", outfile);
|
||
else
|
||
{
|
||
if (!TREE_LITERAL (ct))
|
||
{
|
||
putc ('@', outfile);
|
||
wruid (ct);
|
||
}
|
||
else
|
||
fprintf (outfile, "%ld", TREE_INT_CST_LOW (ct));
|
||
}
|
||
putc (punct, outfile);
|
||
}
|
||
|
||
static void
|
||
walk (node, leaf, indent)
|
||
tree node;
|
||
tree leaf;
|
||
int indent;
|
||
{
|
||
if (node != NULL
|
||
/* Don't walk any global nodes reached from local nodes!
|
||
The global nodes will be dumped at the end, all together.
|
||
Also don't mention a FUNCTION_DECL node that is marked local
|
||
since it was fully described when it was dumped locally. */
|
||
&& (TREE_CODE (node) != FUNCTION_DECL
|
||
|| TREE_PERMANENT (node))
|
||
&& (TREE_PERMANENT (leaf) == TREE_PERMANENT (node)))
|
||
dump (node, indent+1);
|
||
}
|
||
|
||
static void
|
||
cwalk (s, leaf, indent)
|
||
tree s;
|
||
tree leaf;
|
||
int indent;
|
||
{
|
||
if (s != NULL)
|
||
if (!TREE_LITERAL (s))
|
||
walk (s, leaf, indent);
|
||
}
|
||
|
||
static void
|
||
prtypeinfo (node)
|
||
register tree node;
|
||
{
|
||
int first;
|
||
|
||
part ("type", TREE_TYPE (node));
|
||
first = 1;
|
||
fputs (" [", outfile);
|
||
if (TREE_EXTERNAL (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("external", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_PUBLIC (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("public", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_STATIC (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("static", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_VOLATILE (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("volatile", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_PACKED (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("packed", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_READONLY (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("readonly", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_LITERAL (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("literal", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_NONLOCAL (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("nonlocal", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_ADDRESSABLE (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("addressable", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_REGDECL (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("regdecl", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_THIS_VOLATILE (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("this_vol", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_UNSIGNED (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("unsigned", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_ASM_WRITTEN (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("asm_written", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_INLINE (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("inline", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_USED (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("used", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_PERMANENT (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("permanent", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_LANG_FLAG_1 (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("lang_flag_1", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_LANG_FLAG_2 (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("lang_flag_2", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_LANG_FLAG_3 (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("lang_flag_3", outfile);
|
||
first = 0;
|
||
}
|
||
if (TREE_LANG_FLAG_4 (node))
|
||
{
|
||
if (!first) putc (' ', outfile);
|
||
fputs ("lang_flag_4", outfile);
|
||
first = 0;
|
||
}
|
||
fputs ("] ", outfile);
|
||
}
|
||
|
||
static void
|
||
prdeclmodeinfo (node)
|
||
tree node;
|
||
{
|
||
register enum machine_mode mode = DECL_MODE (node);
|
||
fprintf (outfile, " %s;", mode_name[(int) mode]);
|
||
|
||
cpart ("size", DECL_SIZE (node), '*');
|
||
fprintf (outfile, "%d;", DECL_SIZE_UNIT (node));
|
||
|
||
fprintf (outfile, " alignment = %1d;", DECL_ALIGN (node));
|
||
}
|
||
|
||
static void
|
||
prtypemodeinfo (node)
|
||
tree node;
|
||
{
|
||
register enum machine_mode mode = TYPE_MODE (node);
|
||
fprintf (outfile, " %s;", mode_name[(int) mode]);
|
||
|
||
cpart ("size", TYPE_SIZE (node), '*');
|
||
fprintf (outfile, "%d;", TYPE_SIZE_UNIT (node));
|
||
|
||
fprintf (outfile, " alignment = %1d;", TYPE_ALIGN (node));
|
||
}
|
||
|
||
static void
|
||
skip (indent)
|
||
int indent;
|
||
{
|
||
putc ('\n',outfile);
|
||
fputs (spaces + (strlen (spaces) - (12 + MIN (40,(indent+1)*2))), outfile);
|
||
}
|
||
|
||
/* Output a description of the tree node NODE
|
||
if its description has not been output already. */
|
||
|
||
static
|
||
void
|
||
dump (node, indent)
|
||
tree node;
|
||
int indent;
|
||
{
|
||
register enum tree_code code = TREE_CODE (node);
|
||
register int i;
|
||
register int len, first_rtl;
|
||
int nochain = 0;
|
||
|
||
if (markvec[TREE_UID (node)])
|
||
return;
|
||
markvec[TREE_UID (node)] = 1;
|
||
|
||
fputs (" ", outfile);
|
||
fprintf (outfile, "%5d", TREE_UID (node));
|
||
fputs (spaces + (strlen (spaces) - MIN (40, (indent+1)*2)), outfile);
|
||
fputs (tree_code_name[(int) code], outfile);
|
||
|
||
switch (*tree_code_type[(int) code])
|
||
{
|
||
case 'd':
|
||
fputs (" name = ", outfile);
|
||
if (DECL_NAME (node) == NULL)
|
||
fputs ("<>;", outfile);
|
||
else
|
||
fprintf (outfile, "%s;",
|
||
IDENTIFIER_POINTER (DECL_NAME (node)));
|
||
if (code != PARM_DECL)
|
||
fprintf (outfile, " at %s line %d;",
|
||
DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
|
||
skip (indent);
|
||
prdeclmodeinfo (node);
|
||
prtypeinfo (node);
|
||
#ifdef PRINT_LANG_DECL
|
||
print_lang_decl (node);
|
||
#endif
|
||
skip (indent);
|
||
fprintf (outfile, " offset = %1d;", DECL_OFFSET (node));
|
||
if (DECL_VOFFSET (node) != NULL)
|
||
{
|
||
fputs ("voffset = ", outfile);
|
||
wruid (DECL_VOFFSET (node));
|
||
fprintf (outfile, "*%1d;", DECL_VOFFSET_UNIT (node));
|
||
}
|
||
part ("context", DECL_CONTEXT (node));
|
||
if (code == FUNCTION_DECL)
|
||
{
|
||
if (DECL_ARGUMENTS (node) || DECL_RESULT (node)
|
||
|| DECL_INITIAL (node))
|
||
{
|
||
skip (indent);
|
||
part ("arguments", DECL_ARGUMENTS (node));
|
||
part ("result", DECL_RESULT (node));
|
||
if ((int) (DECL_INITIAL (node)) == 1)
|
||
fprintf (outfile, " initial = const 1;");
|
||
else
|
||
part ("initial", DECL_INITIAL (node));
|
||
}
|
||
}
|
||
else if (DECL_INITIAL (node))
|
||
{
|
||
if ((int) (DECL_INITIAL (node)) == 1)
|
||
fprintf (outfile, " initial = const 1;");
|
||
else
|
||
part ("initial", DECL_INITIAL (node));
|
||
}
|
||
#ifdef PRINT_LANG_DECL
|
||
walk_lang_decl (node);
|
||
#endif
|
||
part ("chain", TREE_CHAIN (node));
|
||
/* A Decl's chain contents is not part of the decl. */
|
||
nochain = 1;
|
||
fputc ('\n', outfile);
|
||
cwalk (DECL_SIZE (node), node, indent);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
walk (DECL_VOFFSET (node), node, indent);
|
||
walk (DECL_CONTEXT (node), node, indent);
|
||
if (code == FUNCTION_DECL)
|
||
{
|
||
walk (DECL_ARGUMENTS (node), node, indent);
|
||
walk (DECL_RESULT (node), node, indent);
|
||
}
|
||
if ((int) (DECL_INITIAL (node)) != 1)
|
||
walk (DECL_INITIAL (node), node, indent);
|
||
break;
|
||
|
||
case 't':
|
||
prtypemodeinfo (node);
|
||
prtypeinfo (node);
|
||
#ifdef PRINT_LANG_TYPE
|
||
print_lang_type (node);
|
||
#endif
|
||
skip (indent);
|
||
part ("pointers_to_this", TYPE_POINTER_TO (node));
|
||
if (code == ARRAY_TYPE || code == SET_TYPE)
|
||
{
|
||
part ("domain", TYPE_DOMAIN (node));
|
||
cpart ("separation", TYPE_SEP (node), '*');
|
||
fprintf (outfile, "%d;", TYPE_SEP_UNIT (node));
|
||
}
|
||
else if (code == INTEGER_TYPE)
|
||
{
|
||
cpart ("min", TYPE_MIN_VALUE (node), ';');
|
||
cpart ("max", TYPE_MAX_VALUE (node), ';');
|
||
fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
|
||
}
|
||
else if (code == ENUMERAL_TYPE)
|
||
{
|
||
cpart ("min", TYPE_MIN_VALUE (node), ';');
|
||
cpart ("max", TYPE_MAX_VALUE (node), ';');
|
||
part ("values", TYPE_VALUES (node));
|
||
fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
|
||
}
|
||
else if (code == REAL_TYPE)
|
||
{
|
||
fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
|
||
}
|
||
else if (code == RECORD_TYPE
|
||
|| code == UNION_TYPE)
|
||
{
|
||
part ("fields", TYPE_FIELDS (node));
|
||
}
|
||
else if (code == FUNCTION_TYPE)
|
||
{
|
||
part ("arg_types", TYPE_ARG_TYPES (node));
|
||
}
|
||
else if (code == METHOD_TYPE)
|
||
{
|
||
part ("arg_types", TYPE_ARG_TYPES (node));
|
||
}
|
||
#ifdef PRINT_LANG_TYPE
|
||
walk_lang_type (node);
|
||
#endif
|
||
part ("chain", TREE_CHAIN (node));
|
||
/* A type's chain's contents are not printed because the chain of types
|
||
is not part of the meaning of any particular type. */
|
||
nochain = 1;
|
||
fputc ('\n', outfile);
|
||
cwalk (TYPE_SIZE (node), node, indent);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
walk (TYPE_VALUES (node), node, indent);
|
||
walk (TYPE_SEP (node), node, indent);
|
||
walk (TYPE_POINTER_TO (node), node, indent);
|
||
walk (TYPE_REFERENCE_TO (node), node, indent);
|
||
break;
|
||
|
||
case 'e':
|
||
case 'r':
|
||
prtypeinfo (node);
|
||
fputs (" ops =", outfile);
|
||
first_rtl = len = tree_code_length[(int) code];
|
||
/* These kinds of nodes contain rtx's, not trees,
|
||
after a certain point. Print the rtx's as rtx's. */
|
||
switch (code)
|
||
{
|
||
case SAVE_EXPR:
|
||
first_rtl = 1;
|
||
break;
|
||
case CALL_EXPR:
|
||
first_rtl = 2;
|
||
break;
|
||
case METHOD_CALL_EXPR:
|
||
first_rtl = 3;
|
||
break;
|
||
case WITH_CLEANUP_EXPR:
|
||
/* Should be defined to be 2. */
|
||
first_rtl = 1;
|
||
break;
|
||
case RTL_EXPR:
|
||
first_rtl = 0;
|
||
}
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (i >= first_rtl)
|
||
{
|
||
skip (indent);
|
||
if (TREE_OPERAND (node, i))
|
||
print_rtl (outfile, TREE_OPERAND (node, i));
|
||
else
|
||
fprintf (outfile, "(nil)");
|
||
fprintf (outfile, "\n");
|
||
}
|
||
else
|
||
{
|
||
fputs (" ", outfile);
|
||
wruid (TREE_OPERAND (node, i));
|
||
fputs (";", outfile);
|
||
}
|
||
}
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
for (i = 0; i < len && i < first_rtl; i++)
|
||
walk (TREE_OPERAND (node, i), node, indent);
|
||
break;
|
||
|
||
case 's':
|
||
prtypeinfo (node);
|
||
fprintf (outfile, " at %s line %d;",
|
||
STMT_SOURCE_FILE (node), STMT_SOURCE_LINE (node));
|
||
switch (TREE_CODE (node))
|
||
{
|
||
case IF_STMT:
|
||
part ("cond", STMT_COND (node));
|
||
part ("then", STMT_THEN (node));
|
||
part ("else", STMT_ELSE (node));
|
||
break;
|
||
|
||
case LET_STMT:
|
||
case WITH_STMT:
|
||
part ("vars", STMT_VARS (node));
|
||
part ("tags", STMT_TYPE_TAGS (node));
|
||
part ("supercontext", STMT_SUPERCONTEXT (node));
|
||
part ("bind_size", STMT_BIND_SIZE (node));
|
||
part ("body", STMT_BODY (node));
|
||
part ("subblocks", STMT_SUBBLOCKS (node));
|
||
break;
|
||
|
||
case CASE_STMT:
|
||
part ("case_index", STMT_CASE_INDEX (node));
|
||
part ("case_list", STMT_CASE_LIST (node));
|
||
break;
|
||
|
||
default:
|
||
part ("body", STMT_BODY (node));
|
||
break;
|
||
}
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
switch (TREE_CODE (node))
|
||
{
|
||
case IF_STMT:
|
||
walk (STMT_COND (node), node, indent);
|
||
walk (STMT_THEN (node), node, indent);
|
||
walk (STMT_ELSE (node), node, indent);
|
||
break;
|
||
|
||
case LET_STMT:
|
||
case WITH_STMT:
|
||
walk (STMT_VARS (node), node, indent);
|
||
walk (STMT_TYPE_TAGS (node), node, indent);
|
||
walk (STMT_SUPERCONTEXT (node), node, indent);
|
||
walk (STMT_BIND_SIZE (node), node, indent);
|
||
walk (STMT_BODY (node), node, indent);
|
||
walk (STMT_SUBBLOCKS (node), node, indent);
|
||
break;
|
||
|
||
case CASE_STMT:
|
||
walk (STMT_CASE_INDEX (node), node, indent);
|
||
walk (STMT_CASE_LIST (node), node, indent);
|
||
break;
|
||
|
||
default:
|
||
walk (STMT_BODY (node), node, indent);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case 'c':
|
||
switch (code)
|
||
{
|
||
case INTEGER_CST:
|
||
if (TREE_INT_CST_HIGH (node) == 0)
|
||
fprintf (outfile, " = %1u;", TREE_INT_CST_LOW (node));
|
||
else if (TREE_INT_CST_HIGH (node) == -1
|
||
&& TREE_INT_CST_LOW (node) != 0)
|
||
fprintf (outfile, " = -%1u;", -TREE_INT_CST_LOW (node));
|
||
else
|
||
fprintf (outfile, " = 0x%x%08x;",
|
||
TREE_INT_CST_HIGH (node),
|
||
TREE_INT_CST_LOW (node));
|
||
break;
|
||
|
||
case REAL_CST:
|
||
#ifndef REAL_IS_NOT_DOUBLE
|
||
fprintf (outfile, " = %e;", TREE_REAL_CST (node));
|
||
#else
|
||
{
|
||
int i;
|
||
char *p = (char *) &TREE_REAL_CST (node);
|
||
fprintf (outfile, " = 0x");
|
||
for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
|
||
fprintf (outfile, "%02x", *p++);
|
||
fprintf (outfile, ";");
|
||
}
|
||
#endif /* REAL_IS_NOT_DOUBLE */
|
||
break;
|
||
|
||
case COMPLEX_CST:
|
||
part ("realpart", TREE_REALPART (node));
|
||
part ("imagpart", TREE_IMAGPART (node));
|
||
walk (TREE_REALPART (node), node, indent);
|
||
walk (TREE_IMAGPART (node), node, indent);
|
||
break;
|
||
|
||
case STRING_CST:
|
||
fprintf (outfile, " = \"%s\";", TREE_STRING_POINTER (node));
|
||
}
|
||
prtypeinfo (node);
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
break;
|
||
|
||
case 'x':
|
||
if (code == IDENTIFIER_NODE)
|
||
{
|
||
fprintf (outfile, " = %s;\n", IDENTIFIER_POINTER (node));
|
||
nochain = 1;
|
||
}
|
||
else if (code == TREE_LIST)
|
||
{
|
||
prtypeinfo (node);
|
||
part ("purpose", TREE_PURPOSE (node));
|
||
part ("value", TREE_VALUE (node));
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
walk (TREE_PURPOSE (node), node, indent);
|
||
walk (TREE_VALUE (node), node, indent);
|
||
}
|
||
else if (code == TREE_VEC)
|
||
{
|
||
prtypeinfo (node);
|
||
len = TREE_VEC_LENGTH (node);
|
||
fprintf (outfile, "length = %d\n", len);
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
fputs (" ", outfile);
|
||
wruid (TREE_VEC_ELT (node, i));
|
||
fputs (";", outfile);
|
||
}
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
for (i = 0; i < len; i++)
|
||
walk (TREE_VEC_ELT (node, i), node, indent);
|
||
}
|
||
else if (code == OP_IDENTIFIER)
|
||
{
|
||
prtypeinfo (node);
|
||
part ("op1", TREE_PURPOSE (node));
|
||
part ("op2", TREE_VALUE (node));
|
||
part ("chain", TREE_CHAIN (node));
|
||
fputc ('\n', outfile);
|
||
walk (TREE_TYPE (node), node, indent);
|
||
walk (TREE_PURPOSE (node), node, indent);
|
||
walk (TREE_VALUE (node), node, indent);
|
||
}
|
||
else if (code == ERROR_MARK)
|
||
fputc ('\n', outfile);
|
||
else abort ();
|
||
|
||
break;
|
||
|
||
default:
|
||
abort ();
|
||
} /* switch */
|
||
|
||
if (TREE_CHAIN (node) != NULL && ! nochain)
|
||
dump (TREE_CHAIN (node), indent);
|
||
}
|